xref: /linux/drivers/video/fbdev/core/fbsysfs.c (revision a1c613ae4c322ddd58d5a8539dbfba2a0380a8c0)
1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /*
3  * fbsysfs.c - framebuffer device class and attributes
4  *
5  * Copyright (c) 2004 James Simmons <jsimmons@infradead.org>
6  */
7 
8 #include <linux/console.h>
9 #include <linux/fb.h>
10 #include <linux/fbcon.h>
11 #include <linux/major.h>
12 
13 #include "fb_internal.h"
14 
15 #define FB_SYSFS_FLAG_ATTR 1
16 
activate(struct fb_info * fb_info,struct fb_var_screeninfo * var)17 static int activate(struct fb_info *fb_info, struct fb_var_screeninfo *var)
18 {
19 	int err;
20 
21 	var->activate |= FB_ACTIVATE_FORCE;
22 	console_lock();
23 	lock_fb_info(fb_info);
24 	err = fb_set_var(fb_info, var);
25 	if (!err)
26 		fbcon_update_vcs(fb_info, var->activate & FB_ACTIVATE_ALL);
27 	unlock_fb_info(fb_info);
28 	console_unlock();
29 	if (err)
30 		return err;
31 	return 0;
32 }
33 
mode_string(char * buf,unsigned int offset,const struct fb_videomode * mode)34 static int mode_string(char *buf, unsigned int offset,
35 		       const struct fb_videomode *mode)
36 {
37 	char m = 'U';
38 	char v = 'p';
39 
40 	if (mode->flag & FB_MODE_IS_DETAILED)
41 		m = 'D';
42 	if (mode->flag & FB_MODE_IS_VESA)
43 		m = 'V';
44 	if (mode->flag & FB_MODE_IS_STANDARD)
45 		m = 'S';
46 
47 	if (mode->vmode & FB_VMODE_INTERLACED)
48 		v = 'i';
49 	if (mode->vmode & FB_VMODE_DOUBLE)
50 		v = 'd';
51 
52 	return snprintf(&buf[offset], PAGE_SIZE - offset, "%c:%dx%d%c-%d\n",
53 	                m, mode->xres, mode->yres, v, mode->refresh);
54 }
55 
store_mode(struct device * device,struct device_attribute * attr,const char * buf,size_t count)56 static ssize_t store_mode(struct device *device, struct device_attribute *attr,
57 			  const char *buf, size_t count)
58 {
59 	struct fb_info *fb_info = dev_get_drvdata(device);
60 	char mstr[100];
61 	struct fb_var_screeninfo var;
62 	struct fb_modelist *modelist;
63 	struct fb_videomode *mode;
64 	size_t i;
65 	int err;
66 
67 	memset(&var, 0, sizeof(var));
68 
69 	list_for_each_entry(modelist, &fb_info->modelist, list) {
70 		mode = &modelist->mode;
71 		i = mode_string(mstr, 0, mode);
72 		if (strncmp(mstr, buf, max(count, i)) == 0) {
73 
74 			var = fb_info->var;
75 			fb_videomode_to_var(&var, mode);
76 			if ((err = activate(fb_info, &var)))
77 				return err;
78 			fb_info->mode = mode;
79 			return count;
80 		}
81 	}
82 	return -EINVAL;
83 }
84 
show_mode(struct device * device,struct device_attribute * attr,char * buf)85 static ssize_t show_mode(struct device *device, struct device_attribute *attr,
86 			 char *buf)
87 {
88 	struct fb_info *fb_info = dev_get_drvdata(device);
89 
90 	if (!fb_info->mode)
91 		return 0;
92 
93 	return mode_string(buf, 0, fb_info->mode);
94 }
95 
store_modes(struct device * device,struct device_attribute * attr,const char * buf,size_t count)96 static ssize_t store_modes(struct device *device,
97 			   struct device_attribute *attr,
98 			   const char *buf, size_t count)
99 {
100 	struct fb_info *fb_info = dev_get_drvdata(device);
101 	LIST_HEAD(old_list);
102 	int i = count / sizeof(struct fb_videomode);
103 
104 	if (i * sizeof(struct fb_videomode) != count)
105 		return -EINVAL;
106 
107 	console_lock();
108 	lock_fb_info(fb_info);
109 
110 	list_splice(&fb_info->modelist, &old_list);
111 	fb_videomode_to_modelist((const struct fb_videomode *)buf, i,
112 				 &fb_info->modelist);
113 	if (fb_new_modelist(fb_info)) {
114 		fb_destroy_modelist(&fb_info->modelist);
115 		list_splice(&old_list, &fb_info->modelist);
116 	} else
117 		fb_destroy_modelist(&old_list);
118 
119 	unlock_fb_info(fb_info);
120 	console_unlock();
121 
122 	return 0;
123 }
124 
show_modes(struct device * device,struct device_attribute * attr,char * buf)125 static ssize_t show_modes(struct device *device, struct device_attribute *attr,
126 			  char *buf)
127 {
128 	struct fb_info *fb_info = dev_get_drvdata(device);
129 	unsigned int i;
130 	struct fb_modelist *modelist;
131 	const struct fb_videomode *mode;
132 
133 	i = 0;
134 	list_for_each_entry(modelist, &fb_info->modelist, list) {
135 		mode = &modelist->mode;
136 		i += mode_string(buf, i, mode);
137 	}
138 	return i;
139 }
140 
store_bpp(struct device * device,struct device_attribute * attr,const char * buf,size_t count)141 static ssize_t store_bpp(struct device *device, struct device_attribute *attr,
142 			 const char *buf, size_t count)
143 {
144 	struct fb_info *fb_info = dev_get_drvdata(device);
145 	struct fb_var_screeninfo var;
146 	char ** last = NULL;
147 	int err;
148 
149 	var = fb_info->var;
150 	var.bits_per_pixel = simple_strtoul(buf, last, 0);
151 	if ((err = activate(fb_info, &var)))
152 		return err;
153 	return count;
154 }
155 
show_bpp(struct device * device,struct device_attribute * attr,char * buf)156 static ssize_t show_bpp(struct device *device, struct device_attribute *attr,
157 			char *buf)
158 {
159 	struct fb_info *fb_info = dev_get_drvdata(device);
160 	return sysfs_emit(buf, "%d\n", fb_info->var.bits_per_pixel);
161 }
162 
store_rotate(struct device * device,struct device_attribute * attr,const char * buf,size_t count)163 static ssize_t store_rotate(struct device *device,
164 			    struct device_attribute *attr,
165 			    const char *buf, size_t count)
166 {
167 	struct fb_info *fb_info = dev_get_drvdata(device);
168 	struct fb_var_screeninfo var;
169 	char **last = NULL;
170 	int err;
171 
172 	var = fb_info->var;
173 	var.rotate = simple_strtoul(buf, last, 0);
174 
175 	if ((err = activate(fb_info, &var)))
176 		return err;
177 
178 	return count;
179 }
180 
181 
show_rotate(struct device * device,struct device_attribute * attr,char * buf)182 static ssize_t show_rotate(struct device *device,
183 			   struct device_attribute *attr, char *buf)
184 {
185 	struct fb_info *fb_info = dev_get_drvdata(device);
186 
187 	return sysfs_emit(buf, "%d\n", fb_info->var.rotate);
188 }
189 
store_virtual(struct device * device,struct device_attribute * attr,const char * buf,size_t count)190 static ssize_t store_virtual(struct device *device,
191 			     struct device_attribute *attr,
192 			     const char *buf, size_t count)
193 {
194 	struct fb_info *fb_info = dev_get_drvdata(device);
195 	struct fb_var_screeninfo var;
196 	char *last = NULL;
197 	int err;
198 
199 	var = fb_info->var;
200 	var.xres_virtual = simple_strtoul(buf, &last, 0);
201 	last++;
202 	if (last - buf >= count)
203 		return -EINVAL;
204 	var.yres_virtual = simple_strtoul(last, &last, 0);
205 
206 	if ((err = activate(fb_info, &var)))
207 		return err;
208 	return count;
209 }
210 
show_virtual(struct device * device,struct device_attribute * attr,char * buf)211 static ssize_t show_virtual(struct device *device,
212 			    struct device_attribute *attr, char *buf)
213 {
214 	struct fb_info *fb_info = dev_get_drvdata(device);
215 	return sysfs_emit(buf, "%d,%d\n", fb_info->var.xres_virtual,
216 			fb_info->var.yres_virtual);
217 }
218 
show_stride(struct device * device,struct device_attribute * attr,char * buf)219 static ssize_t show_stride(struct device *device,
220 			   struct device_attribute *attr, char *buf)
221 {
222 	struct fb_info *fb_info = dev_get_drvdata(device);
223 	return sysfs_emit(buf, "%d\n", fb_info->fix.line_length);
224 }
225 
store_blank(struct device * device,struct device_attribute * attr,const char * buf,size_t count)226 static ssize_t store_blank(struct device *device,
227 			   struct device_attribute *attr,
228 			   const char *buf, size_t count)
229 {
230 	struct fb_info *fb_info = dev_get_drvdata(device);
231 	char *last = NULL;
232 	int err, arg;
233 
234 	arg = simple_strtoul(buf, &last, 0);
235 	console_lock();
236 	err = fb_blank(fb_info, arg);
237 	/* might again call into fb_blank */
238 	fbcon_fb_blanked(fb_info, arg);
239 	console_unlock();
240 	if (err < 0)
241 		return err;
242 	return count;
243 }
244 
show_blank(struct device * device,struct device_attribute * attr,char * buf)245 static ssize_t show_blank(struct device *device,
246 			  struct device_attribute *attr, char *buf)
247 {
248 //	struct fb_info *fb_info = dev_get_drvdata(device);
249 	return 0;
250 }
251 
store_console(struct device * device,struct device_attribute * attr,const char * buf,size_t count)252 static ssize_t store_console(struct device *device,
253 			     struct device_attribute *attr,
254 			     const char *buf, size_t count)
255 {
256 //	struct fb_info *fb_info = dev_get_drvdata(device);
257 	return 0;
258 }
259 
show_console(struct device * device,struct device_attribute * attr,char * buf)260 static ssize_t show_console(struct device *device,
261 			    struct device_attribute *attr, char *buf)
262 {
263 //	struct fb_info *fb_info = dev_get_drvdata(device);
264 	return 0;
265 }
266 
store_cursor(struct device * device,struct device_attribute * attr,const char * buf,size_t count)267 static ssize_t store_cursor(struct device *device,
268 			    struct device_attribute *attr,
269 			    const char *buf, size_t count)
270 {
271 //	struct fb_info *fb_info = dev_get_drvdata(device);
272 	return 0;
273 }
274 
show_cursor(struct device * device,struct device_attribute * attr,char * buf)275 static ssize_t show_cursor(struct device *device,
276 			   struct device_attribute *attr, char *buf)
277 {
278 //	struct fb_info *fb_info = dev_get_drvdata(device);
279 	return 0;
280 }
281 
store_pan(struct device * device,struct device_attribute * attr,const char * buf,size_t count)282 static ssize_t store_pan(struct device *device,
283 			 struct device_attribute *attr,
284 			 const char *buf, size_t count)
285 {
286 	struct fb_info *fb_info = dev_get_drvdata(device);
287 	struct fb_var_screeninfo var;
288 	char *last = NULL;
289 	int err;
290 
291 	var = fb_info->var;
292 	var.xoffset = simple_strtoul(buf, &last, 0);
293 	last++;
294 	if (last - buf >= count)
295 		return -EINVAL;
296 	var.yoffset = simple_strtoul(last, &last, 0);
297 
298 	console_lock();
299 	err = fb_pan_display(fb_info, &var);
300 	console_unlock();
301 
302 	if (err < 0)
303 		return err;
304 	return count;
305 }
306 
show_pan(struct device * device,struct device_attribute * attr,char * buf)307 static ssize_t show_pan(struct device *device,
308 			struct device_attribute *attr, char *buf)
309 {
310 	struct fb_info *fb_info = dev_get_drvdata(device);
311 	return sysfs_emit(buf, "%d,%d\n", fb_info->var.xoffset,
312 			fb_info->var.yoffset);
313 }
314 
show_name(struct device * device,struct device_attribute * attr,char * buf)315 static ssize_t show_name(struct device *device,
316 			 struct device_attribute *attr, char *buf)
317 {
318 	struct fb_info *fb_info = dev_get_drvdata(device);
319 
320 	return sysfs_emit(buf, "%s\n", fb_info->fix.id);
321 }
322 
store_fbstate(struct device * device,struct device_attribute * attr,const char * buf,size_t count)323 static ssize_t store_fbstate(struct device *device,
324 			     struct device_attribute *attr,
325 			     const char *buf, size_t count)
326 {
327 	struct fb_info *fb_info = dev_get_drvdata(device);
328 	u32 state;
329 	char *last = NULL;
330 
331 	state = simple_strtoul(buf, &last, 0);
332 
333 	console_lock();
334 	lock_fb_info(fb_info);
335 
336 	fb_set_suspend(fb_info, (int)state);
337 
338 	unlock_fb_info(fb_info);
339 	console_unlock();
340 
341 	return count;
342 }
343 
show_fbstate(struct device * device,struct device_attribute * attr,char * buf)344 static ssize_t show_fbstate(struct device *device,
345 			    struct device_attribute *attr, char *buf)
346 {
347 	struct fb_info *fb_info = dev_get_drvdata(device);
348 	return sysfs_emit(buf, "%d\n", fb_info->state);
349 }
350 
351 #if IS_ENABLED(CONFIG_FB_BACKLIGHT)
store_bl_curve(struct device * device,struct device_attribute * attr,const char * buf,size_t count)352 static ssize_t store_bl_curve(struct device *device,
353 			      struct device_attribute *attr,
354 			      const char *buf, size_t count)
355 {
356 	struct fb_info *fb_info = dev_get_drvdata(device);
357 	u8 tmp_curve[FB_BACKLIGHT_LEVELS];
358 	unsigned int i;
359 
360 	/* Some drivers don't use framebuffer_alloc(), but those also
361 	 * don't have backlights.
362 	 */
363 	if (!fb_info || !fb_info->bl_dev)
364 		return -ENODEV;
365 
366 	if (count != (FB_BACKLIGHT_LEVELS / 8 * 24))
367 		return -EINVAL;
368 
369 	for (i = 0; i < (FB_BACKLIGHT_LEVELS / 8); ++i)
370 		if (sscanf(&buf[i * 24],
371 			"%2hhx %2hhx %2hhx %2hhx %2hhx %2hhx %2hhx %2hhx\n",
372 			&tmp_curve[i * 8 + 0],
373 			&tmp_curve[i * 8 + 1],
374 			&tmp_curve[i * 8 + 2],
375 			&tmp_curve[i * 8 + 3],
376 			&tmp_curve[i * 8 + 4],
377 			&tmp_curve[i * 8 + 5],
378 			&tmp_curve[i * 8 + 6],
379 			&tmp_curve[i * 8 + 7]) != 8)
380 			return -EINVAL;
381 
382 	/* If there has been an error in the input data, we won't
383 	 * reach this loop.
384 	 */
385 	mutex_lock(&fb_info->bl_curve_mutex);
386 	for (i = 0; i < FB_BACKLIGHT_LEVELS; ++i)
387 		fb_info->bl_curve[i] = tmp_curve[i];
388 	mutex_unlock(&fb_info->bl_curve_mutex);
389 
390 	return count;
391 }
392 
show_bl_curve(struct device * device,struct device_attribute * attr,char * buf)393 static ssize_t show_bl_curve(struct device *device,
394 			     struct device_attribute *attr, char *buf)
395 {
396 	struct fb_info *fb_info = dev_get_drvdata(device);
397 	ssize_t len = 0;
398 	unsigned int i;
399 
400 	/* Some drivers don't use framebuffer_alloc(), but those also
401 	 * don't have backlights.
402 	 */
403 	if (!fb_info || !fb_info->bl_dev)
404 		return -ENODEV;
405 
406 	mutex_lock(&fb_info->bl_curve_mutex);
407 	for (i = 0; i < FB_BACKLIGHT_LEVELS; i += 8)
408 		len += scnprintf(&buf[len], PAGE_SIZE - len, "%8ph\n",
409 				fb_info->bl_curve + i);
410 	mutex_unlock(&fb_info->bl_curve_mutex);
411 
412 	return len;
413 }
414 #endif
415 
416 /* When cmap is added back in it should be a binary attribute
417  * not a text one. Consideration should also be given to converting
418  * fbdev to use configfs instead of sysfs */
419 static struct device_attribute device_attrs[] = {
420 	__ATTR(bits_per_pixel, S_IRUGO|S_IWUSR, show_bpp, store_bpp),
421 	__ATTR(blank, S_IRUGO|S_IWUSR, show_blank, store_blank),
422 	__ATTR(console, S_IRUGO|S_IWUSR, show_console, store_console),
423 	__ATTR(cursor, S_IRUGO|S_IWUSR, show_cursor, store_cursor),
424 	__ATTR(mode, S_IRUGO|S_IWUSR, show_mode, store_mode),
425 	__ATTR(modes, S_IRUGO|S_IWUSR, show_modes, store_modes),
426 	__ATTR(pan, S_IRUGO|S_IWUSR, show_pan, store_pan),
427 	__ATTR(virtual_size, S_IRUGO|S_IWUSR, show_virtual, store_virtual),
428 	__ATTR(name, S_IRUGO, show_name, NULL),
429 	__ATTR(stride, S_IRUGO, show_stride, NULL),
430 	__ATTR(rotate, S_IRUGO|S_IWUSR, show_rotate, store_rotate),
431 	__ATTR(state, S_IRUGO|S_IWUSR, show_fbstate, store_fbstate),
432 #if IS_ENABLED(CONFIG_FB_BACKLIGHT)
433 	__ATTR(bl_curve, S_IRUGO|S_IWUSR, show_bl_curve, store_bl_curve),
434 #endif
435 };
436 
fb_init_device(struct fb_info * fb_info)437 static int fb_init_device(struct fb_info *fb_info)
438 {
439 	int i, error = 0;
440 
441 	dev_set_drvdata(fb_info->dev, fb_info);
442 
443 	fb_info->class_flag |= FB_SYSFS_FLAG_ATTR;
444 
445 	for (i = 0; i < ARRAY_SIZE(device_attrs); i++) {
446 		error = device_create_file(fb_info->dev, &device_attrs[i]);
447 
448 		if (error)
449 			break;
450 	}
451 
452 	if (error) {
453 		while (--i >= 0)
454 			device_remove_file(fb_info->dev, &device_attrs[i]);
455 		fb_info->class_flag &= ~FB_SYSFS_FLAG_ATTR;
456 	}
457 
458 	return 0;
459 }
460 
fb_cleanup_device(struct fb_info * fb_info)461 static void fb_cleanup_device(struct fb_info *fb_info)
462 {
463 	unsigned int i;
464 
465 	if (fb_info->class_flag & FB_SYSFS_FLAG_ATTR) {
466 		for (i = 0; i < ARRAY_SIZE(device_attrs); i++)
467 			device_remove_file(fb_info->dev, &device_attrs[i]);
468 
469 		fb_info->class_flag &= ~FB_SYSFS_FLAG_ATTR;
470 	}
471 }
472 
fb_device_create(struct fb_info * fb_info)473 int fb_device_create(struct fb_info *fb_info)
474 {
475 	int node = fb_info->node;
476 	dev_t devt = MKDEV(FB_MAJOR, node);
477 	int ret;
478 
479 	fb_info->dev = device_create(fb_class, fb_info->device, devt, NULL, "fb%d", node);
480 	if (IS_ERR(fb_info->dev)) {
481 		/* Not fatal */
482 		ret = PTR_ERR(fb_info->dev);
483 		pr_warn("Unable to create device for framebuffer %d; error %d\n", node, ret);
484 		fb_info->dev = NULL;
485 	} else {
486 		fb_init_device(fb_info);
487 	}
488 
489 	return 0;
490 }
491 
fb_device_destroy(struct fb_info * fb_info)492 void fb_device_destroy(struct fb_info *fb_info)
493 {
494 	dev_t devt = MKDEV(FB_MAJOR, fb_info->node);
495 
496 	if (!fb_info->dev)
497 		return;
498 
499 	fb_cleanup_device(fb_info);
500 	device_destroy(fb_class, devt);
501 	fb_info->dev = NULL;
502 }
503