Pull address_range into release branch
[linux-2.6] / drivers / video / fbsysfs.c
1 /*
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>
19 #include <linux/fb.h>
20 #include <linux/console.h>
21
22 /**
23  * framebuffer_alloc - creates a new frame buffer info structure
24  *
25  * @size: size of driver private data, can be zero
26  * @dev: pointer to the device for this fb, this can be NULL
27  *
28  * Creates a new frame buffer info structure. Also reserves @size bytes
29  * for driver private data (info->par). info->par (if any) will be
30  * aligned to sizeof(long).
31  *
32  * Returns the new structure, or NULL if an error occured.
33  *
34  */
35 struct fb_info *framebuffer_alloc(size_t size, struct device *dev)
36 {
37 #define BYTES_PER_LONG (BITS_PER_LONG/8)
38 #define PADDING (BYTES_PER_LONG - (sizeof(struct fb_info) % BYTES_PER_LONG))
39         int fb_info_size = sizeof(struct fb_info);
40         struct fb_info *info;
41         char *p;
42
43         if (size)
44                 fb_info_size += PADDING;
45
46         p = kzalloc(fb_info_size + size, GFP_KERNEL);
47
48         if (!p)
49                 return NULL;
50
51         info = (struct fb_info *) p;
52
53         if (size)
54                 info->par = p + fb_info_size;
55
56         info->device = dev;
57
58         return info;
59 #undef PADDING
60 #undef BYTES_PER_LONG
61 }
62 EXPORT_SYMBOL(framebuffer_alloc);
63
64 /**
65  * framebuffer_release - marks the structure available for freeing
66  *
67  * @info: frame buffer info structure
68  *
69  * Drop the reference count of the class_device embedded in the
70  * framebuffer info structure.
71  *
72  */
73 void framebuffer_release(struct fb_info *info)
74 {
75         kfree(info);
76 }
77 EXPORT_SYMBOL(framebuffer_release);
78
79 static int activate(struct fb_info *fb_info, struct fb_var_screeninfo *var)
80 {
81         int err;
82
83         var->activate |= FB_ACTIVATE_FORCE;
84         acquire_console_sem();
85         fb_info->flags |= FBINFO_MISC_USEREVENT;
86         err = fb_set_var(fb_info, var);
87         fb_info->flags &= ~FBINFO_MISC_USEREVENT;
88         release_console_sem();
89         if (err)
90                 return err;
91         return 0;
92 }
93
94 static int mode_string(char *buf, unsigned int offset,
95                        const struct fb_videomode *mode)
96 {
97         char m = 'U';
98         if (mode->flag & FB_MODE_IS_DETAILED)
99                 m = 'D';
100         if (mode->flag & FB_MODE_IS_VESA)
101                 m = 'V';
102         if (mode->flag & FB_MODE_IS_STANDARD)
103                 m = 'S';
104         return snprintf(&buf[offset], PAGE_SIZE - offset, "%c:%dx%d-%d\n", m, mode->xres, mode->yres, mode->refresh);
105 }
106
107 static ssize_t store_mode(struct class_device *class_device, const char * buf,
108                           size_t count)
109 {
110         struct fb_info *fb_info = class_get_devdata(class_device);
111         char mstr[100];
112         struct fb_var_screeninfo var;
113         struct fb_modelist *modelist;
114         struct fb_videomode *mode;
115         struct list_head *pos;
116         size_t i;
117         int err;
118
119         memset(&var, 0, sizeof(var));
120
121         list_for_each(pos, &fb_info->modelist) {
122                 modelist = list_entry(pos, struct fb_modelist, list);
123                 mode = &modelist->mode;
124                 i = mode_string(mstr, 0, mode);
125                 if (strncmp(mstr, buf, max(count, i)) == 0) {
126
127                         var = fb_info->var;
128                         fb_videomode_to_var(&var, mode);
129                         if ((err = activate(fb_info, &var)))
130                                 return err;
131                         fb_info->mode = mode;
132                         return count;
133                 }
134         }
135         return -EINVAL;
136 }
137
138 static ssize_t show_mode(struct class_device *class_device, char *buf)
139 {
140         struct fb_info *fb_info = class_get_devdata(class_device);
141
142         if (!fb_info->mode)
143                 return 0;
144
145         return mode_string(buf, 0, fb_info->mode);
146 }
147
148 static ssize_t store_modes(struct class_device *class_device, const char * buf,
149                            size_t count)
150 {
151         struct fb_info *fb_info = class_get_devdata(class_device);
152         LIST_HEAD(old_list);
153         int i = count / sizeof(struct fb_videomode);
154
155         if (i * sizeof(struct fb_videomode) != count)
156                 return -EINVAL;
157
158         acquire_console_sem();
159         list_splice(&fb_info->modelist, &old_list);
160         fb_videomode_to_modelist((struct fb_videomode *)buf, i,
161                                  &fb_info->modelist);
162         if (fb_new_modelist(fb_info)) {
163                 fb_destroy_modelist(&fb_info->modelist);
164                 list_splice(&old_list, &fb_info->modelist);
165         } else
166                 fb_destroy_modelist(&old_list);
167
168         release_console_sem();
169
170         return 0;
171 }
172
173 static ssize_t show_modes(struct class_device *class_device, char *buf)
174 {
175         struct fb_info *fb_info = class_get_devdata(class_device);
176         unsigned int i;
177         struct list_head *pos;
178         struct fb_modelist *modelist;
179         const struct fb_videomode *mode;
180
181         i = 0;
182         list_for_each(pos, &fb_info->modelist) {
183                 modelist = list_entry(pos, struct fb_modelist, list);
184                 mode = &modelist->mode;
185                 i += mode_string(buf, i, mode);
186         }
187         return i;
188 }
189
190 static ssize_t store_bpp(struct class_device *class_device, const char * buf,
191                          size_t count)
192 {
193         struct fb_info *fb_info = class_get_devdata(class_device);
194         struct fb_var_screeninfo var;
195         char ** last = NULL;
196         int err;
197
198         var = fb_info->var;
199         var.bits_per_pixel = simple_strtoul(buf, last, 0);
200         if ((err = activate(fb_info, &var)))
201                 return err;
202         return count;
203 }
204
205 static ssize_t show_bpp(struct class_device *class_device, char *buf)
206 {
207         struct fb_info *fb_info = class_get_devdata(class_device);
208         return snprintf(buf, PAGE_SIZE, "%d\n", fb_info->var.bits_per_pixel);
209 }
210
211 static ssize_t store_rotate(struct class_device *class_device, const char *buf,
212                             size_t count)
213 {
214         struct fb_info *fb_info = class_get_devdata(class_device);
215         struct fb_var_screeninfo var;
216         char **last = NULL;
217         int err;
218
219         var = fb_info->var;
220         var.rotate = simple_strtoul(buf, last, 0);
221
222         if ((err = activate(fb_info, &var)))
223                 return err;
224
225         return count;
226 }
227
228
229 static ssize_t show_rotate(struct class_device *class_device, char *buf)
230 {
231         struct fb_info *fb_info = class_get_devdata(class_device);
232
233         return snprintf(buf, PAGE_SIZE, "%d\n", fb_info->var.rotate);
234 }
235
236 static ssize_t store_con_rotate(struct class_device *class_device,
237                                 const char *buf, size_t count)
238 {
239         struct fb_info *fb_info = class_get_devdata(class_device);
240         int rotate;
241         char **last = NULL;
242
243         acquire_console_sem();
244         rotate = simple_strtoul(buf, last, 0);
245         fb_con_duit(fb_info, FB_EVENT_SET_CON_ROTATE, &rotate);
246         release_console_sem();
247         return count;
248 }
249
250 static ssize_t store_con_rotate_all(struct class_device *class_device,
251                                 const char *buf, size_t count)
252 {
253         struct fb_info *fb_info = class_get_devdata(class_device);
254         int rotate;
255         char **last = NULL;
256
257         acquire_console_sem();
258         rotate = simple_strtoul(buf, last, 0);
259         fb_con_duit(fb_info, FB_EVENT_SET_CON_ROTATE_ALL, &rotate);
260         release_console_sem();
261         return count;
262 }
263
264 static ssize_t show_con_rotate(struct class_device *class_device, char *buf)
265 {
266         struct fb_info *fb_info = class_get_devdata(class_device);
267         int rotate;
268
269         acquire_console_sem();
270         rotate = fb_con_duit(fb_info, FB_EVENT_GET_CON_ROTATE, NULL);
271         release_console_sem();
272         return snprintf(buf, PAGE_SIZE, "%d\n", rotate);
273 }
274
275 static ssize_t store_virtual(struct class_device *class_device,
276                              const char * buf, size_t count)
277 {
278         struct fb_info *fb_info = class_get_devdata(class_device);
279         struct fb_var_screeninfo var;
280         char *last = NULL;
281         int err;
282
283         var = fb_info->var;
284         var.xres_virtual = simple_strtoul(buf, &last, 0);
285         last++;
286         if (last - buf >= count)
287                 return -EINVAL;
288         var.yres_virtual = simple_strtoul(last, &last, 0);
289
290         if ((err = activate(fb_info, &var)))
291                 return err;
292         return count;
293 }
294
295 static ssize_t show_virtual(struct class_device *class_device, char *buf)
296 {
297         struct fb_info *fb_info = class_get_devdata(class_device);
298         return snprintf(buf, PAGE_SIZE, "%d,%d\n", fb_info->var.xres_virtual,
299                         fb_info->var.yres_virtual);
300 }
301
302 static ssize_t show_stride(struct class_device *class_device, char *buf)
303 {
304         struct fb_info *fb_info = class_get_devdata(class_device);
305         return snprintf(buf, PAGE_SIZE, "%d\n", fb_info->fix.line_length);
306 }
307
308 static ssize_t store_blank(struct class_device *class_device, const char * buf,
309                            size_t count)
310 {
311         struct fb_info *fb_info = class_get_devdata(class_device);
312         char *last = NULL;
313         int err;
314
315         acquire_console_sem();
316         fb_info->flags |= FBINFO_MISC_USEREVENT;
317         err = fb_blank(fb_info, simple_strtoul(buf, &last, 0));
318         fb_info->flags &= ~FBINFO_MISC_USEREVENT;
319         release_console_sem();
320         if (err < 0)
321                 return err;
322         return count;
323 }
324
325 static ssize_t show_blank(struct class_device *class_device, char *buf)
326 {
327 //      struct fb_info *fb_info = class_get_devdata(class_device);
328         return 0;
329 }
330
331 static ssize_t store_console(struct class_device *class_device,
332                              const char * buf, size_t count)
333 {
334 //      struct fb_info *fb_info = class_get_devdata(class_device);
335         return 0;
336 }
337
338 static ssize_t show_console(struct class_device *class_device, char *buf)
339 {
340 //      struct fb_info *fb_info = class_get_devdata(class_device);
341         return 0;
342 }
343
344 static ssize_t store_cursor(struct class_device *class_device,
345                             const char * buf, size_t count)
346 {
347 //      struct fb_info *fb_info = class_get_devdata(class_device);
348         return 0;
349 }
350
351 static ssize_t show_cursor(struct class_device *class_device, char *buf)
352 {
353 //      struct fb_info *fb_info = class_get_devdata(class_device);
354         return 0;
355 }
356
357 static ssize_t store_pan(struct class_device *class_device, const char * buf,
358                          size_t count)
359 {
360         struct fb_info *fb_info = class_get_devdata(class_device);
361         struct fb_var_screeninfo var;
362         char *last = NULL;
363         int err;
364
365         var = fb_info->var;
366         var.xoffset = simple_strtoul(buf, &last, 0);
367         last++;
368         if (last - buf >= count)
369                 return -EINVAL;
370         var.yoffset = simple_strtoul(last, &last, 0);
371
372         acquire_console_sem();
373         err = fb_pan_display(fb_info, &var);
374         release_console_sem();
375
376         if (err < 0)
377                 return err;
378         return count;
379 }
380
381 static ssize_t show_pan(struct class_device *class_device, char *buf)
382 {
383         struct fb_info *fb_info = class_get_devdata(class_device);
384         return snprintf(buf, PAGE_SIZE, "%d,%d\n", fb_info->var.xoffset,
385                         fb_info->var.xoffset);
386 }
387
388 static ssize_t show_name(struct class_device *class_device, char *buf)
389 {
390         struct fb_info *fb_info = class_get_devdata(class_device);
391
392         return snprintf(buf, PAGE_SIZE, "%s\n", fb_info->fix.id);
393 }
394
395 static ssize_t store_fbstate(struct class_device *class_device,
396                         const char *buf, size_t count)
397 {
398         struct fb_info *fb_info = class_get_devdata(class_device);
399         u32 state;
400         char *last = NULL;
401
402         state = simple_strtoul(buf, &last, 0);
403
404         acquire_console_sem();
405         fb_set_suspend(fb_info, (int)state);
406         release_console_sem();
407
408         return count;
409 }
410
411 static ssize_t show_fbstate(struct class_device *class_device, char *buf)
412 {
413         struct fb_info *fb_info = class_get_devdata(class_device);
414         return snprintf(buf, PAGE_SIZE, "%d\n", fb_info->state);
415 }
416
417 /* When cmap is added back in it should be a binary attribute
418  * not a text one. Consideration should also be given to converting
419  * fbdev to use configfs instead of sysfs */
420 static struct class_device_attribute class_device_attrs[] = {
421         __ATTR(bits_per_pixel, S_IRUGO|S_IWUSR, show_bpp, store_bpp),
422         __ATTR(blank, S_IRUGO|S_IWUSR, show_blank, store_blank),
423         __ATTR(console, S_IRUGO|S_IWUSR, show_console, store_console),
424         __ATTR(cursor, S_IRUGO|S_IWUSR, show_cursor, store_cursor),
425         __ATTR(mode, S_IRUGO|S_IWUSR, show_mode, store_mode),
426         __ATTR(modes, S_IRUGO|S_IWUSR, show_modes, store_modes),
427         __ATTR(pan, S_IRUGO|S_IWUSR, show_pan, store_pan),
428         __ATTR(virtual_size, S_IRUGO|S_IWUSR, show_virtual, store_virtual),
429         __ATTR(name, S_IRUGO, show_name, NULL),
430         __ATTR(stride, S_IRUGO, show_stride, NULL),
431         __ATTR(rotate, S_IRUGO|S_IWUSR, show_rotate, store_rotate),
432         __ATTR(con_rotate, S_IRUGO|S_IWUSR, show_con_rotate, store_con_rotate),
433         __ATTR(con_rotate_all, S_IWUSR, NULL, store_con_rotate_all),
434         __ATTR(state, S_IRUGO|S_IWUSR, show_fbstate, store_fbstate),
435 };
436
437 int fb_init_class_device(struct fb_info *fb_info)
438 {
439         unsigned int i;
440         class_set_devdata(fb_info->class_device, fb_info);
441
442         for (i = 0; i < ARRAY_SIZE(class_device_attrs); i++)
443                 class_device_create_file(fb_info->class_device,
444                                          &class_device_attrs[i]);
445         return 0;
446 }
447
448 void fb_cleanup_class_device(struct fb_info *fb_info)
449 {
450         unsigned int i;
451
452         for (i = 0; i < ARRAY_SIZE(class_device_attrs); i++)
453                 class_device_remove_file(fb_info->class_device,
454                                          &class_device_attrs[i]);
455 }
456
457