blob: 67afa9c2289d539e281bb831aa2260c0fba1205b [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * fbsysfs.c - framebuffer device class and attributes
3 *
4 * Copyright (c) 2004 James Simmons <jsimmons@infradead.org>
5 *
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.
10 */
11
12/*
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.
16 */
17
18#include <linux/kernel.h>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090019#include <linux/slab.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070020#include <linux/fb.h>
21#include <linux/console.h>
Michael Hanselmann5474c122006-06-25 05:47:08 -070022#include <linux/module.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070023
Antonino A. Daplas1a6600b2006-10-03 01:14:50 -070024#define FB_SYSFS_FLAG_ATTR 1
25
Linus Torvalds1da177e2005-04-16 15:20:36 -070026/**
27 * framebuffer_alloc - creates a new frame buffer info structure
28 *
29 * @size: size of driver private data, can be zero
30 * @dev: pointer to the device for this fb, this can be NULL
31 *
32 * Creates a new frame buffer info structure. Also reserves @size bytes
33 * for driver private data (info->par). info->par (if any) will be
34 * aligned to sizeof(long).
35 *
Lucas De Marchi25985ed2011-03-30 22:57:33 -030036 * Returns the new structure, or NULL if an error occurred.
Linus Torvalds1da177e2005-04-16 15:20:36 -070037 *
38 */
39struct fb_info *framebuffer_alloc(size_t size, struct device *dev)
40{
41#define BYTES_PER_LONG (BITS_PER_LONG/8)
42#define PADDING (BYTES_PER_LONG - (sizeof(struct fb_info) % BYTES_PER_LONG))
43 int fb_info_size = sizeof(struct fb_info);
44 struct fb_info *info;
45 char *p;
46
47 if (size)
48 fb_info_size += PADDING;
49
Antonino A. Daplasdef1ede2006-01-09 20:53:45 -080050 p = kzalloc(fb_info_size + size, GFP_KERNEL);
51
Linus Torvalds1da177e2005-04-16 15:20:36 -070052 if (!p)
53 return NULL;
Antonino A. Daplasdef1ede2006-01-09 20:53:45 -080054
Linus Torvalds1da177e2005-04-16 15:20:36 -070055 info = (struct fb_info *) p;
56
57 if (size)
58 info->par = p + fb_info_size;
59
60 info->device = dev;
61
Michael Hanselmann5474c122006-06-25 05:47:08 -070062#ifdef CONFIG_FB_BACKLIGHT
Richard Purdie37ce69a2007-02-10 14:10:33 +000063 mutex_init(&info->bl_curve_mutex);
Michael Hanselmann5474c122006-06-25 05:47:08 -070064#endif
65
Linus Torvalds1da177e2005-04-16 15:20:36 -070066 return info;
67#undef PADDING
68#undef BYTES_PER_LONG
69}
70EXPORT_SYMBOL(framebuffer_alloc);
71
72/**
73 * framebuffer_release - marks the structure available for freeing
74 *
75 * @info: frame buffer info structure
76 *
Greg Kroah-Hartman78cde082006-09-14 07:30:59 -070077 * Drop the reference count of the device embedded in the
Linus Torvalds1da177e2005-04-16 15:20:36 -070078 * framebuffer info structure.
79 *
80 */
81void framebuffer_release(struct fb_info *info)
82{
Marcin Slusarz1471ca92010-05-16 17:27:03 +020083 kfree(info->apertures);
Linus Torvalds1da177e2005-04-16 15:20:36 -070084 kfree(info);
85}
86EXPORT_SYMBOL(framebuffer_release);
87
88static int activate(struct fb_info *fb_info, struct fb_var_screeninfo *var)
89{
90 int err;
91
92 var->activate |= FB_ACTIVATE_FORCE;
Torben Hohnac751ef2011-01-25 15:07:35 -080093 console_lock();
Linus Torvalds1da177e2005-04-16 15:20:36 -070094 fb_info->flags |= FBINFO_MISC_USEREVENT;
95 err = fb_set_var(fb_info, var);
96 fb_info->flags &= ~FBINFO_MISC_USEREVENT;
Torben Hohnac751ef2011-01-25 15:07:35 -080097 console_unlock();
Linus Torvalds1da177e2005-04-16 15:20:36 -070098 if (err)
99 return err;
100 return 0;
101}
102
103static int mode_string(char *buf, unsigned int offset,
104 const struct fb_videomode *mode)
105{
106 char m = 'U';
Daniel R Thompson9dac73a2006-06-26 00:27:00 -0700107 char v = 'p';
108
Linus Torvalds1da177e2005-04-16 15:20:36 -0700109 if (mode->flag & FB_MODE_IS_DETAILED)
110 m = 'D';
111 if (mode->flag & FB_MODE_IS_VESA)
112 m = 'V';
113 if (mode->flag & FB_MODE_IS_STANDARD)
114 m = 'S';
Daniel R Thompson9dac73a2006-06-26 00:27:00 -0700115
116 if (mode->vmode & FB_VMODE_INTERLACED)
117 v = 'i';
118 if (mode->vmode & FB_VMODE_DOUBLE)
119 v = 'd';
120
121 return snprintf(&buf[offset], PAGE_SIZE - offset, "%c:%dx%d%c-%d\n",
122 m, mode->xres, mode->yres, v, mode->refresh);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700123}
124
Greg Kroah-Hartman78cde082006-09-14 07:30:59 -0700125static ssize_t store_mode(struct device *device, struct device_attribute *attr,
126 const char *buf, size_t count)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700127{
Greg Kroah-Hartman78cde082006-09-14 07:30:59 -0700128 struct fb_info *fb_info = dev_get_drvdata(device);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700129 char mstr[100];
130 struct fb_var_screeninfo var;
131 struct fb_modelist *modelist;
132 struct fb_videomode *mode;
133 struct list_head *pos;
134 size_t i;
135 int err;
136
137 memset(&var, 0, sizeof(var));
138
139 list_for_each(pos, &fb_info->modelist) {
140 modelist = list_entry(pos, struct fb_modelist, list);
141 mode = &modelist->mode;
142 i = mode_string(mstr, 0, mode);
143 if (strncmp(mstr, buf, max(count, i)) == 0) {
144
145 var = fb_info->var;
146 fb_videomode_to_var(&var, mode);
147 if ((err = activate(fb_info, &var)))
148 return err;
149 fb_info->mode = mode;
150 return count;
151 }
152 }
153 return -EINVAL;
154}
155
Greg Kroah-Hartman78cde082006-09-14 07:30:59 -0700156static ssize_t show_mode(struct device *device, struct device_attribute *attr,
157 char *buf)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700158{
Greg Kroah-Hartman78cde082006-09-14 07:30:59 -0700159 struct fb_info *fb_info = dev_get_drvdata(device);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700160
161 if (!fb_info->mode)
162 return 0;
163
164 return mode_string(buf, 0, fb_info->mode);
165}
166
Greg Kroah-Hartman78cde082006-09-14 07:30:59 -0700167static ssize_t store_modes(struct device *device,
168 struct device_attribute *attr,
169 const char *buf, size_t count)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700170{
Greg Kroah-Hartman78cde082006-09-14 07:30:59 -0700171 struct fb_info *fb_info = dev_get_drvdata(device);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700172 LIST_HEAD(old_list);
173 int i = count / sizeof(struct fb_videomode);
174
175 if (i * sizeof(struct fb_videomode) != count)
176 return -EINVAL;
177
Torben Hohnac751ef2011-01-25 15:07:35 -0800178 console_lock();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700179 list_splice(&fb_info->modelist, &old_list);
Geert Uytterhoeven9791d762007-02-12 00:55:19 -0800180 fb_videomode_to_modelist((const struct fb_videomode *)buf, i,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700181 &fb_info->modelist);
182 if (fb_new_modelist(fb_info)) {
183 fb_destroy_modelist(&fb_info->modelist);
184 list_splice(&old_list, &fb_info->modelist);
185 } else
186 fb_destroy_modelist(&old_list);
187
Torben Hohnac751ef2011-01-25 15:07:35 -0800188 console_unlock();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700189
190 return 0;
191}
192
Greg Kroah-Hartman78cde082006-09-14 07:30:59 -0700193static ssize_t show_modes(struct device *device, struct device_attribute *attr,
194 char *buf)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700195{
Greg Kroah-Hartman78cde082006-09-14 07:30:59 -0700196 struct fb_info *fb_info = dev_get_drvdata(device);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700197 unsigned int i;
198 struct list_head *pos;
199 struct fb_modelist *modelist;
200 const struct fb_videomode *mode;
201
202 i = 0;
203 list_for_each(pos, &fb_info->modelist) {
204 modelist = list_entry(pos, struct fb_modelist, list);
205 mode = &modelist->mode;
206 i += mode_string(buf, i, mode);
207 }
208 return i;
209}
210
Greg Kroah-Hartman78cde082006-09-14 07:30:59 -0700211static ssize_t store_bpp(struct device *device, struct device_attribute *attr,
212 const char *buf, size_t count)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700213{
Greg Kroah-Hartman78cde082006-09-14 07:30:59 -0700214 struct fb_info *fb_info = dev_get_drvdata(device);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700215 struct fb_var_screeninfo var;
216 char ** last = NULL;
217 int err;
218
219 var = fb_info->var;
220 var.bits_per_pixel = simple_strtoul(buf, last, 0);
221 if ((err = activate(fb_info, &var)))
222 return err;
223 return count;
224}
225
Greg Kroah-Hartman78cde082006-09-14 07:30:59 -0700226static ssize_t show_bpp(struct device *device, struct device_attribute *attr,
227 char *buf)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700228{
Greg Kroah-Hartman78cde082006-09-14 07:30:59 -0700229 struct fb_info *fb_info = dev_get_drvdata(device);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700230 return snprintf(buf, PAGE_SIZE, "%d\n", fb_info->var.bits_per_pixel);
231}
232
Greg Kroah-Hartman78cde082006-09-14 07:30:59 -0700233static ssize_t store_rotate(struct device *device,
234 struct device_attribute *attr,
235 const char *buf, size_t count)
Antonino A. Daplasa812c942005-11-08 21:39:15 -0800236{
Greg Kroah-Hartman78cde082006-09-14 07:30:59 -0700237 struct fb_info *fb_info = dev_get_drvdata(device);
Antonino A. Daplasa812c942005-11-08 21:39:15 -0800238 struct fb_var_screeninfo var;
239 char **last = NULL;
240 int err;
241
242 var = fb_info->var;
243 var.rotate = simple_strtoul(buf, last, 0);
244
245 if ((err = activate(fb_info, &var)))
246 return err;
247
248 return count;
249}
250
251
Greg Kroah-Hartman78cde082006-09-14 07:30:59 -0700252static ssize_t show_rotate(struct device *device,
253 struct device_attribute *attr, char *buf)
Antonino A. Daplasa812c942005-11-08 21:39:15 -0800254{
Greg Kroah-Hartman78cde082006-09-14 07:30:59 -0700255 struct fb_info *fb_info = dev_get_drvdata(device);
Antonino A. Daplasa812c942005-11-08 21:39:15 -0800256
257 return snprintf(buf, PAGE_SIZE, "%d\n", fb_info->var.rotate);
258}
259
Greg Kroah-Hartman78cde082006-09-14 07:30:59 -0700260static ssize_t store_virtual(struct device *device,
261 struct device_attribute *attr,
262 const char *buf, size_t count)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700263{
Greg Kroah-Hartman78cde082006-09-14 07:30:59 -0700264 struct fb_info *fb_info = dev_get_drvdata(device);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700265 struct fb_var_screeninfo var;
266 char *last = NULL;
267 int err;
268
269 var = fb_info->var;
270 var.xres_virtual = simple_strtoul(buf, &last, 0);
271 last++;
272 if (last - buf >= count)
273 return -EINVAL;
274 var.yres_virtual = simple_strtoul(last, &last, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700275
276 if ((err = activate(fb_info, &var)))
277 return err;
278 return count;
279}
280
Greg Kroah-Hartman78cde082006-09-14 07:30:59 -0700281static ssize_t show_virtual(struct device *device,
282 struct device_attribute *attr, char *buf)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700283{
Greg Kroah-Hartman78cde082006-09-14 07:30:59 -0700284 struct fb_info *fb_info = dev_get_drvdata(device);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700285 return snprintf(buf, PAGE_SIZE, "%d,%d\n", fb_info->var.xres_virtual,
Jon Smirle2c16492005-06-13 15:52:36 -0700286 fb_info->var.yres_virtual);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700287}
288
Greg Kroah-Hartman78cde082006-09-14 07:30:59 -0700289static ssize_t show_stride(struct device *device,
290 struct device_attribute *attr, char *buf)
James Simmonsc14e2cf2005-10-24 21:46:21 +0100291{
Greg Kroah-Hartman78cde082006-09-14 07:30:59 -0700292 struct fb_info *fb_info = dev_get_drvdata(device);
James Simmonsc14e2cf2005-10-24 21:46:21 +0100293 return snprintf(buf, PAGE_SIZE, "%d\n", fb_info->fix.line_length);
294}
295
Greg Kroah-Hartman78cde082006-09-14 07:30:59 -0700296static ssize_t store_blank(struct device *device,
297 struct device_attribute *attr,
298 const char *buf, size_t count)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700299{
Greg Kroah-Hartman78cde082006-09-14 07:30:59 -0700300 struct fb_info *fb_info = dev_get_drvdata(device);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700301 char *last = NULL;
302 int err;
303
Torben Hohnac751ef2011-01-25 15:07:35 -0800304 console_lock();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700305 fb_info->flags |= FBINFO_MISC_USEREVENT;
306 err = fb_blank(fb_info, simple_strtoul(buf, &last, 0));
307 fb_info->flags &= ~FBINFO_MISC_USEREVENT;
Torben Hohnac751ef2011-01-25 15:07:35 -0800308 console_unlock();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700309 if (err < 0)
310 return err;
311 return count;
312}
313
Greg Kroah-Hartman78cde082006-09-14 07:30:59 -0700314static ssize_t show_blank(struct device *device,
315 struct device_attribute *attr, char *buf)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700316{
Greg Kroah-Hartman78cde082006-09-14 07:30:59 -0700317// struct fb_info *fb_info = dev_get_drvdata(device);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700318 return 0;
319}
320
Greg Kroah-Hartman78cde082006-09-14 07:30:59 -0700321static ssize_t store_console(struct device *device,
322 struct device_attribute *attr,
323 const char *buf, size_t count)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700324{
Greg Kroah-Hartman78cde082006-09-14 07:30:59 -0700325// struct fb_info *fb_info = dev_get_drvdata(device);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700326 return 0;
327}
328
Greg Kroah-Hartman78cde082006-09-14 07:30:59 -0700329static ssize_t show_console(struct device *device,
330 struct device_attribute *attr, char *buf)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700331{
Greg Kroah-Hartman78cde082006-09-14 07:30:59 -0700332// struct fb_info *fb_info = dev_get_drvdata(device);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700333 return 0;
334}
335
Greg Kroah-Hartman78cde082006-09-14 07:30:59 -0700336static ssize_t store_cursor(struct device *device,
337 struct device_attribute *attr,
338 const char *buf, size_t count)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700339{
Greg Kroah-Hartman78cde082006-09-14 07:30:59 -0700340// struct fb_info *fb_info = dev_get_drvdata(device);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700341 return 0;
342}
343
Greg Kroah-Hartman78cde082006-09-14 07:30:59 -0700344static ssize_t show_cursor(struct device *device,
345 struct device_attribute *attr, char *buf)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700346{
Greg Kroah-Hartman78cde082006-09-14 07:30:59 -0700347// struct fb_info *fb_info = dev_get_drvdata(device);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700348 return 0;
349}
350
Greg Kroah-Hartman78cde082006-09-14 07:30:59 -0700351static ssize_t store_pan(struct device *device,
352 struct device_attribute *attr,
353 const char *buf, size_t count)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700354{
Greg Kroah-Hartman78cde082006-09-14 07:30:59 -0700355 struct fb_info *fb_info = dev_get_drvdata(device);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700356 struct fb_var_screeninfo var;
357 char *last = NULL;
358 int err;
359
360 var = fb_info->var;
361 var.xoffset = simple_strtoul(buf, &last, 0);
362 last++;
363 if (last - buf >= count)
364 return -EINVAL;
365 var.yoffset = simple_strtoul(last, &last, 0);
366
Torben Hohnac751ef2011-01-25 15:07:35 -0800367 console_lock();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700368 err = fb_pan_display(fb_info, &var);
Torben Hohnac751ef2011-01-25 15:07:35 -0800369 console_unlock();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700370
371 if (err < 0)
372 return err;
373 return count;
374}
375
Greg Kroah-Hartman78cde082006-09-14 07:30:59 -0700376static ssize_t show_pan(struct device *device,
377 struct device_attribute *attr, char *buf)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700378{
Greg Kroah-Hartman78cde082006-09-14 07:30:59 -0700379 struct fb_info *fb_info = dev_get_drvdata(device);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700380 return snprintf(buf, PAGE_SIZE, "%d,%d\n", fb_info->var.xoffset,
Antonino A. Daplasc4270632007-05-08 00:37:30 -0700381 fb_info->var.yoffset);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700382}
383
Greg Kroah-Hartman78cde082006-09-14 07:30:59 -0700384static ssize_t show_name(struct device *device,
385 struct device_attribute *attr, char *buf)
James Simmons02459ea2005-07-30 23:49:54 +0100386{
Greg Kroah-Hartman78cde082006-09-14 07:30:59 -0700387 struct fb_info *fb_info = dev_get_drvdata(device);
James Simmons02459ea2005-07-30 23:49:54 +0100388
389 return snprintf(buf, PAGE_SIZE, "%s\n", fb_info->fix.id);
390}
391
Greg Kroah-Hartman78cde082006-09-14 07:30:59 -0700392static ssize_t store_fbstate(struct device *device,
393 struct device_attribute *attr,
394 const char *buf, size_t count)
Matthew Garrett30420f82006-01-09 20:53:01 -0800395{
Greg Kroah-Hartman78cde082006-09-14 07:30:59 -0700396 struct fb_info *fb_info = dev_get_drvdata(device);
Matthew Garrett30420f82006-01-09 20:53:01 -0800397 u32 state;
398 char *last = NULL;
399
400 state = simple_strtoul(buf, &last, 0);
401
Herton Ronaldo Krzesinski9e769ff2011-06-17 19:02:39 +0000402 if (!lock_fb_info(fb_info))
403 return -ENODEV;
Torben Hohnac751ef2011-01-25 15:07:35 -0800404 console_lock();
Matthew Garrett30420f82006-01-09 20:53:01 -0800405 fb_set_suspend(fb_info, (int)state);
Torben Hohnac751ef2011-01-25 15:07:35 -0800406 console_unlock();
Herton Ronaldo Krzesinski9e769ff2011-06-17 19:02:39 +0000407 unlock_fb_info(fb_info);
Matthew Garrett30420f82006-01-09 20:53:01 -0800408
409 return count;
410}
411
Greg Kroah-Hartman78cde082006-09-14 07:30:59 -0700412static ssize_t show_fbstate(struct device *device,
413 struct device_attribute *attr, char *buf)
Matthew Garrett30420f82006-01-09 20:53:01 -0800414{
Greg Kroah-Hartman78cde082006-09-14 07:30:59 -0700415 struct fb_info *fb_info = dev_get_drvdata(device);
Matthew Garrett30420f82006-01-09 20:53:01 -0800416 return snprintf(buf, PAGE_SIZE, "%d\n", fb_info->state);
417}
418
Michael Hanselmann5474c122006-06-25 05:47:08 -0700419#ifdef CONFIG_FB_BACKLIGHT
Greg Kroah-Hartman78cde082006-09-14 07:30:59 -0700420static ssize_t store_bl_curve(struct device *device,
421 struct device_attribute *attr,
422 const char *buf, size_t count)
Michael Hanselmann5474c122006-06-25 05:47:08 -0700423{
Greg Kroah-Hartman78cde082006-09-14 07:30:59 -0700424 struct fb_info *fb_info = dev_get_drvdata(device);
Michael Hanselmann5474c122006-06-25 05:47:08 -0700425 u8 tmp_curve[FB_BACKLIGHT_LEVELS];
426 unsigned int i;
427
Michael Hanselmann25981de2006-09-25 16:25:07 -0700428 /* Some drivers don't use framebuffer_alloc(), but those also
429 * don't have backlights.
430 */
431 if (!fb_info || !fb_info->bl_dev)
432 return -ENODEV;
433
Michael Hanselmann5474c122006-06-25 05:47:08 -0700434 if (count != (FB_BACKLIGHT_LEVELS / 8 * 24))
435 return -EINVAL;
436
437 for (i = 0; i < (FB_BACKLIGHT_LEVELS / 8); ++i)
438 if (sscanf(&buf[i * 24],
439 "%2hhx %2hhx %2hhx %2hhx %2hhx %2hhx %2hhx %2hhx\n",
440 &tmp_curve[i * 8 + 0],
441 &tmp_curve[i * 8 + 1],
442 &tmp_curve[i * 8 + 2],
443 &tmp_curve[i * 8 + 3],
444 &tmp_curve[i * 8 + 4],
445 &tmp_curve[i * 8 + 5],
446 &tmp_curve[i * 8 + 6],
447 &tmp_curve[i * 8 + 7]) != 8)
448 return -EINVAL;
449
450 /* If there has been an error in the input data, we won't
451 * reach this loop.
452 */
Richard Purdie37ce69a2007-02-10 14:10:33 +0000453 mutex_lock(&fb_info->bl_curve_mutex);
Michael Hanselmann5474c122006-06-25 05:47:08 -0700454 for (i = 0; i < FB_BACKLIGHT_LEVELS; ++i)
455 fb_info->bl_curve[i] = tmp_curve[i];
Richard Purdie37ce69a2007-02-10 14:10:33 +0000456 mutex_unlock(&fb_info->bl_curve_mutex);
Michael Hanselmann5474c122006-06-25 05:47:08 -0700457
458 return count;
459}
460
Greg Kroah-Hartman78cde082006-09-14 07:30:59 -0700461static ssize_t show_bl_curve(struct device *device,
462 struct device_attribute *attr, char *buf)
Michael Hanselmann5474c122006-06-25 05:47:08 -0700463{
Greg Kroah-Hartman78cde082006-09-14 07:30:59 -0700464 struct fb_info *fb_info = dev_get_drvdata(device);
Michael Hanselmann5474c122006-06-25 05:47:08 -0700465 ssize_t len = 0;
466 unsigned int i;
467
Michael Hanselmann25981de2006-09-25 16:25:07 -0700468 /* Some drivers don't use framebuffer_alloc(), but those also
469 * don't have backlights.
470 */
471 if (!fb_info || !fb_info->bl_dev)
472 return -ENODEV;
473
Richard Purdie37ce69a2007-02-10 14:10:33 +0000474 mutex_lock(&fb_info->bl_curve_mutex);
Michael Hanselmann5474c122006-06-25 05:47:08 -0700475 for (i = 0; i < FB_BACKLIGHT_LEVELS; i += 8)
476 len += snprintf(&buf[len], PAGE_SIZE,
477 "%02x %02x %02x %02x %02x %02x %02x %02x\n",
478 fb_info->bl_curve[i + 0],
479 fb_info->bl_curve[i + 1],
480 fb_info->bl_curve[i + 2],
481 fb_info->bl_curve[i + 3],
482 fb_info->bl_curve[i + 4],
483 fb_info->bl_curve[i + 5],
484 fb_info->bl_curve[i + 6],
485 fb_info->bl_curve[i + 7]);
Richard Purdie37ce69a2007-02-10 14:10:33 +0000486 mutex_unlock(&fb_info->bl_curve_mutex);
Michael Hanselmann5474c122006-06-25 05:47:08 -0700487
488 return len;
489}
490#endif
491
Jon Smirl913e7ec2006-04-12 19:43:35 -0400492/* When cmap is added back in it should be a binary attribute
493 * not a text one. Consideration should also be given to converting
494 * fbdev to use configfs instead of sysfs */
Greg Kroah-Hartman78cde082006-09-14 07:30:59 -0700495static struct device_attribute device_attrs[] = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700496 __ATTR(bits_per_pixel, S_IRUGO|S_IWUSR, show_bpp, store_bpp),
497 __ATTR(blank, S_IRUGO|S_IWUSR, show_blank, store_blank),
Linus Torvalds1da177e2005-04-16 15:20:36 -0700498 __ATTR(console, S_IRUGO|S_IWUSR, show_console, store_console),
499 __ATTR(cursor, S_IRUGO|S_IWUSR, show_cursor, store_cursor),
500 __ATTR(mode, S_IRUGO|S_IWUSR, show_mode, store_mode),
501 __ATTR(modes, S_IRUGO|S_IWUSR, show_modes, store_modes),
502 __ATTR(pan, S_IRUGO|S_IWUSR, show_pan, store_pan),
503 __ATTR(virtual_size, S_IRUGO|S_IWUSR, show_virtual, store_virtual),
James Simmons02459ea2005-07-30 23:49:54 +0100504 __ATTR(name, S_IRUGO, show_name, NULL),
James Simmonsc14e2cf2005-10-24 21:46:21 +0100505 __ATTR(stride, S_IRUGO, show_stride, NULL),
Antonino A. Daplasa812c942005-11-08 21:39:15 -0800506 __ATTR(rotate, S_IRUGO|S_IWUSR, show_rotate, store_rotate),
Matthew Garrett30420f82006-01-09 20:53:01 -0800507 __ATTR(state, S_IRUGO|S_IWUSR, show_fbstate, store_fbstate),
Michael Hanselmann5474c122006-06-25 05:47:08 -0700508#ifdef CONFIG_FB_BACKLIGHT
509 __ATTR(bl_curve, S_IRUGO|S_IWUSR, show_bl_curve, store_bl_curve),
510#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700511};
512
Greg Kroah-Hartman78cde082006-09-14 07:30:59 -0700513int fb_init_device(struct fb_info *fb_info)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700514{
Antonino A. Daplas1a6600b2006-10-03 01:14:50 -0700515 int i, error = 0;
516
Greg Kroah-Hartman78cde082006-09-14 07:30:59 -0700517 dev_set_drvdata(fb_info->dev, fb_info);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700518
Antonino A. Daplas1a6600b2006-10-03 01:14:50 -0700519 fb_info->class_flag |= FB_SYSFS_FLAG_ATTR;
520
Greg Kroah-Hartman78cde082006-09-14 07:30:59 -0700521 for (i = 0; i < ARRAY_SIZE(device_attrs); i++) {
522 error = device_create_file(fb_info->dev, &device_attrs[i]);
Antonino A. Daplas1a6600b2006-10-03 01:14:50 -0700523
524 if (error)
525 break;
526 }
527
528 if (error) {
529 while (--i >= 0)
Greg Kroah-Hartman78cde082006-09-14 07:30:59 -0700530 device_remove_file(fb_info->dev, &device_attrs[i]);
Antonino A. Daplas1a6600b2006-10-03 01:14:50 -0700531 fb_info->class_flag &= ~FB_SYSFS_FLAG_ATTR;
532 }
533
Linus Torvalds1da177e2005-04-16 15:20:36 -0700534 return 0;
535}
536
Greg Kroah-Hartman78cde082006-09-14 07:30:59 -0700537void fb_cleanup_device(struct fb_info *fb_info)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700538{
539 unsigned int i;
540
Antonino A. Daplas1a6600b2006-10-03 01:14:50 -0700541 if (fb_info->class_flag & FB_SYSFS_FLAG_ATTR) {
Greg Kroah-Hartman78cde082006-09-14 07:30:59 -0700542 for (i = 0; i < ARRAY_SIZE(device_attrs); i++)
543 device_remove_file(fb_info->dev, &device_attrs[i]);
Antonino A. Daplas1a6600b2006-10-03 01:14:50 -0700544
545 fb_info->class_flag &= ~FB_SYSFS_FLAG_ATTR;
546 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700547}
548
Michael Hanselmann5474c122006-06-25 05:47:08 -0700549#ifdef CONFIG_FB_BACKLIGHT
550/* This function generates a linear backlight curve
551 *
552 * 0: off
553 * 1-7: min
554 * 8-127: linear from min to max
555 */
556void fb_bl_default_curve(struct fb_info *fb_info, u8 off, u8 min, u8 max)
557{
558 unsigned int i, flat, count, range = (max - min);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700559
Richard Purdie37ce69a2007-02-10 14:10:33 +0000560 mutex_lock(&fb_info->bl_curve_mutex);
561
Michael Hanselmann5474c122006-06-25 05:47:08 -0700562 fb_info->bl_curve[0] = off;
563
564 for (flat = 1; flat < (FB_BACKLIGHT_LEVELS / 16); ++flat)
565 fb_info->bl_curve[flat] = min;
566
567 count = FB_BACKLIGHT_LEVELS * 15 / 16;
568 for (i = 0; i < count; ++i)
569 fb_info->bl_curve[flat + i] = min + (range * (i + 1) / count);
Richard Purdie37ce69a2007-02-10 14:10:33 +0000570
571 mutex_unlock(&fb_info->bl_curve_mutex);
Michael Hanselmann5474c122006-06-25 05:47:08 -0700572}
573EXPORT_SYMBOL_GPL(fb_bl_default_curve);
574#endif