drivers/video/fbdev/core/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         info->fbcon_rotate_hint = -1;
  62
  63 #ifdef CONFIG_FB_BACKLIGHT
  64         mutex_init(&info->bl_curve_mutex);
  65 #endif
  66
  67         return info;
  68 #undef PADDING
  69 #undef BYTES_PER_LONG
  70 }
  71 EXPORT_SYMBOL(framebuffer_alloc);
  72
  73 /**
  74  * framebuffer_release - marks the structure available for freeing
  75  *
  76  * @info: frame buffer info structure
  77  *
  78  * Drop the reference count of the device embedded in the
  79  * framebuffer info structure.
  80  *
  81  */
  82 void framebuffer_release(struct fb_info *info)
  83 {
  84         if (!info)
  85                 return;
  86         kfree(info->apertures);
  87         kfree(info);
  88 }
  89 EXPORT_SYMBOL(framebuffer_release);
  90
  91 static int activate(struct fb_info *fb_info, struct fb_var_screeninfo *var)
  92 {
  93         int err;
  94
  95         var->activate |= FB_ACTIVATE_FORCE;
  96         console_lock();
  97         fb_info->flags |= FBINFO_MISC_USEREVENT;
  98         err = fb_set_var(fb_info, var);
  99         fb_info->flags &= ~FBINFO_MISC_USEREVENT;
 100         console_unlock();
 101         if (err)
 102                 return err;
 103         return 0;
 104 }
 105
 106 static int mode_string(char *buf, unsigned int offset,
 107                        const struct fb_videomode *mode)
 108 {
 109         char m = 'U';
 110         char v = 'p';
 111
 112         if (mode->flag & FB_MODE_IS_DETAILED)
 113                 m = 'D';
 114         if (mode->flag & FB_MODE_IS_VESA)
 115                 m = 'V';
 116         if (mode->flag & FB_MODE_IS_STANDARD)
 117                 m = 'S';
 118
 119         if (mode->vmode & FB_VMODE_INTERLACED)
 120                 v = 'i';
 121         if (mode->vmode & FB_VMODE_DOUBLE)
 122                 v = 'd';
 123
 124         return snprintf(&buf[offset], PAGE_SIZE - offset, "%c:%dx%d%c-%d\n",
 125                         m, mode->xres, mode->yres, v, mode->refresh);
 126 }
 127
 128 static ssize_t store_mode(struct device *device, struct device_attribute *attr,
 129                           const char *buf, size_t count)
 130 {
 131         struct fb_info *fb_info = dev_get_drvdata(device);
 132         char mstr[100];
 133         struct fb_var_screeninfo var;
 134         struct fb_modelist *modelist;
 135         struct fb_videomode *mode;
 136         struct list_head *pos;
 137         size_t i;
 138         int err;
 139
 140         memset(&var, 0, sizeof(var));
 141
 142         list_for_each(pos, &fb_info->modelist) {
 143                 modelist = list_entry(pos, struct fb_modelist, list);
 144                 mode = &modelist->mode;
 145                 i = mode_string(mstr, 0, mode);
 146                 if (strncmp(mstr, buf, max(count, i)) == 0) {
 147
 148                         var = fb_info->var;
 149                         fb_videomode_to_var(&var, mode);
 150                         if ((err = activate(fb_info, &var)))
 151                                 return err;
 152                         fb_info->mode = mode;
 153                         return count;
 154                 }
 155         }
 156         return -EINVAL;
 157 }
 158
 159 static ssize_t show_mode(struct device *device, struct device_attribute *attr,
 160                          char *buf)
 161 {
 162         struct fb_info *fb_info = dev_get_drvdata(device);
 163
 164         if (!fb_info->mode)
 165                 return 0;
 166
 167         return mode_string(buf, 0, fb_info->mode);
 168 }
 169
 170 static ssize_t store_modes(struct device *device,
 171                            struct device_attribute *attr,
 172                            const char *buf, size_t count)
 173 {
 174         struct fb_info *fb_info = dev_get_drvdata(device);
 175         LIST_HEAD(old_list);
 176         int i = count / sizeof(struct fb_videomode);
 177
 178         if (i * sizeof(struct fb_videomode) != count)
 179                 return -EINVAL;
 180
 181         console_lock();
 182         if (!lock_fb_info(fb_info)) {
 183                 console_unlock();
 184                 return -ENODEV;
 185         }
 186
 187         list_splice(&fb_info->modelist, &old_list);
 188         fb_videomode_to_modelist((const struct fb_videomode *)buf, i,
 189                                  &fb_info->modelist);
 190         if (fb_new_modelist(fb_info)) {
 191                 fb_destroy_modelist(&fb_info->modelist);
 192                 list_splice(&old_list, &fb_info->modelist);
 193         } else
 194                 fb_destroy_modelist(&old_list);
 195
 196         unlock_fb_info(fb_info);
 197         console_unlock();
 198
 199         return 0;
 200 }
 201
 202 static ssize_t show_modes(struct device *device, struct device_attribute *attr,
 203                           char *buf)
 204 {
 205         struct fb_info *fb_info = dev_get_drvdata(device);
 206         unsigned int i;
 207         struct list_head *pos;
 208         struct fb_modelist *modelist;
 209         const struct fb_videomode *mode;
 210
 211         i = 0;
 212         list_for_each(pos, &fb_info->modelist) {
 213                 modelist = list_entry(pos, struct fb_modelist, list);
 214                 mode = &modelist->mode;
 215                 i += mode_string(buf, i, mode);
 216         }
 217         return i;
 218 }
 219
 220 static ssize_t store_bpp(struct device *device, struct device_attribute *attr,
 221                          const char *buf, size_t count)
 222 {
 223         struct fb_info *fb_info = dev_get_drvdata(device);
 224         struct fb_var_screeninfo var;
 225         char ** last = NULL;
 226         int err;
 227
 228         var = fb_info->var;
 229         var.bits_per_pixel = simple_strtoul(buf, last, 0);
 230         if ((err = activate(fb_info, &var)))
 231                 return err;
 232         return count;
 233 }
 234
 235 static ssize_t show_bpp(struct device *device, struct device_attribute *attr,
 236                         char *buf)
 237 {
 238         struct fb_info *fb_info = dev_get_drvdata(device);
 239         return snprintf(buf, PAGE_SIZE, "%d\n", fb_info->var.bits_per_pixel);
 240 }
 241
 242 static ssize_t store_rotate(struct device *device,
 243                             struct device_attribute *attr,
 244                             const char *buf, size_t count)
 245 {
 246         struct fb_info *fb_info = dev_get_drvdata(device);
 247         struct fb_var_screeninfo var;
 248         char **last = NULL;
 249         int err;
 250
 251         var = fb_info->var;
 252         var.rotate = simple_strtoul(buf, last, 0);
 253
 254         if ((err = activate(fb_info, &var)))
 255                 return err;
 256
 257         return count;
 258 }
 259
 260
 261 static ssize_t show_rotate(struct device *device,
 262                            struct device_attribute *attr, char *buf)
 263 {
 264         struct fb_info *fb_info = dev_get_drvdata(device);
 265
 266         return snprintf(buf, PAGE_SIZE, "%d\n", fb_info->var.rotate);
 267 }
 268
 269 static ssize_t store_virtual(struct device *device,
 270                              struct device_attribute *attr,
 271                              const char *buf, size_t count)
 272 {
 273         struct fb_info *fb_info = dev_get_drvdata(device);
 274         struct fb_var_screeninfo var;
 275         char *last = NULL;
 276         int err;
 277
 278         var = fb_info->var;
 279         var.xres_virtual = simple_strtoul(buf, &last, 0);
 280         last++;
 281         if (last - buf >= count)
 282                 return -EINVAL;
 283         var.yres_virtual = simple_strtoul(last, &last, 0);
 284
 285         if ((err = activate(fb_info, &var)))
 286                 return err;
 287         return count;
 288 }
 289
 290 static ssize_t show_virtual(struct device *device,
 291                             struct device_attribute *attr, char *buf)
 292 {
 293         struct fb_info *fb_info = dev_get_drvdata(device);
 294         return snprintf(buf, PAGE_SIZE, "%d,%d\n", fb_info->var.xres_virtual,
 295                         fb_info->var.yres_virtual);
 296 }
 297
 298 static ssize_t show_stride(struct device *device,
 299                            struct device_attribute *attr, char *buf)
 300 {
 301         struct fb_info *fb_info = dev_get_drvdata(device);
 302         return snprintf(buf, PAGE_SIZE, "%d\n", fb_info->fix.line_length);
 303 }
 304
 305 static ssize_t store_blank(struct device *device,
 306                            struct device_attribute *attr,
 307                            const char *buf, size_t count)
 308 {
 309         struct fb_info *fb_info = dev_get_drvdata(device);
 310         char *last = NULL;
 311         int err;
 312
 313         console_lock();
 314         fb_info->flags |= FBINFO_MISC_USEREVENT;
 315         err = fb_blank(fb_info, simple_strtoul(buf, &last, 0));
 316         fb_info->flags &= ~FBINFO_MISC_USEREVENT;
 317         console_unlock();
 318         if (err < 0)
 319                 return err;
 320         return count;
 321 }
 322
 323 static ssize_t show_blank(struct device *device,
 324                           struct device_attribute *attr, char *buf)
 325 {
 326 //      struct fb_info *fb_info = dev_get_drvdata(device);
 327         return 0;
 328 }
 329
 330 static ssize_t store_console(struct device *device,
 331                              struct device_attribute *attr,
 332                              const char *buf, size_t count)
 333 {
 334 //      struct fb_info *fb_info = dev_get_drvdata(device);
 335         return 0;
 336 }
 337
 338 static ssize_t show_console(struct device *device,
 339                             struct device_attribute *attr, char *buf)
 340 {
 341 //      struct fb_info *fb_info = dev_get_drvdata(device);
 342         return 0;
 343 }
 344
 345 static ssize_t store_cursor(struct device *device,
 346                             struct device_attribute *attr,
 347                             const char *buf, size_t count)
 348 {
 349 //      struct fb_info *fb_info = dev_get_drvdata(device);
 350         return 0;
 351 }
 352
 353 static ssize_t show_cursor(struct device *device,
 354                            struct device_attribute *attr, char *buf)
 355 {
 356 //      struct fb_info *fb_info = dev_get_drvdata(device);
 357         return 0;
 358 }
 359
 360 static ssize_t store_pan(struct device *device,
 361                          struct device_attribute *attr,
 362                          const char *buf, size_t count)
 363 {
 364         struct fb_info *fb_info = dev_get_drvdata(device);
 365         struct fb_var_screeninfo var;
 366         char *last = NULL;
 367         int err;
 368
 369         var = fb_info->var;
 370         var.xoffset = simple_strtoul(buf, &last, 0);
 371         last++;
 372         if (last - buf >= count)
 373                 return -EINVAL;
 374         var.yoffset = simple_strtoul(last, &last, 0);
 375
 376         console_lock();
 377         err = fb_pan_display(fb_info, &var);
 378         console_unlock();
 379
 380         if (err < 0)
 381                 return err;
 382         return count;
 383 }
 384
 385 static ssize_t show_pan(struct device *device,
 386                         struct device_attribute *attr, char *buf)
 387 {
 388         struct fb_info *fb_info = dev_get_drvdata(device);
 389         return snprintf(buf, PAGE_SIZE, "%d,%d\n", fb_info->var.xoffset,
 390                         fb_info->var.yoffset);
 391 }
 392
 393 static ssize_t show_name(struct device *device,
 394                          struct device_attribute *attr, char *buf)
 395 {
 396         struct fb_info *fb_info = dev_get_drvdata(device);
 397
 398         return snprintf(buf, PAGE_SIZE, "%s\n", fb_info->fix.id);
 399 }
 400
 401 static ssize_t store_fbstate(struct device *device,
 402                              struct device_attribute *attr,
 403                              const char *buf, size_t count)
 404 {
 405         struct fb_info *fb_info = dev_get_drvdata(device);
 406         u32 state;
 407         char *last = NULL;
 408
 409         state = simple_strtoul(buf, &last, 0);
 410
 411         console_lock();
 412         if (!lock_fb_info(fb_info)) {
 413                 console_unlock();
 414                 return -ENODEV;
 415         }
 416
 417         fb_set_suspend(fb_info, (int)state);
 418
 419         unlock_fb_info(fb_info);
 420         console_unlock();
 421
 422         return count;
 423 }
 424
 425 static ssize_t show_fbstate(struct device *device,
 426                             struct device_attribute *attr, char *buf)
 427 {
 428         struct fb_info *fb_info = dev_get_drvdata(device);
 429         return snprintf(buf, PAGE_SIZE, "%d\n", fb_info->state);
 430 }
 431
 432 #ifdef CONFIG_FB_BACKLIGHT
 433 static ssize_t store_bl_curve(struct device *device,
 434                               struct device_attribute *attr,
 435                               const char *buf, size_t count)
 436 {
 437         struct fb_info *fb_info = dev_get_drvdata(device);
 438         u8 tmp_curve[FB_BACKLIGHT_LEVELS];
 439         unsigned int i;
 440
 441         /* Some drivers don't use framebuffer_alloc(), but those also
 442          * don't have backlights.
 443          */
 444         if (!fb_info || !fb_info->bl_dev)
 445                 return -ENODEV;
 446
 447         if (count != (FB_BACKLIGHT_LEVELS / 8 * 24))
 448                 return -EINVAL;
 449
 450         for (i = 0; i < (FB_BACKLIGHT_LEVELS / 8); ++i)
 451                 if (sscanf(&buf[i * 24],
 452                         "%2hhx %2hhx %2hhx %2hhx %2hhx %2hhx %2hhx %2hhx\n",
 453                         &tmp_curve[i * 8 + 0],
 454                         &tmp_curve[i * 8 + 1],
 455                         &tmp_curve[i * 8 + 2],
 456                         &tmp_curve[i * 8 + 3],
 457                         &tmp_curve[i * 8 + 4],
 458                         &tmp_curve[i * 8 + 5],
 459                         &tmp_curve[i * 8 + 6],
 460                         &tmp_curve[i * 8 + 7]) != 8)
 461                         return -EINVAL;
 462
 463         /* If there has been an error in the input data, we won't
 464          * reach this loop.
 465          */
 466         mutex_lock(&fb_info->bl_curve_mutex);
 467         for (i = 0; i < FB_BACKLIGHT_LEVELS; ++i)
 468                 fb_info->bl_curve[i] = tmp_curve[i];
 469         mutex_unlock(&fb_info->bl_curve_mutex);
 470
 471         return count;
 472 }
 473
 474 static ssize_t show_bl_curve(struct device *device,
 475                              struct device_attribute *attr, char *buf)
 476 {
 477         struct fb_info *fb_info = dev_get_drvdata(device);
 478         ssize_t len = 0;
 479         unsigned int i;
 480
 481         /* Some drivers don't use framebuffer_alloc(), but those also
 482          * don't have backlights.
 483          */
 484         if (!fb_info || !fb_info->bl_dev)
 485                 return -ENODEV;
 486
 487         mutex_lock(&fb_info->bl_curve_mutex);
 488         for (i = 0; i < FB_BACKLIGHT_LEVELS; i += 8)
 489                 len += scnprintf(&buf[len], PAGE_SIZE - len, "%8ph\n",
 490                                 fb_info->bl_curve + i);
 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