blob: 04251ce89184bbfc752e2d927f48d0f534841c7b [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
Torben Hohnac751ef2011-01-25 15:07:35 -0800402 console_lock();
Matthew Garrett30420f82006-01-09 20:53:01 -0800403 fb_set_suspend(fb_info, (int)state);
Torben Hohnac751ef2011-01-25 15:07:35 -0800404 console_unlock();
Matthew Garrett30420f82006-01-09 20:53:01 -0800405
406 return count;
407}
408
Greg Kroah-Hartman78cde082006-09-14 07:30:59 -0700409static ssize_t show_fbstate(struct device *device,
410 struct device_attribute *attr, char *buf)
Matthew Garrett30420f82006-01-09 20:53:01 -0800411{
Greg Kroah-Hartman78cde082006-09-14 07:30:59 -0700412 struct fb_info *fb_info = dev_get_drvdata(device);
Matthew Garrett30420f82006-01-09 20:53:01 -0800413 return snprintf(buf, PAGE_SIZE, "%d\n", fb_info->state);
414}
415
Michael Hanselmann5474c122006-06-25 05:47:08 -0700416#ifdef CONFIG_FB_BACKLIGHT
Greg Kroah-Hartman78cde082006-09-14 07:30:59 -0700417static ssize_t store_bl_curve(struct device *device,
418 struct device_attribute *attr,
419 const char *buf, size_t count)
Michael Hanselmann5474c122006-06-25 05:47:08 -0700420{
Greg Kroah-Hartman78cde082006-09-14 07:30:59 -0700421 struct fb_info *fb_info = dev_get_drvdata(device);
Michael Hanselmann5474c122006-06-25 05:47:08 -0700422 u8 tmp_curve[FB_BACKLIGHT_LEVELS];
423 unsigned int i;
424
Michael Hanselmann25981de2006-09-25 16:25:07 -0700425 /* Some drivers don't use framebuffer_alloc(), but those also
426 * don't have backlights.
427 */
428 if (!fb_info || !fb_info->bl_dev)
429 return -ENODEV;
430
Michael Hanselmann5474c122006-06-25 05:47:08 -0700431 if (count != (FB_BACKLIGHT_LEVELS / 8 * 24))
432 return -EINVAL;
433
434 for (i = 0; i < (FB_BACKLIGHT_LEVELS / 8); ++i)
435 if (sscanf(&buf[i * 24],
436 "%2hhx %2hhx %2hhx %2hhx %2hhx %2hhx %2hhx %2hhx\n",
437 &tmp_curve[i * 8 + 0],
438 &tmp_curve[i * 8 + 1],
439 &tmp_curve[i * 8 + 2],
440 &tmp_curve[i * 8 + 3],
441 &tmp_curve[i * 8 + 4],
442 &tmp_curve[i * 8 + 5],
443 &tmp_curve[i * 8 + 6],
444 &tmp_curve[i * 8 + 7]) != 8)
445 return -EINVAL;
446
447 /* If there has been an error in the input data, we won't
448 * reach this loop.
449 */
Richard Purdie37ce69a2007-02-10 14:10:33 +0000450 mutex_lock(&fb_info->bl_curve_mutex);
Michael Hanselmann5474c122006-06-25 05:47:08 -0700451 for (i = 0; i < FB_BACKLIGHT_LEVELS; ++i)
452 fb_info->bl_curve[i] = tmp_curve[i];
Richard Purdie37ce69a2007-02-10 14:10:33 +0000453 mutex_unlock(&fb_info->bl_curve_mutex);
Michael Hanselmann5474c122006-06-25 05:47:08 -0700454
455 return count;
456}
457
Greg Kroah-Hartman78cde082006-09-14 07:30:59 -0700458static ssize_t show_bl_curve(struct device *device,
459 struct device_attribute *attr, char *buf)
Michael Hanselmann5474c122006-06-25 05:47:08 -0700460{
Greg Kroah-Hartman78cde082006-09-14 07:30:59 -0700461 struct fb_info *fb_info = dev_get_drvdata(device);
Michael Hanselmann5474c122006-06-25 05:47:08 -0700462 ssize_t len = 0;
463 unsigned int i;
464
Michael Hanselmann25981de2006-09-25 16:25:07 -0700465 /* Some drivers don't use framebuffer_alloc(), but those also
466 * don't have backlights.
467 */
468 if (!fb_info || !fb_info->bl_dev)
469 return -ENODEV;
470
Richard Purdie37ce69a2007-02-10 14:10:33 +0000471 mutex_lock(&fb_info->bl_curve_mutex);
Michael Hanselmann5474c122006-06-25 05:47:08 -0700472 for (i = 0; i < FB_BACKLIGHT_LEVELS; i += 8)
473 len += snprintf(&buf[len], PAGE_SIZE,
474 "%02x %02x %02x %02x %02x %02x %02x %02x\n",
475 fb_info->bl_curve[i + 0],
476 fb_info->bl_curve[i + 1],
477 fb_info->bl_curve[i + 2],
478 fb_info->bl_curve[i + 3],
479 fb_info->bl_curve[i + 4],
480 fb_info->bl_curve[i + 5],
481 fb_info->bl_curve[i + 6],
482 fb_info->bl_curve[i + 7]);
Richard Purdie37ce69a2007-02-10 14:10:33 +0000483 mutex_unlock(&fb_info->bl_curve_mutex);
Michael Hanselmann5474c122006-06-25 05:47:08 -0700484
485 return len;
486}
487#endif
488
Jon Smirl913e7ec2006-04-12 19:43:35 -0400489/* When cmap is added back in it should be a binary attribute
490 * not a text one. Consideration should also be given to converting
491 * fbdev to use configfs instead of sysfs */
Greg Kroah-Hartman78cde082006-09-14 07:30:59 -0700492static struct device_attribute device_attrs[] = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700493 __ATTR(bits_per_pixel, S_IRUGO|S_IWUSR, show_bpp, store_bpp),
494 __ATTR(blank, S_IRUGO|S_IWUSR, show_blank, store_blank),
Linus Torvalds1da177e2005-04-16 15:20:36 -0700495 __ATTR(console, S_IRUGO|S_IWUSR, show_console, store_console),
496 __ATTR(cursor, S_IRUGO|S_IWUSR, show_cursor, store_cursor),
497 __ATTR(mode, S_IRUGO|S_IWUSR, show_mode, store_mode),
498 __ATTR(modes, S_IRUGO|S_IWUSR, show_modes, store_modes),
499 __ATTR(pan, S_IRUGO|S_IWUSR, show_pan, store_pan),
500 __ATTR(virtual_size, S_IRUGO|S_IWUSR, show_virtual, store_virtual),
James Simmons02459ea2005-07-30 23:49:54 +0100501 __ATTR(name, S_IRUGO, show_name, NULL),
James Simmonsc14e2cf2005-10-24 21:46:21 +0100502 __ATTR(stride, S_IRUGO, show_stride, NULL),
Antonino A. Daplasa812c942005-11-08 21:39:15 -0800503 __ATTR(rotate, S_IRUGO|S_IWUSR, show_rotate, store_rotate),
Matthew Garrett30420f82006-01-09 20:53:01 -0800504 __ATTR(state, S_IRUGO|S_IWUSR, show_fbstate, store_fbstate),
Michael Hanselmann5474c122006-06-25 05:47:08 -0700505#ifdef CONFIG_FB_BACKLIGHT
506 __ATTR(bl_curve, S_IRUGO|S_IWUSR, show_bl_curve, store_bl_curve),
507#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700508};
509
Greg Kroah-Hartman78cde082006-09-14 07:30:59 -0700510int fb_init_device(struct fb_info *fb_info)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700511{
Antonino A. Daplas1a6600b2006-10-03 01:14:50 -0700512 int i, error = 0;
513
Greg Kroah-Hartman78cde082006-09-14 07:30:59 -0700514 dev_set_drvdata(fb_info->dev, fb_info);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700515
Antonino A. Daplas1a6600b2006-10-03 01:14:50 -0700516 fb_info->class_flag |= FB_SYSFS_FLAG_ATTR;
517
Greg Kroah-Hartman78cde082006-09-14 07:30:59 -0700518 for (i = 0; i < ARRAY_SIZE(device_attrs); i++) {
519 error = device_create_file(fb_info->dev, &device_attrs[i]);
Antonino A. Daplas1a6600b2006-10-03 01:14:50 -0700520
521 if (error)
522 break;
523 }
524
525 if (error) {
526 while (--i >= 0)
Greg Kroah-Hartman78cde082006-09-14 07:30:59 -0700527 device_remove_file(fb_info->dev, &device_attrs[i]);
Antonino A. Daplas1a6600b2006-10-03 01:14:50 -0700528 fb_info->class_flag &= ~FB_SYSFS_FLAG_ATTR;
529 }
530
Linus Torvalds1da177e2005-04-16 15:20:36 -0700531 return 0;
532}
533
Greg Kroah-Hartman78cde082006-09-14 07:30:59 -0700534void fb_cleanup_device(struct fb_info *fb_info)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700535{
536 unsigned int i;
537
Antonino A. Daplas1a6600b2006-10-03 01:14:50 -0700538 if (fb_info->class_flag & FB_SYSFS_FLAG_ATTR) {
Greg Kroah-Hartman78cde082006-09-14 07:30:59 -0700539 for (i = 0; i < ARRAY_SIZE(device_attrs); i++)
540 device_remove_file(fb_info->dev, &device_attrs[i]);
Antonino A. Daplas1a6600b2006-10-03 01:14:50 -0700541
542 fb_info->class_flag &= ~FB_SYSFS_FLAG_ATTR;
543 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700544}
545
Michael Hanselmann5474c122006-06-25 05:47:08 -0700546#ifdef CONFIG_FB_BACKLIGHT
547/* This function generates a linear backlight curve
548 *
549 * 0: off
550 * 1-7: min
551 * 8-127: linear from min to max
552 */
553void fb_bl_default_curve(struct fb_info *fb_info, u8 off, u8 min, u8 max)
554{
555 unsigned int i, flat, count, range = (max - min);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700556
Richard Purdie37ce69a2007-02-10 14:10:33 +0000557 mutex_lock(&fb_info->bl_curve_mutex);
558
Michael Hanselmann5474c122006-06-25 05:47:08 -0700559 fb_info->bl_curve[0] = off;
560
561 for (flat = 1; flat < (FB_BACKLIGHT_LEVELS / 16); ++flat)
562 fb_info->bl_curve[flat] = min;
563
564 count = FB_BACKLIGHT_LEVELS * 15 / 16;
565 for (i = 0; i < count; ++i)
566 fb_info->bl_curve[flat + i] = min + (range * (i + 1) / count);
Richard Purdie37ce69a2007-02-10 14:10:33 +0000567
568 mutex_unlock(&fb_info->bl_curve_mutex);
Michael Hanselmann5474c122006-06-25 05:47:08 -0700569}
570EXPORT_SYMBOL_GPL(fb_bl_default_curve);
571#endif