2 * fbsysfs.c - framebuffer device class and attributes
4 * Copyright (c) 2004 James Simmons <jsimmons@infradead.org>
6 * This program is free software you can redistribute it and/or
7 * modify it under the terms of the GNU General Public License
8 * as published by the Free Software Foundation; either version
9 * 2 of the License, or (at your option) any later version.
13 * Note: currently there's only stubs for framebuffer_alloc and
14 * framebuffer_release here. The reson for that is that until all drivers
15 * are converted to use it a sysfsification will open OOPSable races.
18 #include <linux/kernel.h>
20 #include <linux/console.h>
21 #include <linux/module.h>
24 * framebuffer_alloc - creates a new frame buffer info structure
26 * @size: size of driver private data, can be zero
27 * @dev: pointer to the device for this fb, this can be NULL
29 * Creates a new frame buffer info structure. Also reserves @size bytes
30 * for driver private data (info->par). info->par (if any) will be
31 * aligned to sizeof(long).
33 * Returns the new structure, or NULL if an error occured.
36 struct fb_info
*framebuffer_alloc(size_t size
, struct device
*dev
)
38 #define BYTES_PER_LONG (BITS_PER_LONG/8)
39 #define PADDING (BYTES_PER_LONG - (sizeof(struct fb_info) % BYTES_PER_LONG))
40 int fb_info_size
= sizeof(struct fb_info
);
45 fb_info_size
+= PADDING
;
47 p
= kzalloc(fb_info_size
+ size
, GFP_KERNEL
);
52 info
= (struct fb_info
*) p
;
55 info
->par
= p
+ fb_info_size
;
59 #ifdef CONFIG_FB_BACKLIGHT
60 mutex_init(&info
->bl_mutex
);
67 EXPORT_SYMBOL(framebuffer_alloc
);
70 * framebuffer_release - marks the structure available for freeing
72 * @info: frame buffer info structure
74 * Drop the reference count of the class_device embedded in the
75 * framebuffer info structure.
78 void framebuffer_release(struct fb_info
*info
)
82 EXPORT_SYMBOL(framebuffer_release
);
84 static int activate(struct fb_info
*fb_info
, struct fb_var_screeninfo
*var
)
88 var
->activate
|= FB_ACTIVATE_FORCE
;
89 acquire_console_sem();
90 fb_info
->flags
|= FBINFO_MISC_USEREVENT
;
91 err
= fb_set_var(fb_info
, var
);
92 fb_info
->flags
&= ~FBINFO_MISC_USEREVENT
;
93 release_console_sem();
99 static int mode_string(char *buf
, unsigned int offset
,
100 const struct fb_videomode
*mode
)
105 if (mode
->flag
& FB_MODE_IS_DETAILED
)
107 if (mode
->flag
& FB_MODE_IS_VESA
)
109 if (mode
->flag
& FB_MODE_IS_STANDARD
)
112 if (mode
->vmode
& FB_VMODE_INTERLACED
)
114 if (mode
->vmode
& FB_VMODE_DOUBLE
)
117 return snprintf(&buf
[offset
], PAGE_SIZE
- offset
, "%c:%dx%d%c-%d\n",
118 m
, mode
->xres
, mode
->yres
, v
, mode
->refresh
);
121 static ssize_t
store_mode(struct class_device
*class_device
, const char * buf
,
124 struct fb_info
*fb_info
= class_get_devdata(class_device
);
126 struct fb_var_screeninfo var
;
127 struct fb_modelist
*modelist
;
128 struct fb_videomode
*mode
;
129 struct list_head
*pos
;
133 memset(&var
, 0, sizeof(var
));
135 list_for_each(pos
, &fb_info
->modelist
) {
136 modelist
= list_entry(pos
, struct fb_modelist
, list
);
137 mode
= &modelist
->mode
;
138 i
= mode_string(mstr
, 0, mode
);
139 if (strncmp(mstr
, buf
, max(count
, i
)) == 0) {
142 fb_videomode_to_var(&var
, mode
);
143 if ((err
= activate(fb_info
, &var
)))
145 fb_info
->mode
= mode
;
152 static ssize_t
show_mode(struct class_device
*class_device
, char *buf
)
154 struct fb_info
*fb_info
= class_get_devdata(class_device
);
159 return mode_string(buf
, 0, fb_info
->mode
);
162 static ssize_t
store_modes(struct class_device
*class_device
, const char * buf
,
165 struct fb_info
*fb_info
= class_get_devdata(class_device
);
167 int i
= count
/ sizeof(struct fb_videomode
);
169 if (i
* sizeof(struct fb_videomode
) != count
)
172 acquire_console_sem();
173 list_splice(&fb_info
->modelist
, &old_list
);
174 fb_videomode_to_modelist((struct fb_videomode
*)buf
, i
,
176 if (fb_new_modelist(fb_info
)) {
177 fb_destroy_modelist(&fb_info
->modelist
);
178 list_splice(&old_list
, &fb_info
->modelist
);
180 fb_destroy_modelist(&old_list
);
182 release_console_sem();
187 static ssize_t
show_modes(struct class_device
*class_device
, char *buf
)
189 struct fb_info
*fb_info
= class_get_devdata(class_device
);
191 struct list_head
*pos
;
192 struct fb_modelist
*modelist
;
193 const struct fb_videomode
*mode
;
196 list_for_each(pos
, &fb_info
->modelist
) {
197 modelist
= list_entry(pos
, struct fb_modelist
, list
);
198 mode
= &modelist
->mode
;
199 i
+= mode_string(buf
, i
, mode
);
204 static ssize_t
store_bpp(struct class_device
*class_device
, const char * buf
,
207 struct fb_info
*fb_info
= class_get_devdata(class_device
);
208 struct fb_var_screeninfo var
;
213 var
.bits_per_pixel
= simple_strtoul(buf
, last
, 0);
214 if ((err
= activate(fb_info
, &var
)))
219 static ssize_t
show_bpp(struct class_device
*class_device
, char *buf
)
221 struct fb_info
*fb_info
= class_get_devdata(class_device
);
222 return snprintf(buf
, PAGE_SIZE
, "%d\n", fb_info
->var
.bits_per_pixel
);
225 static ssize_t
store_rotate(struct class_device
*class_device
, const char *buf
,
228 struct fb_info
*fb_info
= class_get_devdata(class_device
);
229 struct fb_var_screeninfo var
;
234 var
.rotate
= simple_strtoul(buf
, last
, 0);
236 if ((err
= activate(fb_info
, &var
)))
243 static ssize_t
show_rotate(struct class_device
*class_device
, char *buf
)
245 struct fb_info
*fb_info
= class_get_devdata(class_device
);
247 return snprintf(buf
, PAGE_SIZE
, "%d\n", fb_info
->var
.rotate
);
250 static ssize_t
store_virtual(struct class_device
*class_device
,
251 const char * buf
, size_t count
)
253 struct fb_info
*fb_info
= class_get_devdata(class_device
);
254 struct fb_var_screeninfo var
;
259 var
.xres_virtual
= simple_strtoul(buf
, &last
, 0);
261 if (last
- buf
>= count
)
263 var
.yres_virtual
= simple_strtoul(last
, &last
, 0);
265 if ((err
= activate(fb_info
, &var
)))
270 static ssize_t
show_virtual(struct class_device
*class_device
, char *buf
)
272 struct fb_info
*fb_info
= class_get_devdata(class_device
);
273 return snprintf(buf
, PAGE_SIZE
, "%d,%d\n", fb_info
->var
.xres_virtual
,
274 fb_info
->var
.yres_virtual
);
277 static ssize_t
show_stride(struct class_device
*class_device
, char *buf
)
279 struct fb_info
*fb_info
= class_get_devdata(class_device
);
280 return snprintf(buf
, PAGE_SIZE
, "%d\n", fb_info
->fix
.line_length
);
283 static ssize_t
store_blank(struct class_device
*class_device
, const char * buf
,
286 struct fb_info
*fb_info
= class_get_devdata(class_device
);
290 acquire_console_sem();
291 fb_info
->flags
|= FBINFO_MISC_USEREVENT
;
292 err
= fb_blank(fb_info
, simple_strtoul(buf
, &last
, 0));
293 fb_info
->flags
&= ~FBINFO_MISC_USEREVENT
;
294 release_console_sem();
300 static ssize_t
show_blank(struct class_device
*class_device
, char *buf
)
302 // struct fb_info *fb_info = class_get_devdata(class_device);
306 static ssize_t
store_console(struct class_device
*class_device
,
307 const char * buf
, size_t count
)
309 // struct fb_info *fb_info = class_get_devdata(class_device);
313 static ssize_t
show_console(struct class_device
*class_device
, char *buf
)
315 // struct fb_info *fb_info = class_get_devdata(class_device);
319 static ssize_t
store_cursor(struct class_device
*class_device
,
320 const char * buf
, size_t count
)
322 // struct fb_info *fb_info = class_get_devdata(class_device);
326 static ssize_t
show_cursor(struct class_device
*class_device
, char *buf
)
328 // struct fb_info *fb_info = class_get_devdata(class_device);
332 static ssize_t
store_pan(struct class_device
*class_device
, const char * buf
,
335 struct fb_info
*fb_info
= class_get_devdata(class_device
);
336 struct fb_var_screeninfo var
;
341 var
.xoffset
= simple_strtoul(buf
, &last
, 0);
343 if (last
- buf
>= count
)
345 var
.yoffset
= simple_strtoul(last
, &last
, 0);
347 acquire_console_sem();
348 err
= fb_pan_display(fb_info
, &var
);
349 release_console_sem();
356 static ssize_t
show_pan(struct class_device
*class_device
, char *buf
)
358 struct fb_info
*fb_info
= class_get_devdata(class_device
);
359 return snprintf(buf
, PAGE_SIZE
, "%d,%d\n", fb_info
->var
.xoffset
,
360 fb_info
->var
.xoffset
);
363 static ssize_t
show_name(struct class_device
*class_device
, char *buf
)
365 struct fb_info
*fb_info
= class_get_devdata(class_device
);
367 return snprintf(buf
, PAGE_SIZE
, "%s\n", fb_info
->fix
.id
);
370 static ssize_t
store_fbstate(struct class_device
*class_device
,
371 const char *buf
, size_t count
)
373 struct fb_info
*fb_info
= class_get_devdata(class_device
);
377 state
= simple_strtoul(buf
, &last
, 0);
379 acquire_console_sem();
380 fb_set_suspend(fb_info
, (int)state
);
381 release_console_sem();
386 static ssize_t
show_fbstate(struct class_device
*class_device
, char *buf
)
388 struct fb_info
*fb_info
= class_get_devdata(class_device
);
389 return snprintf(buf
, PAGE_SIZE
, "%d\n", fb_info
->state
);
392 #ifdef CONFIG_FB_BACKLIGHT
393 static ssize_t
store_bl_curve(struct class_device
*class_device
,
394 const char *buf
, size_t count
)
396 struct fb_info
*fb_info
= class_get_devdata(class_device
);
397 u8 tmp_curve
[FB_BACKLIGHT_LEVELS
];
400 if (count
!= (FB_BACKLIGHT_LEVELS
/ 8 * 24))
403 for (i
= 0; i
< (FB_BACKLIGHT_LEVELS
/ 8); ++i
)
404 if (sscanf(&buf
[i
* 24],
405 "%2hhx %2hhx %2hhx %2hhx %2hhx %2hhx %2hhx %2hhx\n",
406 &tmp_curve
[i
* 8 + 0],
407 &tmp_curve
[i
* 8 + 1],
408 &tmp_curve
[i
* 8 + 2],
409 &tmp_curve
[i
* 8 + 3],
410 &tmp_curve
[i
* 8 + 4],
411 &tmp_curve
[i
* 8 + 5],
412 &tmp_curve
[i
* 8 + 6],
413 &tmp_curve
[i
* 8 + 7]) != 8)
416 /* If there has been an error in the input data, we won't
419 mutex_lock(&fb_info
->bl_mutex
);
420 for (i
= 0; i
< FB_BACKLIGHT_LEVELS
; ++i
)
421 fb_info
->bl_curve
[i
] = tmp_curve
[i
];
422 mutex_unlock(&fb_info
->bl_mutex
);
427 static ssize_t
show_bl_curve(struct class_device
*class_device
, char *buf
)
429 struct fb_info
*fb_info
= class_get_devdata(class_device
);
433 mutex_lock(&fb_info
->bl_mutex
);
434 for (i
= 0; i
< FB_BACKLIGHT_LEVELS
; i
+= 8)
435 len
+= snprintf(&buf
[len
], PAGE_SIZE
,
436 "%02x %02x %02x %02x %02x %02x %02x %02x\n",
437 fb_info
->bl_curve
[i
+ 0],
438 fb_info
->bl_curve
[i
+ 1],
439 fb_info
->bl_curve
[i
+ 2],
440 fb_info
->bl_curve
[i
+ 3],
441 fb_info
->bl_curve
[i
+ 4],
442 fb_info
->bl_curve
[i
+ 5],
443 fb_info
->bl_curve
[i
+ 6],
444 fb_info
->bl_curve
[i
+ 7]);
445 mutex_unlock(&fb_info
->bl_mutex
);
451 /* When cmap is added back in it should be a binary attribute
452 * not a text one. Consideration should also be given to converting
453 * fbdev to use configfs instead of sysfs */
454 static struct class_device_attribute class_device_attrs
[] = {
455 __ATTR(bits_per_pixel
, S_IRUGO
|S_IWUSR
, show_bpp
, store_bpp
),
456 __ATTR(blank
, S_IRUGO
|S_IWUSR
, show_blank
, store_blank
),
457 __ATTR(console
, S_IRUGO
|S_IWUSR
, show_console
, store_console
),
458 __ATTR(cursor
, S_IRUGO
|S_IWUSR
, show_cursor
, store_cursor
),
459 __ATTR(mode
, S_IRUGO
|S_IWUSR
, show_mode
, store_mode
),
460 __ATTR(modes
, S_IRUGO
|S_IWUSR
, show_modes
, store_modes
),
461 __ATTR(pan
, S_IRUGO
|S_IWUSR
, show_pan
, store_pan
),
462 __ATTR(virtual_size
, S_IRUGO
|S_IWUSR
, show_virtual
, store_virtual
),
463 __ATTR(name
, S_IRUGO
, show_name
, NULL
),
464 __ATTR(stride
, S_IRUGO
, show_stride
, NULL
),
465 __ATTR(rotate
, S_IRUGO
|S_IWUSR
, show_rotate
, store_rotate
),
466 __ATTR(state
, S_IRUGO
|S_IWUSR
, show_fbstate
, store_fbstate
),
467 #ifdef CONFIG_FB_BACKLIGHT
468 __ATTR(bl_curve
, S_IRUGO
|S_IWUSR
, show_bl_curve
, store_bl_curve
),
472 int fb_init_class_device(struct fb_info
*fb_info
)
475 class_set_devdata(fb_info
->class_device
, fb_info
);
477 for (i
= 0; i
< ARRAY_SIZE(class_device_attrs
); i
++)
478 class_device_create_file(fb_info
->class_device
,
479 &class_device_attrs
[i
]);
483 void fb_cleanup_class_device(struct fb_info
*fb_info
)
487 for (i
= 0; i
< ARRAY_SIZE(class_device_attrs
); i
++)
488 class_device_remove_file(fb_info
->class_device
,
489 &class_device_attrs
[i
]);
492 #ifdef CONFIG_FB_BACKLIGHT
493 /* This function generates a linear backlight curve
497 * 8-127: linear from min to max
499 void fb_bl_default_curve(struct fb_info
*fb_info
, u8 off
, u8 min
, u8 max
)
501 unsigned int i
, flat
, count
, range
= (max
- min
);
503 fb_info
->bl_curve
[0] = off
;
505 for (flat
= 1; flat
< (FB_BACKLIGHT_LEVELS
/ 16); ++flat
)
506 fb_info
->bl_curve
[flat
] = min
;
508 count
= FB_BACKLIGHT_LEVELS
* 15 / 16;
509 for (i
= 0; i
< count
; ++i
)
510 fb_info
->bl_curve
[flat
+ i
] = min
+ (range
* (i
+ 1) / count
);
512 EXPORT_SYMBOL_GPL(fb_bl_default_curve
);