linux/drivers/video/fbsysfs.c
<<
>>
Prefs
   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 */
  39struct 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}
  70EXPORT_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 */
  81void framebuffer_release(struct fb_info *info)
  82{
  83        if (!info)
  84                return;
  85        kfree(info->apertures);
  86        kfree(info);
  87}
  88EXPORT_SYMBOL(framebuffer_release);
  89
  90static 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
 105static 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
 127static 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
 158static 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
 169static 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
 198static 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
 216static 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
 231static 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
 238static 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
 257static 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
 265static 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
 286static 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
 294static 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
 301static 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
 319static 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
 326static 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
 334static 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
 341static 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
 349static 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
 356static 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
 381static 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
 389static 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
 397static 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
 417static 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
 425static 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
 466static 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 */
 500static 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
 518int 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
 542void 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 */
 561void 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}
 578EXPORT_SYMBOL_GPL(fb_bl_default_curve);
 579#endif
 580
lxr.linux.no kindly hosted by Redpill Linpro AS, provider of Linux consulting and operations services since 1995.