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