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