Loading...
1// SPDX-License-Identifier: GPL-2.0
2/*
3 * PWM Greybus driver.
4 *
5 * Copyright 2014 Google Inc.
6 * Copyright 2014 Linaro Ltd.
7 */
8
9#include <linux/kernel.h>
10#include <linux/module.h>
11#include <linux/slab.h>
12#include <linux/pwm.h>
13#include <linux/greybus.h>
14
15#include "gbphy.h"
16
17struct gb_pwm_chip {
18 struct gb_connection *connection;
19 struct pwm_chip chip;
20};
21
22static inline struct gb_pwm_chip *pwm_chip_to_gb_pwm_chip(struct pwm_chip *chip)
23{
24 return container_of(chip, struct gb_pwm_chip, chip);
25}
26
27static int gb_pwm_get_npwm(struct gb_connection *connection)
28{
29 struct gb_pwm_count_response response;
30 int ret;
31
32 ret = gb_operation_sync(connection, GB_PWM_TYPE_PWM_COUNT,
33 NULL, 0, &response, sizeof(response));
34 if (ret)
35 return ret;
36
37 /*
38 * The request returns the highest allowed PWM id parameter. So add one
39 * to get the number of PWMs.
40 */
41 return response.count + 1;
42}
43
44static int gb_pwm_activate_operation(struct pwm_chip *chip, u8 which)
45{
46 struct gb_pwm_chip *pwmc = pwm_chip_to_gb_pwm_chip(chip);
47 struct gb_pwm_activate_request request;
48 struct gbphy_device *gbphy_dev;
49 int ret;
50
51 request.which = which;
52
53 gbphy_dev = to_gbphy_dev(pwmchip_parent(chip));
54 ret = gbphy_runtime_get_sync(gbphy_dev);
55 if (ret)
56 return ret;
57
58 ret = gb_operation_sync(pwmc->connection, GB_PWM_TYPE_ACTIVATE,
59 &request, sizeof(request), NULL, 0);
60
61 gbphy_runtime_put_autosuspend(gbphy_dev);
62
63 return ret;
64}
65
66static int gb_pwm_deactivate_operation(struct pwm_chip *chip, u8 which)
67{
68 struct gb_pwm_chip *pwmc = pwm_chip_to_gb_pwm_chip(chip);
69 struct gb_pwm_deactivate_request request;
70 struct gbphy_device *gbphy_dev;
71 int ret;
72
73 request.which = which;
74
75 gbphy_dev = to_gbphy_dev(pwmchip_parent(chip));
76 ret = gbphy_runtime_get_sync(gbphy_dev);
77 if (ret)
78 return ret;
79
80 ret = gb_operation_sync(pwmc->connection, GB_PWM_TYPE_DEACTIVATE,
81 &request, sizeof(request), NULL, 0);
82
83 gbphy_runtime_put_autosuspend(gbphy_dev);
84
85 return ret;
86}
87
88static int gb_pwm_config_operation(struct pwm_chip *chip,
89 u8 which, u32 duty, u32 period)
90{
91 struct gb_pwm_chip *pwmc = pwm_chip_to_gb_pwm_chip(chip);
92 struct gb_pwm_config_request request;
93 struct gbphy_device *gbphy_dev;
94 int ret;
95
96 request.which = which;
97 request.duty = cpu_to_le32(duty);
98 request.period = cpu_to_le32(period);
99
100 gbphy_dev = to_gbphy_dev(pwmchip_parent(chip));
101 ret = gbphy_runtime_get_sync(gbphy_dev);
102 if (ret)
103 return ret;
104
105 ret = gb_operation_sync(pwmc->connection, GB_PWM_TYPE_CONFIG,
106 &request, sizeof(request), NULL, 0);
107
108 gbphy_runtime_put_autosuspend(gbphy_dev);
109
110 return ret;
111}
112
113static int gb_pwm_set_polarity_operation(struct pwm_chip *chip,
114 u8 which, u8 polarity)
115{
116 struct gb_pwm_chip *pwmc = pwm_chip_to_gb_pwm_chip(chip);
117 struct gb_pwm_polarity_request request;
118 struct gbphy_device *gbphy_dev;
119 int ret;
120
121 request.which = which;
122 request.polarity = polarity;
123
124 gbphy_dev = to_gbphy_dev(pwmchip_parent(chip));
125 ret = gbphy_runtime_get_sync(gbphy_dev);
126 if (ret)
127 return ret;
128
129 ret = gb_operation_sync(pwmc->connection, GB_PWM_TYPE_POLARITY,
130 &request, sizeof(request), NULL, 0);
131
132 gbphy_runtime_put_autosuspend(gbphy_dev);
133
134 return ret;
135}
136
137static int gb_pwm_enable_operation(struct pwm_chip *chip, u8 which)
138{
139 struct gb_pwm_chip *pwmc = pwm_chip_to_gb_pwm_chip(chip);
140 struct gb_pwm_enable_request request;
141 struct gbphy_device *gbphy_dev;
142 int ret;
143
144 request.which = which;
145
146 gbphy_dev = to_gbphy_dev(pwmchip_parent(chip));
147 ret = gbphy_runtime_get_sync(gbphy_dev);
148 if (ret)
149 return ret;
150
151 ret = gb_operation_sync(pwmc->connection, GB_PWM_TYPE_ENABLE,
152 &request, sizeof(request), NULL, 0);
153 if (ret)
154 gbphy_runtime_put_autosuspend(gbphy_dev);
155
156 return ret;
157}
158
159static int gb_pwm_disable_operation(struct pwm_chip *chip, u8 which)
160{
161 struct gb_pwm_chip *pwmc = pwm_chip_to_gb_pwm_chip(chip);
162 struct gb_pwm_disable_request request;
163 struct gbphy_device *gbphy_dev;
164 int ret;
165
166 request.which = which;
167
168 ret = gb_operation_sync(pwmc->connection, GB_PWM_TYPE_DISABLE,
169 &request, sizeof(request), NULL, 0);
170
171 gbphy_dev = to_gbphy_dev(pwmchip_parent(chip));
172 gbphy_runtime_put_autosuspend(gbphy_dev);
173
174 return ret;
175}
176
177static int gb_pwm_request(struct pwm_chip *chip, struct pwm_device *pwm)
178{
179 return gb_pwm_activate_operation(chip, pwm->hwpwm);
180};
181
182static void gb_pwm_free(struct pwm_chip *chip, struct pwm_device *pwm)
183{
184 if (pwm_is_enabled(pwm))
185 dev_warn(pwmchip_parent(chip), "freeing PWM device without disabling\n");
186
187 gb_pwm_deactivate_operation(chip, pwm->hwpwm);
188}
189
190static int gb_pwm_apply(struct pwm_chip *chip, struct pwm_device *pwm,
191 const struct pwm_state *state)
192{
193 int err;
194 bool enabled = pwm->state.enabled;
195 u64 period = state->period;
196 u64 duty_cycle = state->duty_cycle;
197
198 /* Set polarity */
199 if (state->polarity != pwm->state.polarity) {
200 if (enabled) {
201 gb_pwm_disable_operation(chip, pwm->hwpwm);
202 enabled = false;
203 }
204 err = gb_pwm_set_polarity_operation(chip, pwm->hwpwm, state->polarity);
205 if (err)
206 return err;
207 }
208
209 if (!state->enabled) {
210 if (enabled)
211 gb_pwm_disable_operation(chip, pwm->hwpwm);
212 return 0;
213 }
214
215 /*
216 * Set period and duty cycle
217 *
218 * PWM privodes 64-bit period and duty_cycle, but greybus only accepts
219 * 32-bit, so their values have to be limited to U32_MAX.
220 */
221 if (period > U32_MAX)
222 period = U32_MAX;
223
224 if (duty_cycle > period)
225 duty_cycle = period;
226
227 err = gb_pwm_config_operation(chip, pwm->hwpwm, duty_cycle, period);
228 if (err)
229 return err;
230
231 /* enable/disable */
232 if (!enabled)
233 return gb_pwm_enable_operation(chip, pwm->hwpwm);
234
235 return 0;
236}
237
238static const struct pwm_ops gb_pwm_ops = {
239 .request = gb_pwm_request,
240 .free = gb_pwm_free,
241 .apply = gb_pwm_apply,
242};
243
244static int gb_pwm_probe(struct gbphy_device *gbphy_dev,
245 const struct gbphy_device_id *id)
246{
247 struct gb_connection *connection;
248 struct gb_pwm_chip *pwmc;
249 struct pwm_chip *chip;
250 int ret, npwm;
251
252 connection = gb_connection_create(gbphy_dev->bundle,
253 le16_to_cpu(gbphy_dev->cport_desc->id),
254 NULL);
255 if (IS_ERR(connection))
256 return PTR_ERR(connection);
257
258 ret = gb_connection_enable(connection);
259 if (ret)
260 goto exit_connection_destroy;
261
262 /* Query number of pwms present */
263 ret = gb_pwm_get_npwm(connection);
264 if (ret < 0)
265 goto exit_connection_disable;
266 npwm = ret;
267
268 chip = pwmchip_alloc(&gbphy_dev->dev, npwm, sizeof(*pwmc));
269 if (IS_ERR(chip)) {
270 ret = PTR_ERR(chip);
271 goto exit_connection_disable;
272 }
273 gb_gbphy_set_data(gbphy_dev, chip);
274
275 pwmc = pwm_chip_to_gb_pwm_chip(chip);
276 pwmc->connection = connection;
277
278 chip->ops = &gb_pwm_ops;
279
280 ret = pwmchip_add(chip);
281 if (ret) {
282 dev_err(&gbphy_dev->dev,
283 "failed to register PWM: %d\n", ret);
284 goto exit_pwmchip_put;
285 }
286
287 gbphy_runtime_put_autosuspend(gbphy_dev);
288 return 0;
289
290exit_pwmchip_put:
291 pwmchip_put(chip);
292exit_connection_disable:
293 gb_connection_disable(connection);
294exit_connection_destroy:
295 gb_connection_destroy(connection);
296 return ret;
297}
298
299static void gb_pwm_remove(struct gbphy_device *gbphy_dev)
300{
301 struct pwm_chip *chip = gb_gbphy_get_data(gbphy_dev);
302 struct gb_pwm_chip *pwmc = pwm_chip_to_gb_pwm_chip(chip);
303 struct gb_connection *connection = pwmc->connection;
304 int ret;
305
306 ret = gbphy_runtime_get_sync(gbphy_dev);
307 if (ret)
308 gbphy_runtime_get_noresume(gbphy_dev);
309
310 pwmchip_remove(chip);
311 pwmchip_put(chip);
312 gb_connection_disable(connection);
313 gb_connection_destroy(connection);
314}
315
316static const struct gbphy_device_id gb_pwm_id_table[] = {
317 { GBPHY_PROTOCOL(GREYBUS_PROTOCOL_PWM) },
318 { },
319};
320MODULE_DEVICE_TABLE(gbphy, gb_pwm_id_table);
321
322static struct gbphy_driver pwm_driver = {
323 .name = "pwm",
324 .probe = gb_pwm_probe,
325 .remove = gb_pwm_remove,
326 .id_table = gb_pwm_id_table,
327};
328
329module_gbphy_driver(pwm_driver);
330MODULE_LICENSE("GPL v2");