pwm-lpss.c 6.39 KB
Newer Older
1 2 3 4 5 6 7 8
/*
 * Intel Low Power Subsystem PWM controller driver
 *
 * Copyright (C) 2014, Intel Corporation
 * Author: Mika Westerberg <mika.westerberg@linux.intel.com>
 * Author: Chew Kean Ho <kean.ho.chew@intel.com>
 * Author: Chang Rebecca Swee Fun <rebecca.swee.fun.chang@intel.com>
 * Author: Chew Chiau Ee <chiau.ee.chew@intel.com>
9
 * Author: Alan Cox <alan@linux.intel.com>
10 11 12 13 14 15
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation.
 */

16
#include <linux/delay.h>
17
#include <linux/io.h>
18
#include <linux/iopoll.h>
19 20
#include <linux/kernel.h>
#include <linux/module.h>
21
#include <linux/pm_runtime.h>
22
#include <linux/time.h>
23

24
#include "pwm-lpss.h"
25 26 27 28 29 30 31

#define PWM				0x00000000
#define PWM_ENABLE			BIT(31)
#define PWM_SW_UPDATE			BIT(30)
#define PWM_BASE_UNIT_SHIFT		8
#define PWM_ON_TIME_DIV_MASK		0x000000ff

32 33 34
/* Size of each PWM register space if multiple */
#define PWM_SIZE			0x400

35 36
#define MAX_PWMS			4

37 38 39
struct pwm_lpss_chip {
	struct pwm_chip chip;
	void __iomem *regs;
40
	const struct pwm_lpss_boardinfo *info;
41
	u32 saved_ctrl[MAX_PWMS];
42 43
};

44 45 46 47 48
static inline struct pwm_lpss_chip *to_lpwm(struct pwm_chip *chip)
{
	return container_of(chip, struct pwm_lpss_chip, chip);
}

49 50 51 52 53 54 55 56 57 58 59 60 61 62
static inline u32 pwm_lpss_read(const struct pwm_device *pwm)
{
	struct pwm_lpss_chip *lpwm = to_lpwm(pwm->chip);

	return readl(lpwm->regs + pwm->hwpwm * PWM_SIZE + PWM);
}

static inline void pwm_lpss_write(const struct pwm_device *pwm, u32 value)
{
	struct pwm_lpss_chip *lpwm = to_lpwm(pwm->chip);

	writel(value, lpwm->regs + pwm->hwpwm * PWM_SIZE + PWM);
}

63
static int pwm_lpss_wait_for_update(struct pwm_device *pwm)
64
{
65 66 67 68 69 70
	struct pwm_lpss_chip *lpwm = to_lpwm(pwm->chip);
	const void __iomem *addr = lpwm->regs + pwm->hwpwm * PWM_SIZE + PWM;
	const unsigned int ms = 500 * USEC_PER_MSEC;
	u32 val;
	int err;

71
	/*
72 73 74 75 76 77 78 79 80
	 * PWM Configuration register has SW_UPDATE bit that is set when a new
	 * configuration is written to the register. The bit is automatically
	 * cleared at the start of the next output cycle by the IP block.
	 *
	 * If one writes a new configuration to the register while it still has
	 * the bit enabled, PWM may freeze. That is, while one can still write
	 * to the register, it won't have an effect. Thus, we try to sleep long
	 * enough that the bit gets cleared and make sure the bit is not
	 * enabled while we update the configuration.
81
	 */
82 83 84
	err = readl_poll_timeout(addr, val, !(val & PWM_SW_UPDATE), 40, ms);
	if (err)
		dev_err(pwm->chip->dev, "PWM_SW_UPDATE was not cleared\n");
85

86 87 88 89 90 91
	return err;
}

static inline int pwm_lpss_is_updating(struct pwm_device *pwm)
{
	return (pwm_lpss_read(pwm) & PWM_SW_UPDATE) ? -EBUSY : 0;
92 93
}

94 95
static void pwm_lpss_prepare(struct pwm_lpss_chip *lpwm, struct pwm_device *pwm,
			     int duty_ns, int period_ns)
96
{
97
	unsigned long long on_time_div;
98
	unsigned long c = lpwm->info->clk_rate, base_unit_range;
99
	unsigned long long base_unit, freq = NSEC_PER_SEC;
100 101 102 103
	u32 ctrl;

	do_div(freq, period_ns);

104 105
	/*
	 * The equation is:
106
	 * base_unit = round(base_unit_range * freq / c)
107
	 */
108
	base_unit_range = BIT(lpwm->info->base_unit_bits) - 1;
109
	freq *= base_unit_range;
110

111
	base_unit = DIV_ROUND_CLOSEST_ULL(freq, c);
112

113 114 115
	on_time_div = 255ULL * duty_ns;
	do_div(on_time_div, period_ns);
	on_time_div = 255ULL - on_time_div;
116

117
	ctrl = pwm_lpss_read(pwm);
118
	ctrl &= ~PWM_ON_TIME_DIV_MASK;
119 120
	ctrl &= ~(base_unit_range << PWM_BASE_UNIT_SHIFT);
	base_unit &= base_unit_range;
121
	ctrl |= (u32) base_unit << PWM_BASE_UNIT_SHIFT;
122
	ctrl |= on_time_div;
123
	pwm_lpss_write(pwm, ctrl);
124 125
}

126 127 128 129 130 131
static inline void pwm_lpss_cond_enable(struct pwm_device *pwm, bool cond)
{
	if (cond)
		pwm_lpss_write(pwm, pwm_lpss_read(pwm) | PWM_ENABLE);
}

132 133
static int pwm_lpss_apply(struct pwm_chip *chip, struct pwm_device *pwm,
			  struct pwm_state *state)
134
{
135
	struct pwm_lpss_chip *lpwm = to_lpwm(chip);
136
	int ret;
137

138 139 140
	if (state->enabled) {
		if (!pwm_is_enabled(pwm)) {
			pm_runtime_get_sync(chip->dev);
141 142 143 144 145
			ret = pwm_lpss_is_updating(pwm);
			if (ret) {
				pm_runtime_put(chip->dev);
				return ret;
			}
146
			pwm_lpss_prepare(lpwm, pwm, state->duty_cycle, state->period);
147 148 149
			pwm_lpss_write(pwm, pwm_lpss_read(pwm) | PWM_SW_UPDATE);
			pwm_lpss_cond_enable(pwm, lpwm->info->bypass == false);
			ret = pwm_lpss_wait_for_update(pwm);
150 151 152 153
			if (ret) {
				pm_runtime_put(chip->dev);
				return ret;
			}
154
			pwm_lpss_cond_enable(pwm, lpwm->info->bypass == true);
155
		} else {
156 157 158
			ret = pwm_lpss_is_updating(pwm);
			if (ret)
				return ret;
159
			pwm_lpss_prepare(lpwm, pwm, state->duty_cycle, state->period);
160 161
			pwm_lpss_write(pwm, pwm_lpss_read(pwm) | PWM_SW_UPDATE);
			return pwm_lpss_wait_for_update(pwm);
162 163 164 165 166
		}
	} else if (pwm_is_enabled(pwm)) {
		pwm_lpss_write(pwm, pwm_lpss_read(pwm) & ~PWM_ENABLE);
		pm_runtime_put(chip->dev);
	}
167

168
	return 0;
169 170 171
}

static const struct pwm_ops pwm_lpss_ops = {
172
	.apply = pwm_lpss_apply,
173 174 175
	.owner = THIS_MODULE,
};

176 177
struct pwm_lpss_chip *pwm_lpss_probe(struct device *dev, struct resource *r,
				     const struct pwm_lpss_boardinfo *info)
178 179
{
	struct pwm_lpss_chip *lpwm;
180
	unsigned long c;
181 182
	int ret;

183 184 185
	if (WARN_ON(info->npwm > MAX_PWMS))
		return ERR_PTR(-ENODEV);

186
	lpwm = devm_kzalloc(dev, sizeof(*lpwm), GFP_KERNEL);
187
	if (!lpwm)
188
		return ERR_PTR(-ENOMEM);
189

190
	lpwm->regs = devm_ioremap_resource(dev, r);
191
	if (IS_ERR(lpwm->regs))
192
		return ERR_CAST(lpwm->regs);
193

194
	lpwm->info = info;
195 196 197 198 199

	c = lpwm->info->clk_rate;
	if (!c)
		return ERR_PTR(-EINVAL);

200
	lpwm->chip.dev = dev;
201 202
	lpwm->chip.ops = &pwm_lpss_ops;
	lpwm->chip.base = -1;
203
	lpwm->chip.npwm = info->npwm;
204 205 206

	ret = pwmchip_add(&lpwm->chip);
	if (ret) {
207 208
		dev_err(dev, "failed to add PWM chip: %d\n", ret);
		return ERR_PTR(ret);
209 210
	}

211
	return lpwm;
212
}
213
EXPORT_SYMBOL_GPL(pwm_lpss_probe);
214

215
int pwm_lpss_remove(struct pwm_lpss_chip *lpwm)
216 217 218
{
	return pwmchip_remove(&lpwm->chip);
}
219
EXPORT_SYMBOL_GPL(pwm_lpss_remove);
220

221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244
int pwm_lpss_suspend(struct device *dev)
{
	struct pwm_lpss_chip *lpwm = dev_get_drvdata(dev);
	int i;

	for (i = 0; i < lpwm->info->npwm; i++)
		lpwm->saved_ctrl[i] = readl(lpwm->regs + i * PWM_SIZE + PWM);

	return 0;
}
EXPORT_SYMBOL_GPL(pwm_lpss_suspend);

int pwm_lpss_resume(struct device *dev)
{
	struct pwm_lpss_chip *lpwm = dev_get_drvdata(dev);
	int i;

	for (i = 0; i < lpwm->info->npwm; i++)
		writel(lpwm->saved_ctrl[i], lpwm->regs + i * PWM_SIZE + PWM);

	return 0;
}
EXPORT_SYMBOL_GPL(pwm_lpss_resume);

245 246 247
MODULE_DESCRIPTION("PWM driver for Intel LPSS");
MODULE_AUTHOR("Mika Westerberg <mika.westerberg@linux.intel.com>");
MODULE_LICENSE("GPL v2");