fbsysfs.c

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