pps-gmtimer.c

/*
 * pps-gmtimer.c -- PPS client driver using OMAP Timers
 *
 * Copyright (C) 2014  Daniel Drown <dan-android@drown.org>
 *
 *   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 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., 675 Mass Ave, Cambridge, MA 02139, USA.
 *
 */

#define MODULE_NAME "pps-gmtimer"
#define pr_fmt(fmt) MODULE_NAME ": " fmt

#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/init.h>
#include <linux/clk.h>
#include <linux/string.h>
#include <linux/platform_device.h>
#include <linux/of.h>
#include <linux/of_device.h>
#include <linux/interrupt.h>
#include <linux/device.h>
#include <linux/pinctrl/consumer.h>
#include <linux/pps_kernel.h>
#include <linux/clocksource.h>

#include <clocksource/timer-ti-dm.h>
#include <linux/platform_data/dmtimer-omap.h>

MODULE_LICENSE("GPL");
MODULE_AUTHOR("Dan Drown");
MODULE_DESCRIPTION("PPS Client Driver using OMAP Timer hardware");
MODULE_VERSION("0.1.0");

struct pps_gmtimer_platform_data
{
    struct omap_dm_timer *capture_timer;
    const struct omap_dm_timer_ops *timer_ops;
    const char *timer_name;
    uint32_t frequency;
    unsigned int capture;
    unsigned int overflow;
    unsigned int count_at_interrupt;
    struct pps_event_time ts;
    struct timespec64 delta;
    struct pps_device *pps;
    struct pps_source_info info;
    int ready;
    struct clocksource clksrc;
};

/* kobject *******************/
static ssize_t timer_name_show(struct device *dev, struct device_attribute *attr, char *buf)
{
    struct pps_gmtimer_platform_data *pdata = dev->platform_data;
    return sprintf(buf, "%s\n", pdata->timer_name);
}

static DEVICE_ATTR(timer_name, S_IRUGO, timer_name_show, NULL);

static ssize_t stats_show(struct device *dev, struct device_attribute *attr, char *buf)
{
    struct pps_gmtimer_platform_data *pdata = dev->platform_data;
    return sprintf(buf, "capture: %u\noverflow: %u\n", pdata->capture, pdata->overflow);
}

static DEVICE_ATTR(stats, S_IRUGO, stats_show, NULL);

static ssize_t interrupt_delta_show(struct device *dev, struct device_attribute *attr, char *buf)
{
    struct pps_gmtimer_platform_data *pdata = dev->platform_data;
    return sprintf(buf, "%lld.%09ld\n", (long long)pdata->delta.tv_sec, pdata->delta.tv_nsec);
}

static DEVICE_ATTR(interrupt_delta, S_IRUGO, interrupt_delta_show, NULL);

static ssize_t pps_ts_show(struct device *dev, struct device_attribute *attr, char *buf)
{
    struct pps_gmtimer_platform_data *pdata = dev->platform_data;
    return sprintf(buf, "%lld.%09ld\n", (long long)pdata->ts.ts_real.tv_sec, pdata->ts.ts_real.tv_nsec);
}

static DEVICE_ATTR(pps_ts, S_IRUGO, pps_ts_show, NULL);

static ssize_t count_at_interrupt_show(struct device *dev, struct device_attribute *attr, char *buf)
{
    struct pps_gmtimer_platform_data *pdata = dev->platform_data;
    return sprintf(buf, "%u\n", pdata->count_at_interrupt);
}

static DEVICE_ATTR(count_at_interrupt, S_IRUGO, count_at_interrupt_show, NULL);

static ssize_t capture_show(struct device *dev, struct device_attribute *attr, char *buf)
{
    struct pps_gmtimer_platform_data *pdata = dev->platform_data;
    return sprintf(buf, "%u\n",
                   __omap_dm_timer_read(pdata->capture_timer, OMAP_TIMER_CAPTURE_REG, pdata->capture_timer->posted));
}

static DEVICE_ATTR(capture, S_IRUGO, capture_show, NULL);

static ssize_t ctrlstatus_show(struct device *dev, struct device_attribute *attr, char *buf)
{
    struct pps_gmtimer_platform_data *pdata = dev->platform_data;
    return sprintf(buf, "%x\n",
                   __omap_dm_timer_read(pdata->capture_timer, OMAP_TIMER_CTRL_REG, pdata->capture_timer->posted));
}

static DEVICE_ATTR(ctrlstatus, S_IRUGO, ctrlstatus_show, NULL);

static ssize_t timer_counter_show(struct device *dev, struct device_attribute *attr, char *buf)
{
    struct pps_gmtimer_platform_data *pdata = dev->platform_data;
    unsigned int current_count = 0;

    current_count = pdata->timer_ops->read_counter(pdata->capture_timer);
    return sprintf(buf, "%u\n", current_count);
}

static DEVICE_ATTR(timer_counter, S_IRUGO, timer_counter_show, NULL);

static struct attribute *attrs[] = {
    &dev_attr_timer_counter.attr,
    &dev_attr_ctrlstatus.attr,
    &dev_attr_capture.attr,
    &dev_attr_count_at_interrupt.attr,
    &dev_attr_pps_ts.attr,
    &dev_attr_interrupt_delta.attr,
    &dev_attr_stats.attr,
    &dev_attr_timer_name.attr,
    NULL,
};

static struct attribute_group attr_group = {
    .attrs = attrs,
};

/* timers ********************/
static irqreturn_t pps_gmtimer_interrupt(int irq, void *data)
{
    struct pps_gmtimer_platform_data *pdata;

    pdata = data;

    if (pdata->ready)
    {
        unsigned int irq_status;

        irq_status = pdata->timer_ops->read_status(pdata->capture_timer);
        if (irq_status & OMAP_TIMER_INT_CAPTURE)
        {
            uint32_t ps_per_hz;
            unsigned int count_at_capture;

            pps_get_ts(&pdata->ts);
            pdata->count_at_interrupt = pdata->timer_ops->read_counter(pdata->capture_timer);
            count_at_capture = __omap_dm_timer_read(pdata->capture_timer, OMAP_TIMER_CAPTURE_REG, pdata->capture_timer->posted);

            pdata->delta.tv_sec = 0;

            // use picoseconds per hz to avoid floating point and limit the rounding error
            ps_per_hz = 1000000000 / (pdata->frequency / 1000);
            pdata->delta.tv_nsec = ((pdata->count_at_interrupt - count_at_capture) * ps_per_hz) / 1000;

            pps_sub_ts(&pdata->ts, pdata->delta);
            pps_event(pdata->pps, &pdata->ts, PPS_CAPTUREASSERT, NULL);

            pdata->capture++;

            __omap_dm_timer_write_status(pdata->capture_timer, OMAP_TIMER_INT_CAPTURE);
        }
        if (irq_status & OMAP_TIMER_INT_OVERFLOW)
        {
            pdata->overflow++;
            __omap_dm_timer_write_status(pdata->capture_timer, OMAP_TIMER_INT_OVERFLOW);
        }
    }

    return IRQ_HANDLED; // TODO: shared interrupts?
}

static void omap_dm_timer_setup_capture(struct omap_dm_timer *timer, const struct omap_dm_timer_ops *timer_ops)
{
    u32 ctrl;

    timer_ops->set_source(timer, OMAP_TIMER_SRC_SYS_CLK);

    timer_ops->enable(timer);

    ctrl = __omap_dm_timer_read(timer, OMAP_TIMER_CTRL_REG, timer->posted);

    // disable prescaler
    ctrl &= ~(OMAP_TIMER_CTRL_PRE | (0x07 << 2));

    // autoreload
    ctrl |= OMAP_TIMER_CTRL_AR;
    __omap_dm_timer_write(timer, OMAP_TIMER_LOAD_REG, 0, timer->posted);

    // start timer
    ctrl |= OMAP_TIMER_CTRL_ST;

    // set capture
    ctrl |= OMAP_TIMER_CTRL_TCM_LOWTOHIGH | OMAP_TIMER_CTRL_GPOCFG; // TODO: configurable direction

    __omap_dm_timer_load_start(timer, ctrl, 0, timer->posted);

    /* Save the context */
    timer->context.tclr = ctrl;
    timer->context.tldr = 0;
    timer->context.tcrr = 0;
}

/* if tclkin has no clock, writes to the timer registers will stall and you will get a message like:
 * Unhandled fault: external abort on non-linefetch (0x1028) at 0xfa044048
 */
static void omap_dm_timer_use_tclkin(struct pps_gmtimer_platform_data *pdata)
{
    struct clk *gt_fclk;

    pdata->timer_ops->set_source(pdata->capture_timer, OMAP_TIMER_SRC_EXT_CLK);
    gt_fclk = pdata->timer_ops->get_fclk(pdata->capture_timer);
    pdata->frequency = clk_get_rate(gt_fclk);
    pr_info("timer(%s) switched to tclkin, rate=%uHz\n", pdata->timer_name, pdata->frequency);
}

static void pps_gmtimer_enable_irq(struct pps_gmtimer_platform_data *pdata)
{
    unsigned int interrupt_mask;

    interrupt_mask = OMAP_TIMER_INT_CAPTURE | OMAP_TIMER_INT_OVERFLOW;
    __omap_dm_timer_int_enable(pdata->capture_timer, interrupt_mask);
    pdata->capture_timer->context.tier = interrupt_mask;
    pdata->capture_timer->context.twer = interrupt_mask;
}

static int pps_gmtimer_init_timer(struct device_node *timer_dn, struct pps_gmtimer_platform_data *pdata)
{
    struct clk *gt_fclk;

    of_property_read_string_index(timer_dn, "ti,hwmods", 0, &pdata->timer_name);
    if (!pdata->timer_name)
    {
        pr_err("ti,hwmods property missing?\n");
        return -ENODEV;
    }

    pdata->capture_timer = pdata->timer_ops->request_by_node(timer_dn);
    if (!pdata->capture_timer)
    {
        pr_err("request_by_node failed\n");
        return -ENODEV;
    }

    // TODO: use devm_request_irq?
    if (request_irq(pdata->capture_timer->irq, pps_gmtimer_interrupt, IRQF_TIMER, MODULE_NAME, pdata))
    {
        pr_err("cannot register IRQ %d\n", pdata->capture_timer->irq);
        return -EIO;
    }

    omap_dm_timer_setup_capture(pdata->capture_timer, pdata->timer_ops);

    gt_fclk = pdata->timer_ops->get_fclk(pdata->capture_timer);
    pdata->frequency = clk_get_rate(gt_fclk);

    pr_info("timer name=%s rate=%uHz\n", pdata->timer_name, pdata->frequency);

    return 0;
}

static void pps_gmtimer_cleanup_timer(struct pps_gmtimer_platform_data *pdata)
{
    if (pdata->capture_timer)
    {
        pdata->timer_ops->set_source(pdata->capture_timer, OMAP_TIMER_SRC_SYS_CLK); // in case TCLKIN is stopped during boot
        pdata->timer_ops->set_int_disable(pdata->capture_timer, OMAP_TIMER_INT_CAPTURE | OMAP_TIMER_INT_OVERFLOW);
        free_irq(pdata->capture_timer->irq, pdata);
        pdata->timer_ops->stop(pdata->capture_timer);
        pdata->timer_ops->free(pdata->capture_timer);
        pdata->capture_timer = NULL;
        pr_info("Exiting.\n");
    }
}

/* clocksource ***************/
static struct pps_gmtimer_platform_data *clocksource_timer = NULL;

static u64 pps_gmtimer_read_cycles(struct clocksource *cs)
{

    return (u64)__omap_dm_timer_read_counter(clocksource_timer->capture_timer, clocksource_timer->capture_timer->posted);
}

static void pps_gmtimer_clocksource_init(struct pps_gmtimer_platform_data *pdata)
{
    if (!clocksource_timer)
    {
        pdata->clksrc.name = pdata->timer_name;

        pdata->clksrc.rating = 299;
        pdata->clksrc.read = pps_gmtimer_read_cycles;
        pdata->clksrc.mask = CLOCKSOURCE_MASK(32);
        pdata->clksrc.flags = CLOCK_SOURCE_IS_CONTINUOUS;

        clocksource_timer = pdata;
        if (clocksource_register_hz(&pdata->clksrc, pdata->frequency))
        {
            pr_err("Could not register clocksource %s\n", pdata->clksrc.name);
            clocksource_timer = NULL;
        }
        else
        {
            pr_info("clocksource: %s at %u Hz\n", pdata->clksrc.name, pdata->frequency);
        }
    }
}

static void pps_gmtimer_clocksource_cleanup(struct pps_gmtimer_platform_data *pdata)
{
    if (pdata == clocksource_timer)
    {
        clocksource_unregister(&pdata->clksrc);
        clocksource_timer = NULL;
    }
}

/* module ********************/
static struct pps_gmtimer_platform_data *of_get_pps_gmtimer_pdata(struct platform_device *pdev)
{
    struct device_node *np = pdev->dev.of_node, *timer_dn;
    struct platform_device *timer_pdev;
    struct dmtimer_platform_data *timer_pdata;
    struct pps_gmtimer_platform_data *pdata;

    pdata = devm_kzalloc(&pdev->dev, sizeof(*pdata), GFP_KERNEL);
    if (!pdata)
    {
        return NULL;
    }

    pdata->ready = 0;

    timer_dn = of_parse_phandle(np, "timer", 0);
    if (!timer_dn)
    {
        dev_err(&pdev->dev, "Unable to parse device node\n");
        return NULL;
    }

    timer_pdev = of_find_device_by_node(timer_dn);
    if (!timer_pdev)
    {
        dev_err(&pdev->dev, "Unable to find Timer pdev\n");
        goto fail2;
    }

    timer_pdata = dev_get_platdata(&timer_pdev->dev);
    if (!timer_pdata)
    {
        dev_err(&pdev->dev, "dmtimer pdata structure NULL\n");
        goto fail2;
    }

    pdata->timer_ops = timer_pdata->timer_ops;

    if (!pdata->timer_ops || !pdata->timer_ops->request_by_node ||
        !pdata->timer_ops->free ||
        !pdata->timer_ops->enable ||
        !pdata->timer_ops->disable ||
        !pdata->timer_ops->get_fclk ||
        !pdata->timer_ops->start ||
        !pdata->timer_ops->stop ||
        !pdata->timer_ops->set_load ||
        !pdata->timer_ops->set_match ||
        !pdata->timer_ops->set_pwm ||
        !pdata->timer_ops->set_prescaler ||
        !pdata->timer_ops->write_counter)
    {
        dev_err(&pdev->dev, "Incomplete dmtimer pdata structure\n");
        goto fail2;
    }

    if (pps_gmtimer_init_timer(timer_dn, pdata) < 0)
    {
        goto fail2;
    }

    of_node_put(timer_dn);

    return pdata;

fail2:
    of_node_put(timer_dn);

    devm_kfree(&pdev->dev, pdata);
    return NULL;
}

static const struct of_device_id pps_gmtimer_dt_ids[] = {
    {
        .compatible = "pps-gmtimer",
    },
    {/* sentinel */}};
MODULE_DEVICE_TABLE(of, pps_gmtimer_dt_ids);

static int pps_gmtimer_probe(struct platform_device *pdev)
{

    const struct of_device_id *match;
    struct pps_gmtimer_platform_data *pdata;
    struct pinctrl *pinctrl;
    const __be32 *use_tclkin;

    match = of_match_device(pps_gmtimer_dt_ids, &pdev->dev);
    if (match)
    {
        pdev->dev.platform_data = of_get_pps_gmtimer_pdata(pdev);
    }
    else
    {
        pr_err("of_match_device failed\n");
    }
    pdata = pdev->dev.platform_data;
    if (!pdata)
        return -ENODEV;

    pdata->ready = 0;

    if (sysfs_create_group(&pdev->dev.kobj, &attr_group))
    {
        pr_err("sysfs_create_group failed\n");
    }

    pinctrl = devm_pinctrl_get_select_default(&pdev->dev);
    if (IS_ERR(pinctrl))
        pr_warning("pins are not configured from the driver\n");

    use_tclkin = of_get_property(pdev->dev.of_node, "use-tclkin", NULL);
    if (use_tclkin && be32_to_cpup(use_tclkin) == 1)
    {
        omap_dm_timer_use_tclkin(pdata);
    }
    else
    {
        pr_info("using system clock\n");
    }

    pdata->info.mode = PPS_CAPTUREASSERT | PPS_ECHOASSERT | PPS_CANWAIT | PPS_TSFMT_TSPEC;
    pdata->info.owner = THIS_MODULE;
    snprintf(pdata->info.name, PPS_MAX_NAME_LEN - 1, "%s", pdata->timer_name);

    pdata->pps = pps_register_source(&pdata->info, PPS_CAPTUREASSERT);
    if (pdata->pps == NULL)
    {
        pr_err("failed to register %s as PPS source\n", pdata->timer_name);
    }
    else
    {
        // ready to go
        pdata->ready = 1;
        pps_gmtimer_clocksource_init(pdata);

        pps_gmtimer_enable_irq(pdata);
    }

    return 0;
}

static int pps_gmtimer_remove(struct platform_device *pdev)
{
    struct pps_gmtimer_platform_data *pdata;
    pdata = pdev->dev.platform_data;

    if (pdata)
    {
        pps_gmtimer_clocksource_cleanup(pdata);

        pps_gmtimer_cleanup_timer(pdata);

        if (pdata->pps)
        {
            pps_unregister_source(pdata->pps);
            pdata->pps = NULL;
        }

        devm_kfree(&pdev->dev, pdata);
        pdev->dev.platform_data = NULL;

        sysfs_remove_group(&pdev->dev.kobj, &attr_group);
    }

    platform_set_drvdata(pdev, NULL);

    return 0;
}

static struct platform_driver pps_gmtimer_driver = {
    .probe = pps_gmtimer_probe,
    .remove = pps_gmtimer_remove,
    .driver = {
        .name = MODULE_NAME,
        .owner = THIS_MODULE,
        .of_match_table = of_match_ptr(pps_gmtimer_dt_ids),
    },
};

module_platform_driver(pps_gmtimer_driver);