1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3 * Copyright (C) 2024 Analog Devices Inc.
4 * Copyright (C) 2024 BayLibre, SAS
5 *
6 * Generic PWM trigger for SPI offload.
7 */
8
9 #include <linux/device.h>
10 #include <linux/err.h>
11 #include <linux/math.h>
12 #include <linux/mod_devicetable.h>
13 #include <linux/module.h>
14 #include <linux/platform_device.h>
15 #include <linux/property.h>
16 #include <linux/pwm.h>
17 #include <linux/spi/offload/provider.h>
18 #include <linux/spi/offload/types.h>
19 #include <linux/time.h>
20 #include <linux/types.h>
21
22 struct spi_offload_trigger_pwm_state {
23 struct device *dev;
24 struct pwm_device *pwm;
25 };
26
spi_offload_trigger_pwm_match(struct spi_offload_trigger * trigger,enum spi_offload_trigger_type type,u64 * args,u32 nargs)27 static bool spi_offload_trigger_pwm_match(struct spi_offload_trigger *trigger,
28 enum spi_offload_trigger_type type,
29 u64 *args, u32 nargs)
30 {
31 if (nargs)
32 return false;
33
34 return type == SPI_OFFLOAD_TRIGGER_PERIODIC;
35 }
36
spi_offload_trigger_pwm_validate(struct spi_offload_trigger * trigger,struct spi_offload_trigger_config * config)37 static int spi_offload_trigger_pwm_validate(struct spi_offload_trigger *trigger,
38 struct spi_offload_trigger_config *config)
39 {
40 struct spi_offload_trigger_pwm_state *st = spi_offload_trigger_get_priv(trigger);
41 struct spi_offload_trigger_periodic *periodic = &config->periodic;
42 struct pwm_waveform wf = { };
43 int ret;
44
45 if (config->type != SPI_OFFLOAD_TRIGGER_PERIODIC)
46 return -EINVAL;
47
48 if (!periodic->frequency_hz)
49 return -EINVAL;
50
51 wf.period_length_ns = DIV_ROUND_UP_ULL(NSEC_PER_SEC, periodic->frequency_hz);
52 /* REVISIT: 50% duty-cycle for now - may add config parameter later */
53 wf.duty_length_ns = wf.period_length_ns / 2;
54
55 ret = pwm_round_waveform_might_sleep(st->pwm, &wf);
56 if (ret < 0)
57 return ret;
58
59 periodic->frequency_hz = DIV_ROUND_UP_ULL(NSEC_PER_SEC, wf.period_length_ns);
60
61 return 0;
62 }
63
spi_offload_trigger_pwm_enable(struct spi_offload_trigger * trigger,struct spi_offload_trigger_config * config)64 static int spi_offload_trigger_pwm_enable(struct spi_offload_trigger *trigger,
65 struct spi_offload_trigger_config *config)
66 {
67 struct spi_offload_trigger_pwm_state *st = spi_offload_trigger_get_priv(trigger);
68 struct spi_offload_trigger_periodic *periodic = &config->periodic;
69 struct pwm_waveform wf = { };
70
71 if (config->type != SPI_OFFLOAD_TRIGGER_PERIODIC)
72 return -EINVAL;
73
74 if (!periodic->frequency_hz)
75 return -EINVAL;
76
77 wf.period_length_ns = DIV_ROUND_UP_ULL(NSEC_PER_SEC, periodic->frequency_hz);
78 /* REVISIT: 50% duty-cycle for now - may add config parameter later */
79 wf.duty_length_ns = wf.period_length_ns / 2;
80
81 return pwm_set_waveform_might_sleep(st->pwm, &wf, false);
82 }
83
spi_offload_trigger_pwm_disable(struct spi_offload_trigger * trigger)84 static void spi_offload_trigger_pwm_disable(struct spi_offload_trigger *trigger)
85 {
86 struct spi_offload_trigger_pwm_state *st = spi_offload_trigger_get_priv(trigger);
87 struct pwm_waveform wf;
88 int ret;
89
90 ret = pwm_get_waveform_might_sleep(st->pwm, &wf);
91 if (ret < 0) {
92 dev_err(st->dev, "failed to get waveform: %d\n", ret);
93 return;
94 }
95
96 wf.duty_length_ns = 0;
97
98 ret = pwm_set_waveform_might_sleep(st->pwm, &wf, false);
99 if (ret < 0)
100 dev_err(st->dev, "failed to disable PWM: %d\n", ret);
101 }
102
103 static const struct spi_offload_trigger_ops spi_offload_trigger_pwm_ops = {
104 .match = spi_offload_trigger_pwm_match,
105 .validate = spi_offload_trigger_pwm_validate,
106 .enable = spi_offload_trigger_pwm_enable,
107 .disable = spi_offload_trigger_pwm_disable,
108 };
109
spi_offload_trigger_pwm_release(void * data)110 static void spi_offload_trigger_pwm_release(void *data)
111 {
112 pwm_disable(data);
113 }
114
spi_offload_trigger_pwm_probe(struct platform_device * pdev)115 static int spi_offload_trigger_pwm_probe(struct platform_device *pdev)
116 {
117 struct device *dev = &pdev->dev;
118 struct spi_offload_trigger_info info = {
119 .fwnode = dev_fwnode(dev),
120 .ops = &spi_offload_trigger_pwm_ops,
121 };
122 struct spi_offload_trigger_pwm_state *st;
123 struct pwm_state state;
124 int ret;
125
126 st = devm_kzalloc(dev, sizeof(*st), GFP_KERNEL);
127 if (!st)
128 return -ENOMEM;
129
130 info.priv = st;
131 st->dev = dev;
132
133 st->pwm = devm_pwm_get(dev, NULL);
134 if (IS_ERR(st->pwm))
135 return dev_err_probe(dev, PTR_ERR(st->pwm), "failed to get PWM\n");
136
137 /* init with duty_cycle = 0, output enabled to ensure trigger off */
138 pwm_init_state(st->pwm, &state);
139 state.enabled = true;
140
141 ret = pwm_apply_might_sleep(st->pwm, &state);
142 if (ret < 0)
143 return dev_err_probe(dev, ret, "failed to apply PWM state\n");
144
145 ret = devm_add_action_or_reset(dev, spi_offload_trigger_pwm_release, st->pwm);
146 if (ret)
147 return ret;
148
149 return devm_spi_offload_trigger_register(dev, &info);
150 }
151
152 static const struct of_device_id spi_offload_trigger_pwm_of_match_table[] = {
153 { .compatible = "pwm-trigger" },
154 { }
155 };
156 MODULE_DEVICE_TABLE(of, spi_offload_trigger_pwm_of_match_table);
157
158 static struct platform_driver spi_offload_trigger_pwm_driver = {
159 .driver = {
160 .name = "pwm-trigger",
161 .of_match_table = spi_offload_trigger_pwm_of_match_table,
162 },
163 .probe = spi_offload_trigger_pwm_probe,
164 };
165 module_platform_driver(spi_offload_trigger_pwm_driver);
166
167 MODULE_AUTHOR("David Lechner <dlechner@baylibre.com>");
168 MODULE_DESCRIPTION("Generic PWM trigger");
169 MODULE_LICENSE("GPL");
170