drivers/pwm/core.c

13 #include <linux/pwm.h>
22 #include <dt-bindings/pwm/pwm.h>
25 #include <trace/events/pwm.h>
32 static void pwm_apply_debug(struct pwm_device *pwm,
35 	struct pwm_state *last = &pwm->last;
36 	struct pwm_chip *chip = pwm->chip;
52 	err = chip->ops->get_state(chip, pwm, &s1);
53 	trace_pwm_get(pwm, &s1, err);
111 	err = chip->ops->apply(chip, pwm, &s1);
112 	trace_pwm_apply(pwm, &s1, err);
120 	err = chip->ops->get_state(chip, pwm, last);
121 	trace_pwm_get(pwm, last, err);
140  * @pwm: PWM device
143 static int __pwm_apply(struct pwm_device *pwm, const struct pwm_state *state)
148 	if (!pwm || !state || !state->period ||
152 	chip = pwm->chip;
154 	if (state->period == pwm->state.period &&
155 	    state->duty_cycle == pwm->state.duty_cycle &&
156 	    state->polarity == pwm->state.polarity &&
157 	    state->enabled == pwm->state.enabled &&
158 	    state->usage_power == pwm->state.usage_power)
161 	err = chip->ops->apply(chip, pwm, state);
162 	trace_pwm_apply(pwm, state, err);
166 	pwm->state = *state;
169 	 * only do this after pwm->state was applied as some
172 	pwm_apply_debug(pwm, state);
180  * @pwm: PWM device
183 int pwm_apply_might_sleep(struct pwm_device *pwm, const struct pwm_state *state)
196 	if (IS_ENABLED(CONFIG_PWM_DEBUG) && pwm->chip->atomic) {
202 		err = __pwm_apply(pwm, state);
205 		err = __pwm_apply(pwm, state);
215  * @pwm: PWM device
218 int pwm_apply_atomic(struct pwm_device *pwm, const struct pwm_state *state)
220 	WARN_ONCE(!pwm->chip->atomic,
223 	return __pwm_apply(pwm, state);
229  * @pwm: PWM device
235 int pwm_adjust_config(struct pwm_device *pwm)
240 	pwm_get_args(pwm, &pargs);
241 	pwm_get_state(pwm, &state);
256 		return pwm_apply_might_sleep(pwm, &state);
279 	return pwm_apply_might_sleep(pwm, &state);
285  * @pwm: PWM device
291 int pwm_capture(struct pwm_device *pwm, struct pwm_capture *result,
296 	if (!pwm || !pwm->chip->ops)
299 	if (!pwm->chip->ops->capture)
303 	err = pwm->chip->ops->capture(pwm->chip, pwm, result, timeout);
334 static int pwm_device_request(struct pwm_device *pwm, const char *label)
337 	struct pwm_chip *chip = pwm->chip;
340 	if (test_bit(PWMF_REQUESTED, &pwm->flags))
352 		err = ops->request(chip, pwm);
371 		err = ops->get_state(chip, pwm, &state);
372 		trace_pwm_get(pwm, &state, err);
375 			pwm->state = state;
378 			pwm->last = pwm->state;
381 	set_bit(PWMF_REQUESTED, &pwm->flags);
382 	pwm->label = label;
401 	struct pwm_device *pwm;
408 	pwm = &chip->pwms[index];
410 	err = pwm_device_request(pwm, label);
412 		pwm = ERR_PTR(err);
415 	return pwm;
423 	struct pwm_device *pwm;
429 	pwm = pwm_request_from_chip(chip, args->args[0], NULL);
430 	if (IS_ERR(pwm))
431 		return pwm;
434 		pwm->args.period = args->args[1];
436 	pwm->args.polarity = PWM_POLARITY_NORMAL;
438 		pwm->args.polarity = PWM_POLARITY_INVERSED;
440 	return pwm;
447 	struct pwm_device *pwm;
449 	pwm = pwm_request_from_chip(chip, 0, NULL);
450 	if (IS_ERR(pwm))
451 		return pwm;
454 		pwm->args.period = args->args[0];
456 	pwm->args.polarity = PWM_POLARITY_NORMAL;
458 		pwm->args.polarity = PWM_POLARITY_INVERSED;
460 	return pwm;
466 	struct pwm_device *pwm;
485 	return export->pwm;
492 	const struct pwm_device *pwm = pwm_from_dev(pwm_dev);
495 	pwm_get_state(pwm, &state);
505 	struct pwm_device *pwm = export->pwm;
515 	pwm_get_state(pwm, &state);
517 	ret = pwm_apply_might_sleep(pwm, &state);
527 	const struct pwm_device *pwm = pwm_from_dev(pwm_dev);
530 	pwm_get_state(pwm, &state);
540 	struct pwm_device *pwm = export->pwm;
550 	pwm_get_state(pwm, &state);
552 	ret = pwm_apply_might_sleep(pwm, &state);
562 	const struct pwm_device *pwm = pwm_from_dev(pwm_dev);
565 	pwm_get_state(pwm, &state);
575 	struct pwm_device *pwm = export->pwm;
585 	pwm_get_state(pwm, &state);
599 	ret = pwm_apply_might_sleep(pwm, &state);
610 	const struct pwm_device *pwm = pwm_from_dev(pwm_dev);
614 	pwm_get_state(pwm, &state);
634 	struct pwm_device *pwm = export->pwm;
647 	pwm_get_state(pwm, &state);
649 	ret = pwm_apply_might_sleep(pwm, &state);
659 	struct pwm_device *pwm = pwm_from_dev(pwm_dev);
663 	ret = pwm_capture(pwm, &result, jiffies_to_msecs(HZ));
684 ATTRIBUTE_GROUPS(pwm);
693 static int pwm_export_child(struct device *pwmchip_dev, struct pwm_device *pwm)
699 	if (test_and_set_bit(PWMF_EXPORTED, &pwm->flags))
704 		clear_bit(PWMF_EXPORTED, &pwm->flags);
708 	export->pwm = pwm;
715 	dev_set_name(&export->pwm_dev, "pwm%u", pwm->hwpwm);
719 		clear_bit(PWMF_EXPORTED, &pwm->flags);
724 	pwm_prop[0] = kasprintf(GFP_KERNEL, "EXPORT=pwm%u", pwm->hwpwm);
737 static int pwm_unexport_child(struct device *pwmchip_dev, struct pwm_device *pwm)
742 	if (!test_and_clear_bit(PWMF_EXPORTED, &pwm->flags))
745 	pwm_dev = device_find_child(pwmchip_dev, pwm, pwm_unexport_match);
749 	pwm_prop[0] = kasprintf(GFP_KERNEL, "UNEXPORT=pwm%u", pwm->hwpwm);
757 	pwm_put(pwm);
767 	struct pwm_device *pwm;
778 	pwm = pwm_request_from_chip(chip, hwpwm, "sysfs");
779 	if (IS_ERR(pwm))
780 		return PTR_ERR(pwm);
782 	ret = pwm_export_child(pwmchip_dev, pwm);
784 		pwm_put(pwm);
830 					      struct pwm_device *pwm,
836 	if (!test_bit(PWMF_EXPORTED, &pwm->flags))
839 	pwm_dev = device_find_child(pwmchip_dev, pwm, pwm_unexport_match);
847 	pwm_get_state(pwm, state);
853 				 struct pwm_device *pwm,
856 	int ret = pwm_apply_might_sleep(pwm, state);
871 		struct pwm_device *pwm = &chip->pwms[i];
875 		export = pwm_class_get_state(pwmchip_dev, pwm, &state);
887 		ret = pwm_class_apply_state(export, pwm, &state);
902 		struct pwm_device *pwm = &chip->pwms[i];
906 		export = pwm_class_get_state(pwmchip_dev, pwm, &state);
922 		ret = pwm_class_apply_state(export, pwm, &state);
946 	.name = "pwm",
956 		struct pwm_device *pwm = &chip->pwms[i];
958 		if (test_bit(PWMF_EXPORTED, &pwm->flags))
959 			pwm_unexport_child(&chip->dev, pwm);
1010 		struct pwm_device *pwm = &chip->pwms[i];
1011 		pwm->chip = chip;
1012 		pwm->hwpwm = i;
1182 					       struct pwm_device *pwm)
1192 		dev_warn(pwmchip_parent(pwm->chip),
1197 	dl = device_link_add(dev, pwmchip_parent(pwm->chip), DL_FLAG_AUTOREMOVE_CONSUMER);
1200 			dev_name(pwmchip_parent(pwm->chip)));
1237  * be requested. Otherwise the "pwm-names" property is used to do a reverse
1238  * lookup of the PWM index. This also means that the "pwm-names" property
1248 	struct pwm_device *pwm = NULL;
1256 		index = of_property_match_string(np, "pwm-names", con_id);
1261 	err = of_parse_phandle_with_args(np, "pwms", "#pwm-cells", index,
1273 		pwm = ERR_CAST(chip);
1277 	pwm = chip->of_xlate(chip, &args);
1278 	if (IS_ERR(pwm))
1281 	dl = pwm_device_link_add(dev, pwm);
1284 		pwm_put(pwm);
1285 		pwm = ERR_CAST(dl);
1291 	 * "pwm-names" property if it exists. Otherwise use the name of
1295 		err = of_property_read_string_index(np, "pwm-names", index,
1301 	pwm->label = con_id;
1306 	return pwm;
1328 	struct pwm_device *pwm;
1346 	pwm = pwm_request_from_chip(chip, args.args[0], NULL);
1347 	if (IS_ERR(pwm))
1348 		return pwm;
1350 	pwm->args.period = args.args[1];
1351 	pwm->args.polarity = PWM_POLARITY_NORMAL;
1354 		pwm->args.polarity = PWM_POLARITY_INVERSED;
1356 	return pwm;
1415 	struct pwm_device *pwm;
1429 		pwm = acpi_pwm_get(fwnode);
1430 		if (!IS_ERR(pwm) || PTR_ERR(pwm) != -ENOENT)
1431 			return pwm;
1505 	pwm = pwm_request_from_chip(chip, chosen->index, con_id ?: dev_id);
1506 	if (IS_ERR(pwm))
1507 		return pwm;
1509 	dl = pwm_device_link_add(dev, pwm);
1511 		pwm_put(pwm);
1515 	pwm->args.period = chosen->period;
1516 	pwm->args.polarity = chosen->polarity;
1518 	return pwm;
1524  * @pwm: PWM device
1526 void pwm_put(struct pwm_device *pwm)
1530 	if (!pwm)
1533 	chip = pwm->chip;
1537 	if (!test_and_clear_bit(PWMF_REQUESTED, &pwm->flags)) {
1543 		pwm->chip->ops->free(pwm->chip, pwm);
1545 	pwm->label = NULL;
1555 static void devm_pwm_release(void *pwm)
1557 	pwm_put(pwm);
1573 	struct pwm_device *pwm;
1576 	pwm = pwm_get(dev, con_id);
1577 	if (IS_ERR(pwm))
1578 		return pwm;
1580 	ret = devm_add_action_or_reset(dev, devm_pwm_release, pwm);
1584 	return pwm;
1604 	struct pwm_device *pwm = ERR_PTR(-ENODEV);
1608 		pwm = of_pwm_get(dev, to_of_node(fwnode), con_id);
1610 		pwm = acpi_pwm_get(fwnode);
1611 	if (IS_ERR(pwm))
1612 		return pwm;
1614 	ret = devm_add_action_or_reset(dev, devm_pwm_release, pwm);
1618 	return pwm;
1627 		struct pwm_device *pwm = &chip->pwms[i];
1630 		pwm_get_state(pwm, &state);
1632 		seq_printf(s, " pwm-%-3d (%-20.20s):", i, pwm->label);
1634 		if (test_bit(PWMF_REQUESTED, &pwm->flags))
1709 		debugfs_create_file("pwm", 0444, NULL, NULL, &pwm_debugfs_fops);