Commit | Line | Data |
---|---|---|
cef8ec8c LW |
1 | // SPDX-License-Identifier: GPL-2.0 |
2 | // Copyright (C) 2020 Luca Weiss <luca@z3ntu.xyz> | |
3 | ||
4 | #include <linux/gpio/consumer.h> | |
5 | #include <linux/led-class-flash.h> | |
6 | #include <linux/module.h> | |
7 | #include <linux/regulator/consumer.h> | |
8 | #include <linux/platform_device.h> | |
9 | ||
10 | #include <media/v4l2-flash-led-class.h> | |
11 | ||
12 | #define FLASH_TIMEOUT_DEFAULT 250000U /* 250ms */ | |
13 | #define FLASH_MAX_TIMEOUT_DEFAULT 300000U /* 300ms */ | |
14 | ||
15 | struct sgm3140 { | |
16 | struct led_classdev_flash fled_cdev; | |
17 | struct v4l2_flash *v4l2_flash; | |
18 | ||
19 | struct timer_list powerdown_timer; | |
20 | ||
21 | struct gpio_desc *flash_gpio; | |
22 | struct gpio_desc *enable_gpio; | |
23 | struct regulator *vin_regulator; | |
24 | ||
25 | bool enabled; | |
26 | ||
27 | /* current timeout in us */ | |
28 | u32 timeout; | |
29 | /* maximum timeout in us */ | |
30 | u32 max_timeout; | |
31 | }; | |
32 | ||
33 | static struct sgm3140 *flcdev_to_sgm3140(struct led_classdev_flash *flcdev) | |
34 | { | |
35 | return container_of(flcdev, struct sgm3140, fled_cdev); | |
36 | } | |
37 | ||
38 | static int sgm3140_strobe_set(struct led_classdev_flash *fled_cdev, bool state) | |
39 | { | |
40 | struct sgm3140 *priv = flcdev_to_sgm3140(fled_cdev); | |
41 | int ret; | |
42 | ||
43 | if (priv->enabled == state) | |
44 | return 0; | |
45 | ||
46 | if (state) { | |
47 | ret = regulator_enable(priv->vin_regulator); | |
48 | if (ret) { | |
49 | dev_err(fled_cdev->led_cdev.dev, | |
50 | "failed to enable regulator: %d\n", ret); | |
51 | return ret; | |
52 | } | |
53 | gpiod_set_value_cansleep(priv->flash_gpio, 1); | |
54 | gpiod_set_value_cansleep(priv->enable_gpio, 1); | |
55 | mod_timer(&priv->powerdown_timer, | |
56 | jiffies + usecs_to_jiffies(priv->timeout)); | |
57 | } else { | |
58 | del_timer_sync(&priv->powerdown_timer); | |
59 | gpiod_set_value_cansleep(priv->enable_gpio, 0); | |
60 | gpiod_set_value_cansleep(priv->flash_gpio, 0); | |
61 | ret = regulator_disable(priv->vin_regulator); | |
62 | if (ret) { | |
63 | dev_err(fled_cdev->led_cdev.dev, | |
64 | "failed to disable regulator: %d\n", ret); | |
65 | return ret; | |
66 | } | |
67 | } | |
68 | ||
69 | priv->enabled = state; | |
70 | ||
71 | return 0; | |
72 | } | |
73 | ||
74 | static int sgm3140_strobe_get(struct led_classdev_flash *fled_cdev, bool *state) | |
75 | { | |
76 | struct sgm3140 *priv = flcdev_to_sgm3140(fled_cdev); | |
77 | ||
78 | *state = timer_pending(&priv->powerdown_timer); | |
79 | ||
80 | return 0; | |
81 | } | |
82 | ||
83 | static int sgm3140_timeout_set(struct led_classdev_flash *fled_cdev, | |
84 | u32 timeout) | |
85 | { | |
86 | struct sgm3140 *priv = flcdev_to_sgm3140(fled_cdev); | |
87 | ||
88 | priv->timeout = timeout; | |
89 | ||
90 | return 0; | |
91 | } | |
92 | ||
93 | static const struct led_flash_ops sgm3140_flash_ops = { | |
94 | .strobe_set = sgm3140_strobe_set, | |
95 | .strobe_get = sgm3140_strobe_get, | |
96 | .timeout_set = sgm3140_timeout_set, | |
97 | }; | |
98 | ||
99 | static int sgm3140_brightness_set(struct led_classdev *led_cdev, | |
100 | enum led_brightness brightness) | |
101 | { | |
102 | struct led_classdev_flash *fled_cdev = lcdev_to_flcdev(led_cdev); | |
103 | struct sgm3140 *priv = flcdev_to_sgm3140(fled_cdev); | |
104 | bool enable = brightness == LED_ON; | |
105 | int ret; | |
106 | ||
107 | if (priv->enabled == enable) | |
108 | return 0; | |
109 | ||
110 | if (enable) { | |
111 | ret = regulator_enable(priv->vin_regulator); | |
112 | if (ret) { | |
113 | dev_err(led_cdev->dev, | |
114 | "failed to enable regulator: %d\n", ret); | |
115 | return ret; | |
116 | } | |
117 | gpiod_set_value_cansleep(priv->enable_gpio, 1); | |
118 | } else { | |
119 | gpiod_set_value_cansleep(priv->enable_gpio, 0); | |
120 | ret = regulator_disable(priv->vin_regulator); | |
121 | if (ret) { | |
122 | dev_err(led_cdev->dev, | |
123 | "failed to disable regulator: %d\n", ret); | |
124 | return ret; | |
125 | } | |
126 | } | |
127 | ||
128 | priv->enabled = enable; | |
129 | ||
130 | return 0; | |
131 | } | |
132 | ||
133 | static void sgm3140_powerdown_timer(struct timer_list *t) | |
134 | { | |
135 | struct sgm3140 *priv = from_timer(priv, t, powerdown_timer); | |
136 | ||
137 | gpiod_set_value(priv->enable_gpio, 0); | |
138 | gpiod_set_value(priv->flash_gpio, 0); | |
139 | regulator_disable(priv->vin_regulator); | |
140 | ||
141 | priv->enabled = false; | |
142 | } | |
143 | ||
144 | static void sgm3140_init_flash_timeout(struct sgm3140 *priv) | |
145 | { | |
146 | struct led_classdev_flash *fled_cdev = &priv->fled_cdev; | |
147 | struct led_flash_setting *s; | |
148 | ||
149 | /* Init flash timeout setting */ | |
150 | s = &fled_cdev->timeout; | |
151 | s->min = 1; | |
152 | s->max = priv->max_timeout; | |
153 | s->step = 1; | |
154 | s->val = FLASH_TIMEOUT_DEFAULT; | |
155 | } | |
156 | ||
157 | #if IS_ENABLED(CONFIG_V4L2_FLASH_LED_CLASS) | |
158 | static void sgm3140_init_v4l2_flash_config(struct sgm3140 *priv, | |
159 | struct v4l2_flash_config *v4l2_sd_cfg) | |
160 | { | |
161 | struct led_classdev *led_cdev = &priv->fled_cdev.led_cdev; | |
162 | struct led_flash_setting *s; | |
163 | ||
164 | strscpy(v4l2_sd_cfg->dev_name, led_cdev->dev->kobj.name, | |
165 | sizeof(v4l2_sd_cfg->dev_name)); | |
166 | ||
167 | /* Init flash intensity setting */ | |
168 | s = &v4l2_sd_cfg->intensity; | |
169 | s->min = 0; | |
170 | s->max = 1; | |
171 | s->step = 1; | |
172 | s->val = 1; | |
173 | } | |
174 | ||
175 | #else | |
176 | static void sgm3140_init_v4l2_flash_config(struct sgm3140 *priv, | |
177 | struct v4l2_flash_config *v4l2_sd_cfg) | |
178 | { | |
179 | } | |
180 | #endif | |
181 | ||
182 | static int sgm3140_probe(struct platform_device *pdev) | |
183 | { | |
184 | struct sgm3140 *priv; | |
185 | struct led_classdev *led_cdev; | |
186 | struct led_classdev_flash *fled_cdev; | |
187 | struct led_init_data init_data = {}; | |
188 | struct fwnode_handle *child_node; | |
189 | struct v4l2_flash_config v4l2_sd_cfg = {}; | |
190 | int ret; | |
191 | ||
192 | priv = devm_kzalloc(&pdev->dev, sizeof(*priv), GFP_KERNEL); | |
193 | if (!priv) | |
194 | return -ENOMEM; | |
195 | ||
196 | priv->flash_gpio = devm_gpiod_get(&pdev->dev, "flash", GPIOD_OUT_LOW); | |
197 | ret = PTR_ERR_OR_ZERO(priv->flash_gpio); | |
4582e783 KK |
198 | if (ret) |
199 | return dev_err_probe(&pdev->dev, ret, | |
200 | "Failed to request flash gpio\n"); | |
cef8ec8c LW |
201 | |
202 | priv->enable_gpio = devm_gpiod_get(&pdev->dev, "enable", GPIOD_OUT_LOW); | |
203 | ret = PTR_ERR_OR_ZERO(priv->enable_gpio); | |
4582e783 KK |
204 | if (ret) |
205 | return dev_err_probe(&pdev->dev, ret, | |
206 | "Failed to request enable gpio\n"); | |
cef8ec8c LW |
207 | |
208 | priv->vin_regulator = devm_regulator_get(&pdev->dev, "vin"); | |
209 | ret = PTR_ERR_OR_ZERO(priv->vin_regulator); | |
4582e783 KK |
210 | if (ret) |
211 | return dev_err_probe(&pdev->dev, ret, | |
212 | "Failed to request regulator\n"); | |
cef8ec8c LW |
213 | |
214 | child_node = fwnode_get_next_available_child_node(pdev->dev.fwnode, | |
215 | NULL); | |
216 | if (!child_node) { | |
217 | dev_err(&pdev->dev, | |
218 | "No fwnode child node found for connected LED.\n"); | |
219 | return -EINVAL; | |
220 | } | |
221 | ||
222 | ret = fwnode_property_read_u32(child_node, "flash-max-timeout-us", | |
223 | &priv->max_timeout); | |
224 | if (ret) { | |
225 | priv->max_timeout = FLASH_MAX_TIMEOUT_DEFAULT; | |
226 | dev_warn(&pdev->dev, | |
227 | "flash-max-timeout-us property missing\n"); | |
228 | } | |
229 | ||
230 | /* | |
231 | * Set default timeout to FLASH_DEFAULT_TIMEOUT except if max_timeout | |
232 | * from DT is lower. | |
233 | */ | |
234 | priv->timeout = min(priv->max_timeout, FLASH_TIMEOUT_DEFAULT); | |
235 | ||
236 | timer_setup(&priv->powerdown_timer, sgm3140_powerdown_timer, 0); | |
237 | ||
238 | fled_cdev = &priv->fled_cdev; | |
239 | led_cdev = &fled_cdev->led_cdev; | |
240 | ||
241 | fled_cdev->ops = &sgm3140_flash_ops; | |
242 | ||
243 | led_cdev->brightness_set_blocking = sgm3140_brightness_set; | |
244 | led_cdev->max_brightness = LED_ON; | |
245 | led_cdev->flags |= LED_DEV_CAP_FLASH; | |
246 | ||
247 | sgm3140_init_flash_timeout(priv); | |
248 | ||
249 | init_data.fwnode = child_node; | |
250 | ||
251 | platform_set_drvdata(pdev, priv); | |
252 | ||
253 | /* Register in the LED subsystem */ | |
254 | ret = devm_led_classdev_flash_register_ext(&pdev->dev, | |
255 | fled_cdev, &init_data); | |
256 | if (ret) { | |
257 | dev_err(&pdev->dev, "Failed to register flash device: %d\n", | |
258 | ret); | |
259 | goto err; | |
260 | } | |
261 | ||
262 | sgm3140_init_v4l2_flash_config(priv, &v4l2_sd_cfg); | |
263 | ||
264 | /* Create V4L2 Flash subdev */ | |
265 | priv->v4l2_flash = v4l2_flash_init(&pdev->dev, | |
266 | child_node, | |
267 | fled_cdev, NULL, | |
268 | &v4l2_sd_cfg); | |
269 | if (IS_ERR(priv->v4l2_flash)) { | |
270 | ret = PTR_ERR(priv->v4l2_flash); | |
271 | goto err; | |
272 | } | |
273 | ||
274 | return ret; | |
275 | ||
276 | err: | |
277 | fwnode_handle_put(child_node); | |
278 | return ret; | |
279 | } | |
280 | ||
281 | static int sgm3140_remove(struct platform_device *pdev) | |
282 | { | |
283 | struct sgm3140 *priv = platform_get_drvdata(pdev); | |
284 | ||
285 | del_timer_sync(&priv->powerdown_timer); | |
286 | ||
287 | v4l2_flash_release(priv->v4l2_flash); | |
288 | ||
289 | return 0; | |
290 | } | |
291 | ||
292 | static const struct of_device_id sgm3140_dt_match[] = { | |
293 | { .compatible = "sgmicro,sgm3140" }, | |
294 | { /* sentinel */ } | |
295 | }; | |
296 | MODULE_DEVICE_TABLE(of, sgm3140_dt_match); | |
297 | ||
298 | static struct platform_driver sgm3140_driver = { | |
299 | .probe = sgm3140_probe, | |
300 | .remove = sgm3140_remove, | |
301 | .driver = { | |
302 | .name = "sgm3140", | |
303 | .of_match_table = sgm3140_dt_match, | |
304 | }, | |
305 | }; | |
306 | ||
307 | module_platform_driver(sgm3140_driver); | |
308 | ||
309 | MODULE_AUTHOR("Luca Weiss <luca@z3ntu.xyz>"); | |
deae5de3 | 310 | MODULE_DESCRIPTION("SG Micro SGM3140 charge pump LED driver"); |
cef8ec8c | 311 | MODULE_LICENSE("GPL v2"); |