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