pwm: Drop support for time units other than nanoseconds

Make pwm support nearly match upstream again. The support for time units
other than nanoseconds adds no benefit as the input clock for all known
PWM drivers is less than 1 GHz and so the mapping from pwm_state to
hardware configuration is already surjective with nanoseconds.

Signed-off-by: Uwe Kleine-König <u.kleine-koenig@baylibre.com>

Author: ukleinek

drivers/pwm/core.c

@@ -568,8 +568,7 @@ int pwm_apply_state(struct pwm_device *pwm, const struct pwm_state *state)
 	    state->polarity == pwm->state.polarity &&
 	    state->enabled == pwm->state.enabled &&
 	    state->usage_power == pwm->state.usage_power &&
-	    state->phase == pwm->state.phase &&
-	    state->time_unit == pwm->state.time_unit)
+	    state->phase == pwm->state.phase)
 		return 0;
 
 	err = chip->ops->apply(chip, pwm, state);
@@ -645,7 +644,6 @@ int pwm_adjust_config(struct pwm_device *pwm)
 		state.duty_cycle = 0;
 		state.period = pargs.period;
 		state.polarity = pargs.polarity;
-		state.time_unit = pargs.time_unit;
 
 		return pwm_apply_state(pwm, &state);
 	}
@@ -1107,15 +1105,6 @@ struct pwm_device *devm_fwnode_pwm_get(struct device *dev,
 EXPORT_SYMBOL_GPL(devm_fwnode_pwm_get);
 
 #ifdef CONFIG_DEBUG_FS
-
-const char *pwm_time_unit_strings[] = {
-	[PWM_UNIT_SEC] = "s",
-	[PWM_UNIT_MSEC] = "ms",
-	[PWM_UNIT_USEC] = "us",
-	[PWM_UNIT_NSEC] = "ns",
-	[PWM_UNIT_PSEC] = "ps",
-};
-
 static void pwm_dbg_show(struct pwm_chip *chip, struct seq_file *s)
 {
 	unsigned int i;
@@ -1125,8 +1114,6 @@ static void pwm_dbg_show(struct pwm_chip *chip, struct seq_file *s)
 		struct pwm_state state;
 
 		pwm_get_state(pwm, &state);
-		if (!state.time_unit)
-			state.time_unit = PWM_UNIT_NSEC;
 
 		seq_printf(s, " pwm-%-3d (%-20.20s):", i, pwm->label);
 
@@ -1136,12 +1123,9 @@ static void pwm_dbg_show(struct pwm_chip *chip, struct seq_file *s)
 		if (state.enabled)
 			seq_puts(s, " enabled");
 
-		seq_printf(s, " period: %llu %s", state.period,
-			   pwm_time_unit_strings[state.time_unit]);
-		seq_printf(s, " duty: %llu %s", state.duty_cycle,
-			   pwm_time_unit_strings[state.time_unit]);
-		seq_printf(s, " phase: %llu %s", state.phase,
-			   pwm_time_unit_strings[state.time_unit]);
+		seq_printf(s, " period: %llu ns", state.period);
+		seq_printf(s, " duty: %llu ns", state.duty_cycle);
+		seq_printf(s, " phase: %llu ns", state.phase);
 		seq_printf(s, " polarity: %s",
 			   state.polarity ? "inverse" : "normal");
 

drivers/pwm/pwm-axi-pwmgen.c

@@ -43,14 +43,6 @@
 
 #define AXI_PWMGEN_N_MAX_PWMS		16
 
-static const unsigned long long axi_pwmgen_scales[] = {
-	[PWM_UNIT_SEC]  = 1000000000000ULL,
-	[PWM_UNIT_MSEC] = 1000000000ULL,
-	[PWM_UNIT_USEC] = 1000000ULL,
-	[PWM_UNIT_NSEC] = 1000ULL,
-	[PWM_UNIT_PSEC] = 1ULL,
-};
-
 struct axi_pwmgen {
 	struct pwm_chip		chip;
 	struct clk		*clk;
@@ -114,21 +106,18 @@ static int axi_pwmgen_apply(struct pwm_chip *chip, struct pwm_device *pwm,
 
 	rate = clk_get_rate(pwmgen->clk);
 
-	cnt = mul_u64_u64_div_u64_roundclosest(state->period * axi_pwmgen_scales[state->time_unit],
-					       rate, PSEC_PER_SEC);
+	cnt = mul_u64_u64_div_u64_roundclosest(state->period, rate, NSEC_PER_SEC);
 	if (cnt > U32_MAX)
 		cnt = U32_MAX;
 	axi_pwmgen_write(pwmgen, AXI_PWMGEN_CHX_PERIOD(pwmgen, ch),
 			 state->enabled ? cnt : 0);
 
-	cnt = mul_u64_u64_div_u64_roundclosest(state->duty_cycle * axi_pwmgen_scales[state->time_unit],
-					       rate, PSEC_PER_SEC);
+	cnt = mul_u64_u64_div_u64_roundclosest(state->duty_cycle, rate, NSEC_PER_SEC);
 	if (cnt > U32_MAX)
 		cnt = U32_MAX;
 	axi_pwmgen_write(pwmgen, AXI_PWMGEN_CHX_DUTY(pwmgen, ch), cnt);
 
-	cnt = mul_u64_u64_div_u64_roundclosest(state->phase * axi_pwmgen_scales[state->time_unit],
-					       rate, PSEC_PER_SEC);
+	cnt = mul_u64_u64_div_u64_roundclosest(state->phase, rate, NSEC_PER_SEC);
 	if (cnt > U32_MAX)
 		cnt = U32_MAX;
 	axi_pwmgen_write(pwmgen, AXI_PWMGEN_CHX_PHASE(pwmgen, ch), cnt);
@@ -161,7 +150,6 @@ static void axi_pwmgen_get_state(struct pwm_chip *chip, struct pwm_device *pwm,
 	state->phase = DIV_ROUND_CLOSEST_ULL(cnt * NSEC_PER_SEC, rate);
 
 	state->enabled = state->period > 0;
-	state->time_unit = PWM_UNIT_NSEC;
 }
 
 static const struct pwm_ops axi_pwmgen_pwm_ops = {

drivers/pwm/sysfs.c

@@ -235,69 +235,6 @@ static ssize_t polarity_store(struct device *child,
 	return ret ? : size;
 }
 
-static ssize_t time_unit_show(struct device *child,
-			      struct device_attribute *attr,
-			      char *buf)
-{
-	const struct pwm_device *pwm = child_to_pwm_device(child);
-	const char *unit = "unknown";
-	struct pwm_state state;
-
-	pwm_get_state(pwm, &state);
-
-	switch (state.time_unit) {
-	case PWM_UNIT_SEC:
-		unit = "second";
-		break;
-	case PWM_UNIT_MSEC:
-		unit = "milisecond";
-		break;
-	case PWM_UNIT_USEC:
-		unit = "microsecond";
-		break;
-	case PWM_UNIT_NSEC:
-		unit = "nanosecond";
-		break;
-	case PWM_UNIT_PSEC:
-		unit = "picosecond";
-		break;
-	}
-
-	return sprintf(buf, "%s\n", unit);
-}
-
-static ssize_t time_unit_store(struct device *child,
-			       struct device_attribute *attr,
-			       const char *buf, size_t size)
-{
-	struct pwm_export *export = child_to_pwm_export(child);
-	struct pwm_device *pwm = export->pwm;
-	enum pwm_time_unit unit;
-	struct pwm_state state;
-	int ret;
-
-	if (sysfs_streq(buf, "second"))
-		unit = PWM_UNIT_SEC;
-	else if (sysfs_streq(buf, "milisecond"))
-		unit = PWM_UNIT_MSEC;
-	else if (sysfs_streq(buf, "microsecond"))
-		unit = PWM_UNIT_USEC;
-	else if (sysfs_streq(buf, "nanosecond"))
-		unit = PWM_UNIT_NSEC;
-	else if (sysfs_streq(buf, "picosecond"))
-		unit = PWM_UNIT_PSEC;
-	else
-		return -EINVAL;
-
-	mutex_lock(&export->lock);
-	pwm_get_state(pwm, &state);
-	state.time_unit = unit;
-	ret = pwm_apply_state(pwm, &state);
-	mutex_unlock(&export->lock);
-
-	return ret ? : size;
-}
-
 static ssize_t capture_show(struct device *child,
 			    struct device_attribute *attr,
 			    char *buf)
@@ -319,7 +256,6 @@ static DEVICE_ATTR_RW(duty_cycle);
 static DEVICE_ATTR_RW(phase);
 static DEVICE_ATTR_RW(enable);
 static DEVICE_ATTR_RW(polarity);
-static DEVICE_ATTR_RW(time_unit);
 static DEVICE_ATTR_RO(capture);
 
 static struct attribute *pwm_attrs[] = {
@@ -328,7 +264,6 @@ static struct attribute *pwm_attrs[] = {
 	&dev_attr_phase.attr,
 	&dev_attr_enable.attr,
 	&dev_attr_polarity.attr,
-	&dev_attr_time_unit.attr,
 	&dev_attr_capture.attr,
 	NULL
 };

include/linux/pwm.h

@@ -8,23 +8,6 @@
 
 struct pwm_chip;
 
-/**
- * enum pwm_unit - the time unit in wich the pwm arguments are expressed.
- * @PWM_UNIT_SEC:  the pwm_args members are specified in seconds
- * @PWM_UNIT_MSEC: the pwm_args members are specified in miliseconds
- * @PWM_UNIT_USEC: the pwm_args members are specified in microseconds
- * @PWM_UNIT_NSEC: the pwm_args members are specified in nanoseconds
- * @PWM_UNIT_PSEC: the pwm_args members are specified in picoseconds
- */
-
-enum pwm_time_unit {
-	PWM_UNIT_SEC = 1,
-	PWM_UNIT_MSEC,
-	PWM_UNIT_USEC,
-	PWM_UNIT_NSEC,
-	PWM_UNIT_PSEC,
-};
-
 /**
  * enum pwm_polarity - polarity of a PWM signal
  * @PWM_POLARITY_NORMAL: a high signal for the duration of the duty-
@@ -44,7 +27,6 @@ enum pwm_polarity {
  * @period: reference period
  * @polarity: reference polarity
  * @phase: reference phase
- * @time_unit: refference time unit
  *
  * This structure describes board-dependent arguments attached to a PWM
  * device. These arguments are usually retrieved from the PWM lookup table or
@@ -58,7 +40,6 @@ struct pwm_args {
 	u64 period;
 	u64 phase;
 	enum pwm_polarity polarity;
-	enum pwm_time_unit time_unit;
 };
 
 enum {
@@ -68,11 +49,10 @@ enum {
 
 /*
  * struct pwm_state - state of a PWM channel
- * @period: PWM period (with the time unit expressed in ->time_unit)
- * @duty_cycle: PWM duty cycle (with the time unit expressed in ->time_unit)
- * @phase: PWM phase (with the time unit expressed in ->time_unit)
+ * @period: PWM period (in nanoseconds)
+ * @duty_cycle: PWM duty cycle (in nanoseconds)
+ * @phase: PWM phase (in nanoseconds)
  * @polarity: PWM polarity
- * @time_unit: PWM time unit
  * @enabled: PWM enabled status
  * @usage_power: If set, the PWM driver is only required to maintain the power
  *               output but has more freedom regarding signal form.
@@ -84,7 +64,6 @@ struct pwm_state {
 	u64 duty_cycle;
 	u64 phase;
 	enum pwm_polarity polarity;
-	enum pwm_time_unit time_unit;
 	bool enabled;
 	bool usage_power;
 };
@@ -184,26 +163,6 @@ static inline u64 pwm_get_phase(const struct pwm_device *pwm)
 	return state.phase;
 }
 
-static inline int pwm_set_time_unit(struct pwm_device *pwm,
-				    enum pwm_time_unit time_unit)
-{
-	if (!pwm || time_unit < PWM_UNIT_SEC || time_unit > PWM_UNIT_PSEC)
-		return -EINVAL;
-
-	pwm->state.time_unit = time_unit;
-
-	return 0;
-}
-
-static inline enum pwm_time_unit pwm_get_time_unit(const struct pwm_device *pwm)
-{
-	struct pwm_state state;
-
-	pwm_get_state(pwm, &state);
-
-	return state.time_unit;
-}
-
 static inline enum pwm_polarity pwm_get_polarity(const struct pwm_device *pwm)
 {
 	struct pwm_state state;
@@ -235,8 +194,6 @@ static inline void pwm_get_args(const struct pwm_device *pwm,
  * ->duty_cycle value exceed the pwm_args->period one, which would trigger
  * an error if the user calls pwm_apply_state() without adjusting ->duty_cycle
  * first.
- * ->time_unit is initially set to PWM_UNIT_NSEC to align all the previous
- * drivers that presume the pwm_state arguments time unit is nanoseconds.
  */
 static inline void pwm_init_state(const struct pwm_device *pwm,
 				  struct pwm_state *state)
@@ -253,8 +210,6 @@ static inline void pwm_init_state(const struct pwm_device *pwm,
 	state->polarity = args.polarity;
 	state->duty_cycle = 0;
 	state->phase = 0;
-	/* Set the default time unit to nsec ensuring backward compatibility */
-	state->time_unit = PWM_UNIT_NSEC;
 	state->usage_power = false;
 }
 
@@ -322,7 +277,6 @@ struct pwm_capture {
 	u64 period;
 	u64 duty_cycle;
 	u64 phase;
-	enum pwm_time_unit time_unit;
 };
 
 /**
@@ -406,7 +360,6 @@ static inline int pwm_config(struct pwm_device *pwm, u64 duty_ns,
 
 	state.duty_cycle = duty_ns;
 	state.period = period_ns;
-	state.time_unit = PWM_UNIT_NSEC;
 	return pwm_apply_state(pwm, &state);
 }
 
@@ -611,7 +564,6 @@ static inline void pwm_apply_args(struct pwm_device *pwm)
 	state.polarity = pwm->args.polarity;
 	state.period = pwm->args.period;
 	state.phase = pwm->args.phase;
-	state.time_unit = pwm->args.time_unit;
 	state.usage_power = false;
 
 	pwm_apply_state(pwm, &state);