linux-imx

/*

 * Copyright (c) 2007 Ben Dooks

 * Copyright (c) 2008 Simtec Electronics

 *     Ben Dooks <ben@simtec.co.uk>, <ben-linux@fluff.org>

 * Copyright (c) 2013 Tomasz Figa <tomasz.figa@gmail.com>

 *

 * PWM driver for Samsung SoCs

 *

 * 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.

 */

​

#include <linux/bitops.h>

#include <linux/clk.h>

    u32 duty_ns;

    u32 tin_ns;

};

​

/**

 * struct samsung_pwm_chip - private data of PWM chip

 * @chip:       generic PWM chip

 * @variant:        local copy of hardware variant data

 * @inverter_mask:  inverter status for all channels - one bit per channel

 * @base:       base address of mapped PWM registers

 * @base_clk:       base clock used to drive the timers

 * @tclk0:      external clock 0 (can be ERR_PTR if not present)

 * @tclk1:      external clock 1 (can be ERR_PTR if not present)

 */

struct samsung_pwm_chip {

    struct pwm_chip chip;

    struct samsung_pwm_variant variant;

    u8 inverter_mask;

​

    void __iomem *base;

    struct clk *base_clk;

    struct clk *tclk0;

    struct clk *tclk1;

};

​

#ifndef CONFIG_CLKSRC_SAMSUNG_PWM

/*

 * PWM block is shared between pwm-samsung and samsung_pwm_timer drivers

​

    tcon &= ~TCON_START(tcon_chan);

    tcon |= TCON_MANUALUPDATE(tcon_chan);

    writel(tcon, our_chip->base + REG_TCON);

​

    tcon &= ~TCON_MANUALUPDATE(tcon_chan);

    tcon |= TCON_START(tcon_chan) | TCON_AUTORELOAD(tcon_chan);

    writel(tcon, our_chip->base + REG_TCON);

​

    spin_unlock_irqrestore(&samsung_pwm_lock, flags);

​

    return 0;

}

​

static void pwm_samsung_disable(struct pwm_chip *chip, struct pwm_device *pwm)

{

    struct samsung_pwm_chip *our_chip = to_samsung_pwm_chip(chip);

    unsigned int tcon_chan = to_tcon_channel(pwm->hwpwm);

    unsigned long flags;

    u32 tcon;

​

    spin_lock_irqsave(&samsung_pwm_lock, flags);

​

    tcon = readl(our_chip->base + REG_TCON);

    tcon &= ~TCON_AUTORELOAD(tcon_chan);

    writel(tcon, our_chip->base + REG_TCON);

​

    spin_unlock_irqrestore(&samsung_pwm_lock, flags);

}

​

static void pwm_samsung_manual_update(struct samsung_pwm_chip *chip,

                      struct pwm_device *pwm)

{

    unsigned int tcon_chan = to_tcon_channel(pwm->hwpwm);

    u32 tcon;

    unsigned long flags;

​

    tcon |= TCON_MANUALUPDATE(tcon_chan);

    writel(tcon, chip->base + REG_TCON);

​

    tcon &= ~TCON_MANUALUPDATE(tcon_chan);

    writel(tcon, chip->base + REG_TCON);

​

    spin_unlock_irqrestore(&samsung_pwm_lock, flags);

}

​

{

    struct samsung_pwm_chip *our_chip = to_samsung_pwm_chip(chip);

    struct samsung_pwm_channel *chan = pwm_get_chip_data(pwm);

    u32 tin_ns = chan->tin_ns, tcnt, tcmp, oldtcmp;

​

    /*

     * We currently avoid using 64bit arithmetic by using the

     * fact that anything faster than 1Hz is easily representable

     * by 32bits.

     */

    if (period_ns > NSEC_PER_SEC)

        return -ERANGE;

​

    tcnt = readl(our_chip->base + REG_TCNTB(pwm->hwpwm));

    oldtcmp = readl(our_chip->base + REG_TCMPB(pwm->hwpwm));

​

    /* We need tick count for calculation, not last tick. */

    ++tcnt;

​

    /* Check to see if we are changing the clock rate of the PWM. */

        unsigned long tin_rate;

        u32 period;

​

        period = NSEC_PER_SEC / period_ns;

​

        dev_dbg(our_chip->chip.dev, "duty_ns=%d, period_ns=%d (%u)\n",

                        duty_ns, period_ns, period);

​

        tin_rate = pwm_samsung_calc_tin(our_chip, pwm->hwpwm, period);

​

    }

​

    chan->period_ns = period_ns;

    chan->tin_ns = tin_ns;

    chan->duty_ns = duty_ns;

​

    return 0;

}

​

static void pwm_samsung_set_invert(struct samsung_pwm_chip *chip,

                   unsigned int channel, bool invert)

{

    unsigned int tcon_chan = to_tcon_channel(channel);

    unsigned long flags;

    u32 tcon;

​

    spin_lock_irqsave(&samsung_pwm_lock, flags);

​

    tcon = readl(chip->base + REG_TCON);

    if (ret < 0)

        return ret;

​

    clk_disable_unprepare(chip->base_clk);

​

    return 0;

}

​

#ifdef CONFIG_PM_SLEEP

{

    unsigned int i;

​

        struct samsung_pwm_channel *chan = pwm_get_chip_data(pwm);

​

        if (!chan)

            continue;

​

​

​

    }

​

    return 0;

}

#endif

​

​

static struct platform_driver pwm_samsung_driver = {

    .driver     = {

        .name   = "samsung-pwm",

        .pm = &pwm_samsung_pm_ops,

        .of_match_table = of_match_ptr(samsung_pwm_matches),

    },

    .probe      = pwm_samsung_probe,

    .remove     = pwm_samsung_remove,

};