Release 4.14 drivers/clocksource/em_sti.c

Directory: drivers/clocksource
/*
 * Emma Mobile Timer Support - STI
 *
 *  Copyright (C) 2012 Magnus Damm
 *
 * 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
 *
 * 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.
 *
 * 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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */

#include <linux/init.h>
#include <linux/platform_device.h>
#include <linux/spinlock.h>
#include <linux/interrupt.h>
#include <linux/ioport.h>
#include <linux/io.h>
#include <linux/clk.h>
#include <linux/irq.h>
#include <linux/err.h>
#include <linux/delay.h>
#include <linux/clocksource.h>
#include <linux/clockchips.h>
#include <linux/slab.h>
#include <linux/module.h>




enum { USER_CLOCKSOURCE, USER_CLOCKEVENT, USER_NR };


struct em_sti_priv {
	
void __iomem *base;
	
struct clk *clk;
	
struct platform_device *pdev;
	
unsigned int active[USER_NR];
	
unsigned long rate;
	
raw_spinlock_t lock;
	
struct clock_event_device ced;
	
struct clocksource cs;
};


#define STI_CONTROL 0x00

#define STI_COMPA_H 0x10

#define STI_COMPA_L 0x14

#define STI_COMPB_H 0x18

#define STI_COMPB_L 0x1c

#define STI_COUNT_H 0x20

#define STI_COUNT_L 0x24

#define STI_COUNT_RAW_H 0x28

#define STI_COUNT_RAW_L 0x2c

#define STI_SET_H 0x30

#define STI_SET_L 0x34

#define STI_INTSTATUS 0x40

#define STI_INTRAWSTATUS 0x44

#define STI_INTENSET 0x48

#define STI_INTENCLR 0x4c

#define STI_INTFFCLR 0x50



static inline unsigned long em_sti_read(struct em_sti_priv *p, int offs)
{
	return ioread32(p->base + offs);
}

Contributors
Person Tokens Prop Commits CommitProp
Magnus Damm 26 100.00% 1 100.00%
Total 26 100.00% 1 100.00%



static inline void em_sti_write(struct em_sti_priv *p, int offs,
				unsigned long value)
{
	iowrite32(value, p->base + offs);
}

Contributors
Person Tokens Prop Commits CommitProp
Magnus Damm 30 100.00% 1 100.00%
Total 30 100.00% 1 100.00%



static int em_sti_enable(struct em_sti_priv *p)
{
	int ret;

	/* enable clock */
	ret = clk_enable(p->clk);
	if (ret) {
		dev_err(&p->pdev->dev, "cannot enable clock\n");
		return ret;
	}

	/* reset the counter */
	em_sti_write(p, STI_SET_H, 0x40000000);
	em_sti_write(p, STI_SET_L, 0x00000000);

	/* mask and clear pending interrupts */
	em_sti_write(p, STI_INTENCLR, 3);
	em_sti_write(p, STI_INTFFCLR, 3);

	/* enable updates of counter registers */
	em_sti_write(p, STI_CONTROL, 1);

	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
Magnus Damm 95 98.96% 1 50.00%
Nicolai Stange 1 1.04% 1 50.00%
Total 96 100.00% 2 100.00%



static void em_sti_disable(struct em_sti_priv *p)
{
	/* mask interrupts */
	em_sti_write(p, STI_INTENCLR, 3);

	/* stop clock */
	clk_disable(p->clk);
}

Contributors
Person Tokens Prop Commits CommitProp
Magnus Damm 28 96.55% 1 50.00%
Nicolai Stange 1 3.45% 1 50.00%
Total 29 100.00% 2 100.00%



static u64 em_sti_count(struct em_sti_priv *p)
{
	u64 ticks;
	unsigned long flags;

	/* the STI hardware buffers the 48-bit count, but to
         * break it out into two 32-bit access the registers
         * must be accessed in a certain order.
         * Always read STI_COUNT_H before STI_COUNT_L.
         */
	raw_spin_lock_irqsave(&p->lock, flags);
	ticks = (u64)(em_sti_read(p, STI_COUNT_H) & 0xffff) << 32;
	ticks |= em_sti_read(p, STI_COUNT_L);
	raw_spin_unlock_irqrestore(&p->lock, flags);

	return ticks;
}

Contributors
Person Tokens Prop Commits CommitProp
Magnus Damm 66 95.65% 1 50.00%
Thomas Gleixner 3 4.35% 1 50.00%
Total 69 100.00% 2 100.00%



static u64 em_sti_set_next(struct em_sti_priv *p, u64 next)
{
	unsigned long flags;

	raw_spin_lock_irqsave(&p->lock, flags);

	/* mask compare A interrupt */
	em_sti_write(p, STI_INTENCLR, 1);

	/* update compare A value */
	em_sti_write(p, STI_COMPA_H, next >> 32);
	em_sti_write(p, STI_COMPA_L, next & 0xffffffff);

	/* clear compare A interrupt source */
	em_sti_write(p, STI_INTFFCLR, 1);

	/* unmask compare A interrupt */
	em_sti_write(p, STI_INTENSET, 1);

	raw_spin_unlock_irqrestore(&p->lock, flags);

	return next;
}

Contributors
Person Tokens Prop Commits CommitProp
Magnus Damm 92 97.87% 1 50.00%
Thomas Gleixner 2 2.13% 1 50.00%
Total 94 100.00% 2 100.00%



static irqreturn_t em_sti_interrupt(int irq, void *dev_id)
{
	struct em_sti_priv *p = dev_id;

	p->ced.event_handler(&p->ced);
	return IRQ_HANDLED;
}

Contributors
Person Tokens Prop Commits CommitProp
Magnus Damm 35 100.00% 1 100.00%
Total 35 100.00% 1 100.00%



static int em_sti_start(struct em_sti_priv *p, unsigned int user)
{
	unsigned long flags;
	int used_before;
	int ret = 0;

	raw_spin_lock_irqsave(&p->lock, flags);
	used_before = p->active[USER_CLOCKSOURCE] | p->active[USER_CLOCKEVENT];
	if (!used_before)
		ret = em_sti_enable(p);

	if (!ret)
		p->active[user] = 1;
	raw_spin_unlock_irqrestore(&p->lock, flags);

	return ret;
}

Contributors
Person Tokens Prop Commits CommitProp
Magnus Damm 92 100.00% 1 100.00%
Total 92 100.00% 1 100.00%



static void em_sti_stop(struct em_sti_priv *p, unsigned int user)
{
	unsigned long flags;
	int used_before, used_after;

	raw_spin_lock_irqsave(&p->lock, flags);
	used_before = p->active[USER_CLOCKSOURCE] | p->active[USER_CLOCKEVENT];
	p->active[user] = 0;
	used_after = p->active[USER_CLOCKSOURCE] | p->active[USER_CLOCKEVENT];

	if (used_before && !used_after)
		em_sti_disable(p);
	raw_spin_unlock_irqrestore(&p->lock, flags);
}

Contributors
Person Tokens Prop Commits CommitProp
Magnus Damm 97 100.00% 1 100.00%
Total 97 100.00% 1 100.00%



static struct em_sti_priv *cs_to_em_sti(struct clocksource *cs)
{
	return container_of(cs, struct em_sti_priv, cs);
}

Contributors
Person Tokens Prop Commits CommitProp
Magnus Damm 24 100.00% 1 100.00%
Total 24 100.00% 1 100.00%



static u64 em_sti_clocksource_read(struct clocksource *cs)
{
	return em_sti_count(cs_to_em_sti(cs));
}

Contributors
Person Tokens Prop Commits CommitProp
Magnus Damm 19 95.00% 1 50.00%
Thomas Gleixner 1 5.00% 1 50.00%
Total 20 100.00% 2 100.00%



static int em_sti_clocksource_enable(struct clocksource *cs)
{
	struct em_sti_priv *p = cs_to_em_sti(cs);

	return em_sti_start(p, USER_CLOCKSOURCE);
}

Contributors
Person Tokens Prop Commits CommitProp
Magnus Damm 28 96.55% 1 50.00%
Nicolai Stange 1 3.45% 1 50.00%
Total 29 100.00% 2 100.00%



static void em_sti_clocksource_disable(struct clocksource *cs)
{
	em_sti_stop(cs_to_em_sti(cs), USER_CLOCKSOURCE);
}

Contributors
Person Tokens Prop Commits CommitProp
Magnus Damm 21 100.00% 1 100.00%
Total 21 100.00% 1 100.00%



static void em_sti_clocksource_resume(struct clocksource *cs)
{
	em_sti_clocksource_enable(cs);
}

Contributors
Person Tokens Prop Commits CommitProp
Magnus Damm 16 100.00% 1 100.00%
Total 16 100.00% 1 100.00%



static int em_sti_register_clocksource(struct em_sti_priv *p)
{
	struct clocksource *cs = &p->cs;

	cs->name = dev_name(&p->pdev->dev);
	cs->rating = 200;
	cs->read = em_sti_clocksource_read;
	cs->enable = em_sti_clocksource_enable;
	cs->disable = em_sti_clocksource_disable;
	cs->suspend = em_sti_clocksource_disable;
	cs->resume = em_sti_clocksource_resume;
	cs->mask = CLOCKSOURCE_MASK(48);
	cs->flags = CLOCK_SOURCE_IS_CONTINUOUS;

	dev_info(&p->pdev->dev, "used as clock source\n");

	clocksource_register_hz(cs, p->rate);
	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
Magnus Damm 107 97.27% 1 50.00%
Nicolai Stange 3 2.73% 1 50.00%
Total 110 100.00% 2 100.00%



static struct em_sti_priv *ced_to_em_sti(struct clock_event_device *ced)
{
	return container_of(ced, struct em_sti_priv, ced);
}

Contributors
Person Tokens Prop Commits CommitProp
Magnus Damm 24 100.00% 1 100.00%
Total 24 100.00% 1 100.00%



static int em_sti_clock_event_shutdown(struct clock_event_device *ced)
{
	struct em_sti_priv *p = ced_to_em_sti(ced);
	em_sti_stop(p, USER_CLOCKEVENT);
	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
Magnus Damm 26 83.87% 1 50.00%
Viresh Kumar 5 16.13% 1 50.00%
Total 31 100.00% 2 100.00%



static int em_sti_clock_event_set_oneshot(struct clock_event_device *ced)
{
	struct em_sti_priv *p = ced_to_em_sti(ced);

	dev_info(&p->pdev->dev, "used for oneshot clock events\n");
	em_sti_start(p, USER_CLOCKEVENT);
	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
Viresh Kumar 22 51.16% 1 50.00%
Magnus Damm 21 48.84% 1 50.00%
Total 43 100.00% 2 100.00%



static int em_sti_clock_event_next(unsigned long delta,
				   struct clock_event_device *ced)
{
	struct em_sti_priv *p = ced_to_em_sti(ced);
	u64 next;
	int safe;

	next = em_sti_set_next(p, em_sti_count(p) + delta);
	safe = em_sti_count(p) < (next - 1);

	return !safe;
}

Contributors
Person Tokens Prop Commits CommitProp
Magnus Damm 61 98.39% 1 50.00%
Thomas Gleixner 1 1.61% 1 50.00%
Total 62 100.00% 2 100.00%



static void em_sti_register_clockevent(struct em_sti_priv *p)
{
	struct clock_event_device *ced = &p->ced;

	ced->name = dev_name(&p->pdev->dev);
	ced->features = CLOCK_EVT_FEAT_ONESHOT;
	ced->rating = 200;
	ced->cpumask = cpu_possible_mask;
	ced->set_next_event = em_sti_clock_event_next;
	ced->set_state_shutdown = em_sti_clock_event_shutdown;
	ced->set_state_oneshot = em_sti_clock_event_set_oneshot;

	dev_info(&p->pdev->dev, "used for clock events\n");

	clockevents_config_and_register(ced, p->rate, 2, 0xffffffff);
}

Contributors
Person Tokens Prop Commits CommitProp
Magnus Damm 85 88.54% 2 50.00%
Viresh Kumar 8 8.33% 1 25.00%
Nicolai Stange 3 3.12% 1 25.00%
Total 96 100.00% 4 100.00%



static int em_sti_probe(struct platform_device *pdev)
{
	struct em_sti_priv *p;
	struct resource *res;
	int irq;
	int ret;

	p = devm_kzalloc(&pdev->dev, sizeof(*p), GFP_KERNEL);
	if (p == NULL)
		return -ENOMEM;

	p->pdev = pdev;
	platform_set_drvdata(pdev, p);

	irq = platform_get_irq(pdev, 0);
	if (irq < 0) {
		dev_err(&pdev->dev, "failed to get irq\n");
		return irq;
	}

	/* map memory, let base point to the STI instance */
	res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
	p->base = devm_ioremap_resource(&pdev->dev, res);
	if (IS_ERR(p->base))
		return PTR_ERR(p->base);

	ret = devm_request_irq(&pdev->dev, irq, em_sti_interrupt,
			       IRQF_TIMER | IRQF_IRQPOLL | IRQF_NOBALANCING,
			       dev_name(&pdev->dev), p);
	if (ret) {
		dev_err(&pdev->dev, "failed to request low IRQ\n");
		return ret;
	}

	/* get hold of clock */
	p->clk = devm_clk_get(&pdev->dev, "sclk");
	if (IS_ERR(p->clk)) {
		dev_err(&pdev->dev, "cannot get clock\n");
		return PTR_ERR(p->clk);
	}

	ret = clk_prepare(p->clk);
	if (ret < 0) {
		dev_err(&pdev->dev, "cannot prepare clock\n");
		return ret;
	}

	ret = clk_enable(p->clk);
	if (ret < 0) {
		dev_err(&p->pdev->dev, "cannot enable clock\n");
		clk_unprepare(p->clk);
		return ret;
	}
	p->rate = clk_get_rate(p->clk);
	clk_disable(p->clk);

	raw_spin_lock_init(&p->lock);
	em_sti_register_clockevent(p);
	em_sti_register_clocksource(p);
	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
Magnus Damm 181 52.92% 1 20.00%
Nicolai Stange 115 33.63% 2 40.00%
Laurent Pinchart 38 11.11% 1 20.00%
Gustavo A. R. Silva 8 2.34% 1 20.00%
Total 342 100.00% 5 100.00%



static int em_sti_remove(struct platform_device *pdev)
{
	return -EBUSY; /* cannot unregister clockevent and clocksource */
}

Contributors
Person Tokens Prop Commits CommitProp
Magnus Damm 16 100.00% 1 100.00%
Total 16 100.00% 1 100.00%


static const struct of_device_id em_sti_dt_ids[] = {
	{ .compatible = "renesas,em-sti", },
	{},
};
MODULE_DEVICE_TABLE(of, em_sti_dt_ids);


static struct platform_driver em_sti_device_driver = {
	.probe		= em_sti_probe,
	.remove		= em_sti_remove,
	.driver		= {
		.name	= "em_sti",
		.of_match_table = em_sti_dt_ids,
        }
};



static int __init em_sti_init(void)
{
	return platform_driver_register(&em_sti_device_driver);
}

Contributors
Person Tokens Prop Commits CommitProp
Simon Horman 13 81.25% 1 50.00%
Magnus Damm 3 18.75% 1 50.00%
Total 16 100.00% 2 100.00%



static void __exit em_sti_exit(void)
{
	platform_driver_unregister(&em_sti_device_driver);
}

Contributors
Person Tokens Prop Commits CommitProp
Simon Horman 15 100.00% 1 100.00%
Total 15 100.00% 1 100.00%


subsys_initcall(em_sti_init);

module_exit(em_sti_exit);

MODULE_AUTHOR("Magnus Damm");
MODULE_DESCRIPTION("Renesas Emma Mobile STI Timer Driver");
MODULE_LICENSE("GPL v2");
Overall Contributors
Person Tokens Prop Commits CommitProp
Magnus Damm 1424 85.12% 3 30.00%
Nicolai Stange 124 7.41% 2 20.00%
Laurent Pinchart 38 2.27% 1 10.00%
Simon Horman 37 2.21% 1 10.00%
Viresh Kumar 35 2.09% 1 10.00%
Gustavo A. R. Silva 8 0.48% 1 10.00%
Thomas Gleixner 7 0.42% 1 10.00%
Greg Kroah-Hartman 0.00% 0 0.00%
Total 1673 100.00% 10 100.00%
Directory: drivers/clocksource

Information contained on this website is for historical information purposes only and does not indicate or represent copyright ownership.
Created with cregit.
Person	Tokens	Prop	Commits	CommitProp
Magnus Damm	26	100.00%	1	100.00%
Total	26	100.00%	1	100.00%
cregit-Linux how code gets into the kernel

Release 4.14 drivers/clocksource/em_sti.c

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Overall Contributors
