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 
17 struct gb_pwm_chip {
18 	struct gb_connection	*connection;
19 	struct pwm_chip		chip;
20 };
21 
pwm_chip_to_gb_pwm_chip(struct pwm_chip * chip)22 static 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 
gb_pwm_get_npwm(struct gb_connection * connection)27 static 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 
gb_pwm_activate_operation(struct pwm_chip * chip,u8 which)44 static 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 
gb_pwm_deactivate_operation(struct pwm_chip * chip,u8 which)66 static 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 
gb_pwm_config_operation(struct pwm_chip * chip,u8 which,u32 duty,u32 period)88 static 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 
gb_pwm_set_polarity_operation(struct pwm_chip * chip,u8 which,u8 polarity)113 static 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 
gb_pwm_enable_operation(struct pwm_chip * chip,u8 which)137 static 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 
gb_pwm_disable_operation(struct pwm_chip * chip,u8 which)159 static 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 
gb_pwm_request(struct pwm_chip * chip,struct pwm_device * pwm)177 static int gb_pwm_request(struct pwm_chip *chip, struct pwm_device *pwm)
178 {
179 	return gb_pwm_activate_operation(chip, pwm->hwpwm);
180 };
181 
gb_pwm_free(struct pwm_chip * chip,struct pwm_device * pwm)182 static 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 
gb_pwm_apply(struct pwm_chip * chip,struct pwm_device * pwm,const struct pwm_state * state)190 static 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 
238 static const struct pwm_ops gb_pwm_ops = {
239 	.request = gb_pwm_request,
240 	.free = gb_pwm_free,
241 	.apply = gb_pwm_apply,
242 };
243 
gb_pwm_probe(struct gbphy_device * gbphy_dev,const struct gbphy_device_id * id)244 static 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 
290 exit_pwmchip_put:
291 	pwmchip_put(chip);
292 exit_connection_disable:
293 	gb_connection_disable(connection);
294 exit_connection_destroy:
295 	gb_connection_destroy(connection);
296 	return ret;
297 }
298 
gb_pwm_remove(struct gbphy_device * gbphy_dev)299 static 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 
316 static const struct gbphy_device_id gb_pwm_id_table[] = {
317 	{ GBPHY_PROTOCOL(GREYBUS_PROTOCOL_PWM) },
318 	{ },
319 };
320 MODULE_DEVICE_TABLE(gbphy, gb_pwm_id_table);
321 
322 static 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 
329 module_gbphy_driver(pwm_driver);
330 MODULE_DESCRIPTION("PWM Greybus driver");
331 MODULE_LICENSE("GPL v2");
332