1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3  * Copyright (C) 2009 Nokia Corporation
4  * Author: Tomi Valkeinen <tomi.valkeinen@nokia.com>
5  *
6  * Some code and ideas taken from drivers/video/omap/ driver
7  * by Imre Deak.
8  */
9 
10 #define DSS_SUBSYS_NAME "MANAGER"
11 
12 #include <linux/kernel.h>
13 #include <linux/kstrtox.h>
14 #include <linux/slab.h>
15 #include <linux/module.h>
16 #include <linux/platform_device.h>
17 #include <linux/jiffies.h>
18 
19 #include <video/omapfb_dss.h>
20 
21 #include "dss.h"
22 #include "dss_features.h"
23 
24 static ssize_t manager_name_show(struct omap_overlay_manager *mgr, char *buf)
25 {
26 	return sysfs_emit(buf, "%s\n", mgr->name);
27 }
28 
29 static ssize_t manager_display_show(struct omap_overlay_manager *mgr, char *buf)
30 {
31 	struct omap_dss_device *dssdev = mgr->get_device(mgr);
32 
33 	return sysfs_emit(buf, "%s\n", dssdev ?
34 			dssdev->name : "<none>");
35 }
36 
37 static int manager_display_match(struct omap_dss_device *dssdev, void *data)
38 {
39 	const char *str = data;
40 
41 	return sysfs_streq(dssdev->name, str);
42 }
43 
44 static ssize_t manager_display_store(struct omap_overlay_manager *mgr,
45 		const char *buf, size_t size)
46 {
47 	int r = 0;
48 	size_t len = size;
49 	struct omap_dss_device *dssdev = NULL;
50 	struct omap_dss_device *old_dssdev;
51 
52 	if (buf[size-1] == '\n')
53 		--len;
54 
55 	if (len > 0)
56 		dssdev = omap_dss_find_device((void *)buf,
57 			manager_display_match);
58 
59 	if (len > 0 && dssdev == NULL)
60 		return -EINVAL;
61 
62 	if (dssdev) {
63 		DSSDBG("display %s found\n", dssdev->name);
64 
65 		if (omapdss_device_is_connected(dssdev)) {
66 			DSSERR("new display is already connected\n");
67 			r = -EINVAL;
68 			goto put_device;
69 		}
70 
71 		if (omapdss_device_is_enabled(dssdev)) {
72 			DSSERR("new display is not disabled\n");
73 			r = -EINVAL;
74 			goto put_device;
75 		}
76 	}
77 
78 	old_dssdev = mgr->get_device(mgr);
79 	if (old_dssdev) {
80 		if (omapdss_device_is_enabled(old_dssdev)) {
81 			DSSERR("old display is not disabled\n");
82 			r = -EINVAL;
83 			goto put_device;
84 		}
85 
86 		old_dssdev->driver->disconnect(old_dssdev);
87 	}
88 
89 	if (dssdev) {
90 		r = dssdev->driver->connect(dssdev);
91 		if (r) {
92 			DSSERR("failed to connect new device\n");
93 			goto put_device;
94 		}
95 
96 		old_dssdev = mgr->get_device(mgr);
97 		if (old_dssdev != dssdev) {
98 			DSSERR("failed to connect device to this manager\n");
99 			dssdev->driver->disconnect(dssdev);
100 			goto put_device;
101 		}
102 
103 		r = mgr->apply(mgr);
104 		if (r) {
105 			DSSERR("failed to apply dispc config\n");
106 			goto put_device;
107 		}
108 	}
109 
110 put_device:
111 	if (dssdev)
112 		omap_dss_put_device(dssdev);
113 
114 	return r ? r : size;
115 }
116 
117 static ssize_t manager_default_color_show(struct omap_overlay_manager *mgr,
118 					  char *buf)
119 {
120 	struct omap_overlay_manager_info info;
121 
122 	mgr->get_manager_info(mgr, &info);
123 
124 	return sysfs_emit(buf, "%#x\n", info.default_color);
125 }
126 
127 static ssize_t manager_default_color_store(struct omap_overlay_manager *mgr,
128 					   const char *buf, size_t size)
129 {
130 	struct omap_overlay_manager_info info;
131 	u32 color;
132 	int r;
133 
134 	r = kstrtouint(buf, 0, &color);
135 	if (r)
136 		return r;
137 
138 	mgr->get_manager_info(mgr, &info);
139 
140 	info.default_color = color;
141 
142 	r = mgr->set_manager_info(mgr, &info);
143 	if (r)
144 		return r;
145 
146 	r = mgr->apply(mgr);
147 	if (r)
148 		return r;
149 
150 	return size;
151 }
152 
153 static const char *trans_key_type_str[] = {
154 	"gfx-destination",
155 	"video-source",
156 };
157 
158 static ssize_t manager_trans_key_type_show(struct omap_overlay_manager *mgr,
159 					   char *buf)
160 {
161 	enum omap_dss_trans_key_type key_type;
162 	struct omap_overlay_manager_info info;
163 
164 	mgr->get_manager_info(mgr, &info);
165 
166 	key_type = info.trans_key_type;
167 	BUG_ON(key_type >= ARRAY_SIZE(trans_key_type_str));
168 
169 	return sysfs_emit(buf, "%s\n", trans_key_type_str[key_type]);
170 }
171 
172 static ssize_t manager_trans_key_type_store(struct omap_overlay_manager *mgr,
173 					    const char *buf, size_t size)
174 {
175 	struct omap_overlay_manager_info info;
176 	int r;
177 
178 	r = sysfs_match_string(trans_key_type_str, buf);
179 	if (r < 0)
180 		return r;
181 
182 	mgr->get_manager_info(mgr, &info);
183 
184 	info.trans_key_type = r;
185 
186 	r = mgr->set_manager_info(mgr, &info);
187 	if (r)
188 		return r;
189 
190 	r = mgr->apply(mgr);
191 	if (r)
192 		return r;
193 
194 	return size;
195 }
196 
197 static ssize_t manager_trans_key_value_show(struct omap_overlay_manager *mgr,
198 					    char *buf)
199 {
200 	struct omap_overlay_manager_info info;
201 
202 	mgr->get_manager_info(mgr, &info);
203 
204 	return sysfs_emit(buf, "%#x\n", info.trans_key);
205 }
206 
207 static ssize_t manager_trans_key_value_store(struct omap_overlay_manager *mgr,
208 					     const char *buf, size_t size)
209 {
210 	struct omap_overlay_manager_info info;
211 	u32 key_value;
212 	int r;
213 
214 	r = kstrtouint(buf, 0, &key_value);
215 	if (r)
216 		return r;
217 
218 	mgr->get_manager_info(mgr, &info);
219 
220 	info.trans_key = key_value;
221 
222 	r = mgr->set_manager_info(mgr, &info);
223 	if (r)
224 		return r;
225 
226 	r = mgr->apply(mgr);
227 	if (r)
228 		return r;
229 
230 	return size;
231 }
232 
233 static ssize_t manager_trans_key_enabled_show(struct omap_overlay_manager *mgr,
234 					      char *buf)
235 {
236 	struct omap_overlay_manager_info info;
237 
238 	mgr->get_manager_info(mgr, &info);
239 
240 	return sysfs_emit(buf, "%d\n", info.trans_enabled);
241 }
242 
243 static ssize_t manager_trans_key_enabled_store(struct omap_overlay_manager *mgr,
244 					       const char *buf, size_t size)
245 {
246 	struct omap_overlay_manager_info info;
247 	bool enable;
248 	int r;
249 
250 	r = kstrtobool(buf, &enable);
251 	if (r)
252 		return r;
253 
254 	mgr->get_manager_info(mgr, &info);
255 
256 	info.trans_enabled = enable;
257 
258 	r = mgr->set_manager_info(mgr, &info);
259 	if (r)
260 		return r;
261 
262 	r = mgr->apply(mgr);
263 	if (r)
264 		return r;
265 
266 	return size;
267 }
268 
269 static ssize_t manager_alpha_blending_enabled_show(
270 		struct omap_overlay_manager *mgr, char *buf)
271 {
272 	struct omap_overlay_manager_info info;
273 
274 	if(!dss_has_feature(FEAT_ALPHA_FIXED_ZORDER))
275 		return -ENODEV;
276 
277 	mgr->get_manager_info(mgr, &info);
278 
279 	return sysfs_emit(buf, "%d\n",
280 		info.partial_alpha_enabled);
281 }
282 
283 static ssize_t manager_alpha_blending_enabled_store(
284 		struct omap_overlay_manager *mgr,
285 		const char *buf, size_t size)
286 {
287 	struct omap_overlay_manager_info info;
288 	bool enable;
289 	int r;
290 
291 	if(!dss_has_feature(FEAT_ALPHA_FIXED_ZORDER))
292 		return -ENODEV;
293 
294 	r = kstrtobool(buf, &enable);
295 	if (r)
296 		return r;
297 
298 	mgr->get_manager_info(mgr, &info);
299 
300 	info.partial_alpha_enabled = enable;
301 
302 	r = mgr->set_manager_info(mgr, &info);
303 	if (r)
304 		return r;
305 
306 	r = mgr->apply(mgr);
307 	if (r)
308 		return r;
309 
310 	return size;
311 }
312 
313 static ssize_t manager_cpr_enable_show(struct omap_overlay_manager *mgr,
314 		char *buf)
315 {
316 	struct omap_overlay_manager_info info;
317 
318 	mgr->get_manager_info(mgr, &info);
319 
320 	return sysfs_emit(buf, "%d\n", info.cpr_enable);
321 }
322 
323 static ssize_t manager_cpr_enable_store(struct omap_overlay_manager *mgr,
324 		const char *buf, size_t size)
325 {
326 	struct omap_overlay_manager_info info;
327 	int r;
328 	bool enable;
329 
330 	if (!dss_has_feature(FEAT_CPR))
331 		return -ENODEV;
332 
333 	r = kstrtobool(buf, &enable);
334 	if (r)
335 		return r;
336 
337 	mgr->get_manager_info(mgr, &info);
338 
339 	if (info.cpr_enable == enable)
340 		return size;
341 
342 	info.cpr_enable = enable;
343 
344 	r = mgr->set_manager_info(mgr, &info);
345 	if (r)
346 		return r;
347 
348 	r = mgr->apply(mgr);
349 	if (r)
350 		return r;
351 
352 	return size;
353 }
354 
355 static ssize_t manager_cpr_coef_show(struct omap_overlay_manager *mgr,
356 		char *buf)
357 {
358 	struct omap_overlay_manager_info info;
359 
360 	mgr->get_manager_info(mgr, &info);
361 
362 	return sysfs_emit(buf,
363 			"%d %d %d %d %d %d %d %d %d\n",
364 			info.cpr_coefs.rr,
365 			info.cpr_coefs.rg,
366 			info.cpr_coefs.rb,
367 			info.cpr_coefs.gr,
368 			info.cpr_coefs.gg,
369 			info.cpr_coefs.gb,
370 			info.cpr_coefs.br,
371 			info.cpr_coefs.bg,
372 			info.cpr_coefs.bb);
373 }
374 
375 static ssize_t manager_cpr_coef_store(struct omap_overlay_manager *mgr,
376 		const char *buf, size_t size)
377 {
378 	struct omap_overlay_manager_info info;
379 	struct omap_dss_cpr_coefs coefs;
380 	int r, i;
381 	s16 *arr;
382 
383 	if (!dss_has_feature(FEAT_CPR))
384 		return -ENODEV;
385 
386 	if (sscanf(buf, "%hd %hd %hd %hd %hd %hd %hd %hd %hd",
387 				&coefs.rr, &coefs.rg, &coefs.rb,
388 				&coefs.gr, &coefs.gg, &coefs.gb,
389 				&coefs.br, &coefs.bg, &coefs.bb) != 9)
390 		return -EINVAL;
391 
392 	arr = (s16[]){ coefs.rr, coefs.rg, coefs.rb,
393 		coefs.gr, coefs.gg, coefs.gb,
394 		coefs.br, coefs.bg, coefs.bb };
395 
396 	for (i = 0; i < 9; ++i) {
397 		if (arr[i] < -512 || arr[i] > 511)
398 			return -EINVAL;
399 	}
400 
401 	mgr->get_manager_info(mgr, &info);
402 
403 	info.cpr_coefs = coefs;
404 
405 	r = mgr->set_manager_info(mgr, &info);
406 	if (r)
407 		return r;
408 
409 	r = mgr->apply(mgr);
410 	if (r)
411 		return r;
412 
413 	return size;
414 }
415 
416 struct manager_attribute {
417 	struct attribute attr;
418 	ssize_t (*show)(struct omap_overlay_manager *, char *);
419 	ssize_t	(*store)(struct omap_overlay_manager *, const char *, size_t);
420 };
421 
422 #define MANAGER_ATTR(_name, _mode, _show, _store) \
423 	struct manager_attribute manager_attr_##_name = \
424 	__ATTR(_name, _mode, _show, _store)
425 
426 static MANAGER_ATTR(name, S_IRUGO, manager_name_show, NULL);
427 static MANAGER_ATTR(display, S_IRUGO|S_IWUSR,
428 		manager_display_show, manager_display_store);
429 static MANAGER_ATTR(default_color, S_IRUGO|S_IWUSR,
430 		manager_default_color_show, manager_default_color_store);
431 static MANAGER_ATTR(trans_key_type, S_IRUGO|S_IWUSR,
432 		manager_trans_key_type_show, manager_trans_key_type_store);
433 static MANAGER_ATTR(trans_key_value, S_IRUGO|S_IWUSR,
434 		manager_trans_key_value_show, manager_trans_key_value_store);
435 static MANAGER_ATTR(trans_key_enabled, S_IRUGO|S_IWUSR,
436 		manager_trans_key_enabled_show,
437 		manager_trans_key_enabled_store);
438 static MANAGER_ATTR(alpha_blending_enabled, S_IRUGO|S_IWUSR,
439 		manager_alpha_blending_enabled_show,
440 		manager_alpha_blending_enabled_store);
441 static MANAGER_ATTR(cpr_enable, S_IRUGO|S_IWUSR,
442 		manager_cpr_enable_show,
443 		manager_cpr_enable_store);
444 static MANAGER_ATTR(cpr_coef, S_IRUGO|S_IWUSR,
445 		manager_cpr_coef_show,
446 		manager_cpr_coef_store);
447 
448 
449 static struct attribute *manager_sysfs_attrs[] = {
450 	&manager_attr_name.attr,
451 	&manager_attr_display.attr,
452 	&manager_attr_default_color.attr,
453 	&manager_attr_trans_key_type.attr,
454 	&manager_attr_trans_key_value.attr,
455 	&manager_attr_trans_key_enabled.attr,
456 	&manager_attr_alpha_blending_enabled.attr,
457 	&manager_attr_cpr_enable.attr,
458 	&manager_attr_cpr_coef.attr,
459 	NULL
460 };
461 ATTRIBUTE_GROUPS(manager_sysfs);
462 
463 static ssize_t manager_attr_show(struct kobject *kobj, struct attribute *attr,
464 		char *buf)
465 {
466 	struct omap_overlay_manager *manager;
467 	struct manager_attribute *manager_attr;
468 
469 	manager = container_of(kobj, struct omap_overlay_manager, kobj);
470 	manager_attr = container_of(attr, struct manager_attribute, attr);
471 
472 	if (!manager_attr->show)
473 		return -ENOENT;
474 
475 	return manager_attr->show(manager, buf);
476 }
477 
478 static ssize_t manager_attr_store(struct kobject *kobj, struct attribute *attr,
479 		const char *buf, size_t size)
480 {
481 	struct omap_overlay_manager *manager;
482 	struct manager_attribute *manager_attr;
483 
484 	manager = container_of(kobj, struct omap_overlay_manager, kobj);
485 	manager_attr = container_of(attr, struct manager_attribute, attr);
486 
487 	if (!manager_attr->store)
488 		return -ENOENT;
489 
490 	return manager_attr->store(manager, buf, size);
491 }
492 
493 static const struct sysfs_ops manager_sysfs_ops = {
494 	.show = manager_attr_show,
495 	.store = manager_attr_store,
496 };
497 
498 static struct kobj_type manager_ktype = {
499 	.sysfs_ops = &manager_sysfs_ops,
500 	.default_groups = manager_sysfs_groups,
501 };
502 
503 int dss_manager_kobj_init(struct omap_overlay_manager *mgr,
504 		struct platform_device *pdev)
505 {
506 	return kobject_init_and_add(&mgr->kobj, &manager_ktype,
507 			&pdev->dev.kobj, "manager%d", mgr->id);
508 }
509 
510 void dss_manager_kobj_uninit(struct omap_overlay_manager *mgr)
511 {
512 	kobject_del(&mgr->kobj);
513 	kobject_put(&mgr->kobj);
514 
515 	memset(&mgr->kobj, 0, sizeof(mgr->kobj));
516 }
517