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