USB: xhci: Setup HW retries correctly.
[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 #include <linux/module.h>
22
23 #define FB_SYSFS_FLAG_ATTR 1
24
25 /**
26  * framebuffer_alloc - creates a new frame buffer info structure
27  *
28  * @size: size of driver private data, can be zero
29  * @dev: pointer to the device for this fb, this can be NULL
30  *
31  * Creates a new frame buffer info structure. Also reserves @size bytes
32  * for driver private data (info->par). info->par (if any) will be
33  * aligned to sizeof(long).
34  *
35  * Returns the new structure, or NULL if an error occured.
36  *
37  */
38 struct fb_info *framebuffer_alloc(size_t size, struct device *dev)
39 {
40 #define BYTES_PER_LONG (BITS_PER_LONG/8)
41 #define PADDING (BYTES_PER_LONG - (sizeof(struct fb_info) % BYTES_PER_LONG))
42         int fb_info_size = sizeof(struct fb_info);
43         struct fb_info *info;
44         char *p;
45
46         if (size)
47                 fb_info_size += PADDING;
48
49         p = kzalloc(fb_info_size + size, GFP_KERNEL);
50
51         if (!p)
52                 return NULL;
53
54         info = (struct fb_info *) p;
55
56         if (size)
57                 info->par = p + fb_info_size;
58
59         info->device = dev;
60
61 #ifdef CONFIG_FB_BACKLIGHT
62         mutex_init(&info->bl_curve_mutex);
63 #endif
64
65         return info;
66 #undef PADDING
67 #undef BYTES_PER_LONG
68 }
69 EXPORT_SYMBOL(framebuffer_alloc);
70
71 /**
72  * framebuffer_release - marks the structure available for freeing
73  *
74  * @info: frame buffer info structure
75  *
76  * Drop the reference count of the device embedded in the
77  * framebuffer info structure.
78  *
79  */
80 void framebuffer_release(struct fb_info *info)
81 {
82         kfree(info);
83 }
84 EXPORT_SYMBOL(framebuffer_release);
85
86 static int activate(struct fb_info *fb_info, struct fb_var_screeninfo *var)
87 {
88         int err;
89
90         var->activate |= FB_ACTIVATE_FORCE;
91         acquire_console_sem();
92         fb_info->flags |= FBINFO_MISC_USEREVENT;
93         err = fb_set_var(fb_info, var);
94         fb_info->flags &= ~FBINFO_MISC_USEREVENT;
95         release_console_sem();
96         if (err)
97                 return err;
98         return 0;
99 }
100
101 static int mode_string(char *buf, unsigned int offset,
102                        const struct fb_videomode *mode)
103 {
104         char m = 'U';
105         char v = 'p';
106
107         if (mode->flag & FB_MODE_IS_DETAILED)
108                 m = 'D';
109         if (mode->flag & FB_MODE_IS_VESA)
110                 m = 'V';
111         if (mode->flag & FB_MODE_IS_STANDARD)
112                 m = 'S';
113
114         if (mode->vmode & FB_VMODE_INTERLACED)
115                 v = 'i';
116         if (mode->vmode & FB_VMODE_DOUBLE)
117                 v = 'd';
118
119         return snprintf(&buf[offset], PAGE_SIZE - offset, "%c:%dx%d%c-%d\n",
120                         m, mode->xres, mode->yres, v, mode->refresh);
121 }
122
123 static ssize_t store_mode(struct device *device, struct device_attribute *attr,
124                           const char *buf, size_t count)
125 {
126         struct fb_info *fb_info = dev_get_drvdata(device);
127         char mstr[100];
128         struct fb_var_screeninfo var;
129         struct fb_modelist *modelist;
130         struct fb_videomode *mode;
131         struct list_head *pos;
132         size_t i;
133         int err;
134
135         memset(&var, 0, sizeof(var));
136
137         list_for_each(pos, &fb_info->modelist) {
138                 modelist = list_entry(pos, struct fb_modelist, list);
139                 mode = &modelist->mode;
140                 i = mode_string(mstr, 0, mode);
141                 if (strncmp(mstr, buf, max(count, i)) == 0) {
142
143                         var = fb_info->var;
144                         fb_videomode_to_var(&var, mode);
145                         if ((err = activate(fb_info, &var)))
146                                 return err;
147                         fb_info->mode = mode;
148                         return count;
149                 }
150         }
151         return -EINVAL;
152 }
153
154 static ssize_t show_mode(struct device *device, struct device_attribute *attr,
155                          char *buf)
156 {
157         struct fb_info *fb_info = dev_get_drvdata(device);
158
159         if (!fb_info->mode)
160                 return 0;
161
162         return mode_string(buf, 0, fb_info->mode);
163 }
164
165 static ssize_t store_modes(struct device *device,
166                            struct device_attribute *attr,
167                            const char *buf, size_t count)
168 {
169         struct fb_info *fb_info = dev_get_drvdata(device);
170         LIST_HEAD(old_list);
171         int i = count / sizeof(struct fb_videomode);
172
173         if (i * sizeof(struct fb_videomode) != count)
174                 return -EINVAL;
175
176         acquire_console_sem();
177         list_splice(&fb_info->modelist, &old_list);
178         fb_videomode_to_modelist((const struct fb_videomode *)buf, i,
179                                  &fb_info->modelist);
180         if (fb_new_modelist(fb_info)) {
181                 fb_destroy_modelist(&fb_info->modelist);
182                 list_splice(&old_list, &fb_info->modelist);
183         } else
184                 fb_destroy_modelist(&old_list);
185
186         release_console_sem();
187
188         return 0;
189 }
190
191 static ssize_t show_modes(struct device *device, struct device_attribute *attr,
192                           char *buf)
193 {
194         struct fb_info *fb_info = dev_get_drvdata(device);
195         unsigned int i;
196         struct list_head *pos;
197         struct fb_modelist *modelist;
198         const struct fb_videomode *mode;
199
200         i = 0;
201         list_for_each(pos, &fb_info->modelist) {
202                 modelist = list_entry(pos, struct fb_modelist, list);
203                 mode = &modelist->mode;
204                 i += mode_string(buf, i, mode);
205         }
206         return i;
207 }
208
209 static ssize_t store_bpp(struct device *device, struct device_attribute *attr,
210                          const char *buf, size_t count)
211 {
212         struct fb_info *fb_info = dev_get_drvdata(device);
213         struct fb_var_screeninfo var;
214         char ** last = NULL;
215         int err;
216
217         var = fb_info->var;
218         var.bits_per_pixel = simple_strtoul(buf, last, 0);
219         if ((err = activate(fb_info, &var)))
220                 return err;
221         return count;
222 }
223
224 static ssize_t show_bpp(struct device *device, struct device_attribute *attr,
225                         char *buf)
226 {
227         struct fb_info *fb_info = dev_get_drvdata(device);
228         return snprintf(buf, PAGE_SIZE, "%d\n", fb_info->var.bits_per_pixel);
229 }
230
231 static ssize_t store_rotate(struct device *device,
232                             struct device_attribute *attr,
233                             const char *buf, size_t count)
234 {
235         struct fb_info *fb_info = dev_get_drvdata(device);
236         struct fb_var_screeninfo var;
237         char **last = NULL;
238         int err;
239
240         var = fb_info->var;
241         var.rotate = simple_strtoul(buf, last, 0);
242
243         if ((err = activate(fb_info, &var)))
244                 return err;
245
246         return count;
247 }
248
249
250 static ssize_t show_rotate(struct device *device,
251                            struct device_attribute *attr, char *buf)
252 {
253         struct fb_info *fb_info = dev_get_drvdata(device);
254
255         return snprintf(buf, PAGE_SIZE, "%d\n", fb_info->var.rotate);
256 }
257
258 static ssize_t store_virtual(struct device *device,
259                              struct device_attribute *attr,
260                              const char *buf, size_t count)
261 {
262         struct fb_info *fb_info = dev_get_drvdata(device);
263         struct fb_var_screeninfo var;
264         char *last = NULL;
265         int err;
266
267         var = fb_info->var;
268         var.xres_virtual = simple_strtoul(buf, &last, 0);
269         last++;
270         if (last - buf >= count)
271                 return -EINVAL;
272         var.yres_virtual = simple_strtoul(last, &last, 0);
273
274         if ((err = activate(fb_info, &var)))
275                 return err;
276         return count;
277 }
278
279 static ssize_t show_virtual(struct device *device,
280                             struct device_attribute *attr, char *buf)
281 {
282         struct fb_info *fb_info = dev_get_drvdata(device);
283         return snprintf(buf, PAGE_SIZE, "%d,%d\n", fb_info->var.xres_virtual,
284                         fb_info->var.yres_virtual);
285 }
286
287 static ssize_t show_stride(struct device *device,
288                            struct device_attribute *attr, char *buf)
289 {
290         struct fb_info *fb_info = dev_get_drvdata(device);
291         return snprintf(buf, PAGE_SIZE, "%d\n", fb_info->fix.line_length);
292 }
293
294 static ssize_t store_blank(struct device *device,
295                            struct device_attribute *attr,
296                            const char *buf, size_t count)
297 {
298         struct fb_info *fb_info = dev_get_drvdata(device);
299         char *last = NULL;
300         int err;
301
302         acquire_console_sem();
303         fb_info->flags |= FBINFO_MISC_USEREVENT;
304         err = fb_blank(fb_info, simple_strtoul(buf, &last, 0));
305         fb_info->flags &= ~FBINFO_MISC_USEREVENT;
306         release_console_sem();
307         if (err < 0)
308                 return err;
309         return count;
310 }
311
312 static ssize_t show_blank(struct device *device,
313                           struct device_attribute *attr, char *buf)
314 {
315 //      struct fb_info *fb_info = dev_get_drvdata(device);
316         return 0;
317 }
318
319 static ssize_t store_console(struct device *device,
320                              struct device_attribute *attr,
321                              const char *buf, size_t count)
322 {
323 //      struct fb_info *fb_info = dev_get_drvdata(device);
324         return 0;
325 }
326
327 static ssize_t show_console(struct device *device,
328                             struct device_attribute *attr, char *buf)
329 {
330 //      struct fb_info *fb_info = dev_get_drvdata(device);
331         return 0;
332 }
333
334 static ssize_t store_cursor(struct device *device,
335                             struct device_attribute *attr,
336                             const char *buf, size_t count)
337 {
338 //      struct fb_info *fb_info = dev_get_drvdata(device);
339         return 0;
340 }
341
342 static ssize_t show_cursor(struct device *device,
343                            struct device_attribute *attr, char *buf)
344 {
345 //      struct fb_info *fb_info = dev_get_drvdata(device);
346         return 0;
347 }
348
349 static ssize_t store_pan(struct device *device,
350                          struct device_attribute *attr,
351                          const char *buf, size_t count)
352 {
353         struct fb_info *fb_info = dev_get_drvdata(device);
354         struct fb_var_screeninfo var;
355         char *last = NULL;
356         int err;
357
358         var = fb_info->var;
359         var.xoffset = simple_strtoul(buf, &last, 0);
360         last++;
361         if (last - buf >= count)
362                 return -EINVAL;
363         var.yoffset = simple_strtoul(last, &last, 0);
364
365         acquire_console_sem();
366         err = fb_pan_display(fb_info, &var);
367         release_console_sem();
368
369         if (err < 0)
370                 return err;
371         return count;
372 }
373
374 static ssize_t show_pan(struct device *device,
375                         struct device_attribute *attr, char *buf)
376 {
377         struct fb_info *fb_info = dev_get_drvdata(device);
378         return snprintf(buf, PAGE_SIZE, "%d,%d\n", fb_info->var.xoffset,
379                         fb_info->var.yoffset);
380 }
381
382 static ssize_t show_name(struct device *device,
383                          struct device_attribute *attr, char *buf)
384 {
385         struct fb_info *fb_info = dev_get_drvdata(device);
386
387         return snprintf(buf, PAGE_SIZE, "%s\n", fb_info->fix.id);
388 }
389
390 static ssize_t store_fbstate(struct device *device,
391                              struct device_attribute *attr,
392                              const char *buf, size_t count)
393 {
394         struct fb_info *fb_info = dev_get_drvdata(device);
395         u32 state;
396         char *last = NULL;
397
398         state = simple_strtoul(buf, &last, 0);
399
400         acquire_console_sem();
401         fb_set_suspend(fb_info, (int)state);
402         release_console_sem();
403
404         return count;
405 }
406
407 static ssize_t show_fbstate(struct device *device,
408                             struct device_attribute *attr, char *buf)
409 {
410         struct fb_info *fb_info = dev_get_drvdata(device);
411         return snprintf(buf, PAGE_SIZE, "%d\n", fb_info->state);
412 }
413
414 #ifdef CONFIG_FB_BACKLIGHT
415 static ssize_t store_bl_curve(struct device *device,
416                               struct device_attribute *attr,
417                               const char *buf, size_t count)
418 {
419         struct fb_info *fb_info = dev_get_drvdata(device);
420         u8 tmp_curve[FB_BACKLIGHT_LEVELS];
421         unsigned int i;
422
423         /* Some drivers don't use framebuffer_alloc(), but those also
424          * don't have backlights.
425          */
426         if (!fb_info || !fb_info->bl_dev)
427                 return -ENODEV;
428
429         if (count != (FB_BACKLIGHT_LEVELS / 8 * 24))
430                 return -EINVAL;
431
432         for (i = 0; i < (FB_BACKLIGHT_LEVELS / 8); ++i)
433                 if (sscanf(&buf[i * 24],
434                         "%2hhx %2hhx %2hhx %2hhx %2hhx %2hhx %2hhx %2hhx\n",
435                         &tmp_curve[i * 8 + 0],
436                         &tmp_curve[i * 8 + 1],
437                         &tmp_curve[i * 8 + 2],
438                         &tmp_curve[i * 8 + 3],
439                         &tmp_curve[i * 8 + 4],
440                         &tmp_curve[i * 8 + 5],
441                         &tmp_curve[i * 8 + 6],
442                         &tmp_curve[i * 8 + 7]) != 8)
443                         return -EINVAL;
444
445         /* If there has been an error in the input data, we won't
446          * reach this loop.
447          */
448         mutex_lock(&fb_info->bl_curve_mutex);
449         for (i = 0; i < FB_BACKLIGHT_LEVELS; ++i)
450                 fb_info->bl_curve[i] = tmp_curve[i];
451         mutex_unlock(&fb_info->bl_curve_mutex);
452
453         return count;
454 }
455
456 static ssize_t show_bl_curve(struct device *device,
457                              struct device_attribute *attr, char *buf)
458 {
459         struct fb_info *fb_info = dev_get_drvdata(device);
460         ssize_t len = 0;
461         unsigned int i;
462
463         /* Some drivers don't use framebuffer_alloc(), but those also
464          * don't have backlights.
465          */
466         if (!fb_info || !fb_info->bl_dev)
467                 return -ENODEV;
468
469         mutex_lock(&fb_info->bl_curve_mutex);
470         for (i = 0; i < FB_BACKLIGHT_LEVELS; i += 8)
471                 len += snprintf(&buf[len], PAGE_SIZE,
472                                 "%02x %02x %02x %02x %02x %02x %02x %02x\n",
473                                 fb_info->bl_curve[i + 0],
474                                 fb_info->bl_curve[i + 1],
475                                 fb_info->bl_curve[i + 2],
476                                 fb_info->bl_curve[i + 3],
477                                 fb_info->bl_curve[i + 4],
478                                 fb_info->bl_curve[i + 5],
479                                 fb_info->bl_curve[i + 6],
480                                 fb_info->bl_curve[i + 7]);
481         mutex_unlock(&fb_info->bl_curve_mutex);
482
483         return len;
484 }
485 #endif
486
487 /* When cmap is added back in it should be a binary attribute
488  * not a text one. Consideration should also be given to converting
489  * fbdev to use configfs instead of sysfs */
490 static struct device_attribute device_attrs[] = {
491         __ATTR(bits_per_pixel, S_IRUGO|S_IWUSR, show_bpp, store_bpp),
492         __ATTR(blank, S_IRUGO|S_IWUSR, show_blank, store_blank),
493         __ATTR(console, S_IRUGO|S_IWUSR, show_console, store_console),
494         __ATTR(cursor, S_IRUGO|S_IWUSR, show_cursor, store_cursor),
495         __ATTR(mode, S_IRUGO|S_IWUSR, show_mode, store_mode),
496         __ATTR(modes, S_IRUGO|S_IWUSR, show_modes, store_modes),
497         __ATTR(pan, S_IRUGO|S_IWUSR, show_pan, store_pan),
498         __ATTR(virtual_size, S_IRUGO|S_IWUSR, show_virtual, store_virtual),
499         __ATTR(name, S_IRUGO, show_name, NULL),
500         __ATTR(stride, S_IRUGO, show_stride, NULL),
501         __ATTR(rotate, S_IRUGO|S_IWUSR, show_rotate, store_rotate),
502         __ATTR(state, S_IRUGO|S_IWUSR, show_fbstate, store_fbstate),
503 #ifdef CONFIG_FB_BACKLIGHT
504         __ATTR(bl_curve, S_IRUGO|S_IWUSR, show_bl_curve, store_bl_curve),
505 #endif
506 };
507
508 int fb_init_device(struct fb_info *fb_info)
509 {
510         int i, error = 0;
511
512         dev_set_drvdata(fb_info->dev, fb_info);
513
514         fb_info->class_flag |= FB_SYSFS_FLAG_ATTR;
515
516         for (i = 0; i < ARRAY_SIZE(device_attrs); i++) {
517                 error = device_create_file(fb_info->dev, &device_attrs[i]);
518
519                 if (error)
520                         break;
521         }
522
523         if (error) {
524                 while (--i >= 0)
525                         device_remove_file(fb_info->dev, &device_attrs[i]);
526                 fb_info->class_flag &= ~FB_SYSFS_FLAG_ATTR;
527         }
528
529         return 0;
530 }
531
532 void fb_cleanup_device(struct fb_info *fb_info)
533 {
534         unsigned int i;
535
536         if (fb_info->class_flag & FB_SYSFS_FLAG_ATTR) {
537                 for (i = 0; i < ARRAY_SIZE(device_attrs); i++)
538                         device_remove_file(fb_info->dev, &device_attrs[i]);
539
540                 fb_info->class_flag &= ~FB_SYSFS_FLAG_ATTR;
541         }
542 }
543
544 #ifdef CONFIG_FB_BACKLIGHT
545 /* This function generates a linear backlight curve
546  *
547  *     0: off
548  *   1-7: min
549  * 8-127: linear from min to max
550  */
551 void fb_bl_default_curve(struct fb_info *fb_info, u8 off, u8 min, u8 max)
552 {
553         unsigned int i, flat, count, range = (max - min);
554
555         mutex_lock(&fb_info->bl_curve_mutex);
556
557         fb_info->bl_curve[0] = off;
558
559         for (flat = 1; flat < (FB_BACKLIGHT_LEVELS / 16); ++flat)
560                 fb_info->bl_curve[flat] = min;
561
562         count = FB_BACKLIGHT_LEVELS * 15 / 16;
563         for (i = 0; i < count; ++i)
564                 fb_info->bl_curve[flat + i] = min + (range * (i + 1) / count);
565
566         mutex_unlock(&fb_info->bl_curve_mutex);
567 }
568 EXPORT_SYMBOL_GPL(fb_bl_default_curve);
569 #endif