drivers/video/rockchip/rkfb_sysfs.c

   1 /*
   2  * linux/drivers/video/rockchip/rkfb-sysfs.c
   3  *
   4  * Copyright (C) 2012 Rockchip Corporation
   5  * Author: yxj<yxj@rock-chips.com>
   6  *
   7  * Some code and ideas taken from
   8  *drivers/video/omap2/omapfb/omapfb-sys.c
   9  *driver by Tomi Valkeinen.
  10  *
  11  *
  12  * This program is free software; you can redistribute it and/or modify it
  13  * under the terms of the GNU General Public License version 2 as published by
  14  * the Free Software Foundation.
  15  *
  16  * This program is distributed in the hope that it will be useful, but WITHOUT
  17  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  18  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
  19  * more details.
  20  *
  21  * You should have received a copy of the GNU General Public License along with
  22  * this program.  If not, see <http://www.gnu.org/licenses/>.
  23  */
  24
  25 #include <linux/fb.h>
  26 #include <linux/sysfs.h>
  27 #include <linux/device.h>
  28 #include <linux/uaccess.h>
  29 #include <linux/platform_device.h>
  30 #include <linux/kernel.h>
  31 #include <linux/mm.h>
  32 #include <asm/div64.h>
  33 #include <linux/rk_screen.h>
  34 #include <linux/rk_fb.h>
  35
  36 static ssize_t show_screen_info(struct device *dev,
  37                                 struct device_attribute *attr, char *buf)
  38 {
  39         struct fb_info *fbi = dev_get_drvdata(dev);
  40         struct rk_fb_par *fb_par = (struct rk_fb_par *)fbi->par;
  41         struct rk_lcdc_driver *dev_drv = fb_par->lcdc_drv;
  42         struct rk_screen *screen = dev_drv->cur_screen;
  43         int fps = 0;
  44         u32 x = screen->mode.left_margin + screen->mode.right_margin +
  45                 screen->mode.xres + screen->mode.hsync_len;
  46         u32 y = screen->mode.upper_margin + screen->mode.lower_margin +
  47                 screen->mode.yres + screen->mode.vsync_len;
  48         u64 ft = (u64)x * y * (dev_drv->pixclock);
  49
  50         if (ft > 0)
  51                 fps = div64_u64(1000000000000llu, ft);
  52         return snprintf(buf, PAGE_SIZE, "xres:%d\nyres:%d\nfps:%d\n",
  53                         screen->mode.xres, screen->mode.yres, fps);
  54 }
  55
  56 static ssize_t show_disp_info(struct device *dev,
  57                               struct device_attribute *attr, char *buf)
  58 {
  59         struct fb_info *fbi = dev_get_drvdata(dev);
  60         struct rk_fb_par *fb_par = (struct rk_fb_par *)fbi->par;
  61         struct rk_lcdc_driver *dev_drv = fb_par->lcdc_drv;
  62         int win_id = dev_drv->ops->fb_get_win_id(dev_drv, fbi->fix.id);
  63
  64         if (dev_drv->ops->get_disp_info)
  65                 return dev_drv->ops->get_disp_info(dev_drv, buf, win_id);
  66
  67         return 0;
  68 }
  69
  70 static ssize_t show_phys(struct device *dev,
  71                          struct device_attribute *attr, char *buf)
  72 {
  73         struct fb_info *fbi = dev_get_drvdata(dev);
  74
  75         return snprintf(buf, PAGE_SIZE, "0x%lx-----0x%x\n",
  76                         fbi->fix.smem_start, fbi->fix.smem_len);
  77 }
  78
  79 static ssize_t show_virt(struct device *dev,
  80                          struct device_attribute *attr, char *buf)
  81 {
  82         struct fb_info *fbi = dev_get_drvdata(dev);
  83
  84         return snprintf(buf, PAGE_SIZE, "0x%p-----0x%x\n",
  85                         fbi->screen_base, fbi->fix.smem_len);
  86 }
  87
  88 static ssize_t show_fb_state(struct device *dev,
  89                              struct device_attribute *attr, char *buf)
  90 {
  91         struct fb_info *fbi = dev_get_drvdata(dev);
  92         struct rk_fb_par *fb_par = (struct rk_fb_par *)fbi->par;
  93         struct rk_lcdc_driver *dev_drv = fb_par->lcdc_drv;
  94
  95         int win_id = dev_drv->ops->fb_get_win_id(dev_drv, fbi->fix.id);
  96         int state = dev_drv->ops->get_win_state(dev_drv, win_id);
  97
  98         return snprintf(buf, PAGE_SIZE, "%s\n", state ? "enabled" : "disabled");
  99 }
 100
 101 static ssize_t show_dual_mode(struct device *dev,
 102                               struct device_attribute *attr, char *buf)
 103 {
 104         struct fb_info *fbi = dev_get_drvdata(dev);
 105         struct rk_fb *rk_fb = dev_get_drvdata(fbi->device);
 106         int mode = rk_fb->disp_mode;
 107
 108         return snprintf(buf, PAGE_SIZE, "%d\n", mode);
 109 }
 110
 111 static ssize_t set_fb_state(struct device *dev, struct device_attribute *attr,
 112                             const char *buf, size_t count)
 113 {
 114         struct fb_info *fbi = dev_get_drvdata(dev);
 115         struct rk_fb_par *fb_par = (struct rk_fb_par *)fbi->par;
 116         struct rk_lcdc_driver *dev_drv = fb_par->lcdc_drv;
 117         int win_id = dev_drv->ops->fb_get_win_id(dev_drv, fbi->fix.id);
 118         int state;
 119         int ret;
 120
 121         ret = kstrtoint(buf, 0, &state);
 122         if (ret)
 123                 return ret;
 124         dev_drv->ops->open(dev_drv, win_id, state);
 125         if (state) {
 126                 dev_drv->ops->set_par(dev_drv, win_id);
 127                 dev_drv->ops->pan_display(dev_drv, win_id);
 128                 dev_drv->ops->cfg_done(dev_drv);
 129         }
 130         return count;
 131 }
 132
 133 static ssize_t show_overlay(struct device *dev,
 134                             struct device_attribute *attr, char *buf)
 135 {
 136         struct fb_info *fbi = dev_get_drvdata(dev);
 137         struct rk_fb_par *fb_par = (struct rk_fb_par *)fbi->par;
 138         struct rk_lcdc_driver *dev_drv = fb_par->lcdc_drv;
 139         int ovl;
 140
 141         if (dev_drv->ops->ovl_mgr)
 142                 ovl = dev_drv->ops->ovl_mgr(dev_drv, 0, 0);
 143
 144         if (ovl < 0)
 145                 return ovl;
 146
 147         return snprintf(buf, PAGE_SIZE, "%s\n",
 148                         ovl ? "win0 on the top of win1" :
 149                         "win1 on the top of win0");
 150 }
 151
 152 static ssize_t set_overlay(struct device *dev, struct device_attribute *attr,
 153                            const char *buf, size_t count)
 154 {
 155         struct fb_info *fbi = dev_get_drvdata(dev);
 156         struct rk_fb_par *fb_par = (struct rk_fb_par *)fbi->par;
 157         struct rk_lcdc_driver *dev_drv = fb_par->lcdc_drv;
 158         u32 ovl;
 159         int ret;
 160
 161         ret = kstrtou32(buf, 0, &ovl);
 162         if (ret)
 163                 return ret;
 164         if (dev_drv->ops->ovl_mgr)
 165                 ret = dev_drv->ops->ovl_mgr(dev_drv, ovl, 1);
 166         if (ret < 0)
 167                 return ret;
 168
 169         return count;
 170 }
 171
 172 static ssize_t show_fps(struct device *dev,
 173                         struct device_attribute *attr, char *buf)
 174 {
 175         struct fb_info *fbi = dev_get_drvdata(dev);
 176         struct rk_fb_par *fb_par = (struct rk_fb_par *)fbi->par;
 177         struct rk_lcdc_driver *dev_drv = fb_par->lcdc_drv;
 178         int fps;
 179
 180         if (dev_drv->ops->fps_mgr)
 181                 fps = dev_drv->ops->fps_mgr(dev_drv, 0, 0);
 182         if (fps < 0)
 183                 return fps;
 184
 185         return snprintf(buf, PAGE_SIZE, "fps:%d\n", fps);
 186 }
 187
 188 static ssize_t set_fps(struct device *dev, struct device_attribute *attr,
 189                        const char *buf, size_t count)
 190 {
 191         struct fb_info *fbi = dev_get_drvdata(dev);
 192         struct rk_fb_par *fb_par = (struct rk_fb_par *)fbi->par;
 193         struct rk_lcdc_driver *dev_drv = fb_par->lcdc_drv;
 194         u32 fps;
 195         int ret;
 196
 197         ret = kstrtou32(buf, 0, &fps);
 198         if (ret)
 199                 return ret;
 200
 201         if (fps == 0 || fps > 60) {
 202                 dev_info(dev, "unsupport fps value,pelase set 1~60\n");
 203                 return count;
 204         }
 205
 206         if (dev_drv->ops->fps_mgr)
 207                 ret = dev_drv->ops->fps_mgr(dev_drv, fps, 1);
 208         if (ret < 0)
 209                 return ret;
 210
 211         return count;
 212 }
 213
 214 static ssize_t show_fb_win_map(struct device *dev,
 215                                struct device_attribute *attr, char *buf)
 216 {
 217         int ret;
 218         struct fb_info *fbi = dev_get_drvdata(dev);
 219         struct rk_fb_par *fb_par = (struct rk_fb_par *)fbi->par;
 220         struct rk_lcdc_driver *dev_drv = fb_par->lcdc_drv;
 221
 222         mutex_lock(&dev_drv->fb_win_id_mutex);
 223         ret =
 224             snprintf(buf, PAGE_SIZE, "fb0:win%d\nfb1:win%d\nfb2:win%d\n",
 225                      dev_drv->fb0_win_id, dev_drv->fb1_win_id,
 226                      dev_drv->fb2_win_id);
 227         mutex_unlock(&dev_drv->fb_win_id_mutex);
 228
 229         return ret;
 230 }
 231
 232 static ssize_t set_fb_win_map(struct device *dev, struct device_attribute *attr,
 233                               const char *buf, size_t count)
 234 {
 235         struct fb_info *fbi = dev_get_drvdata(dev);
 236         struct rk_fb_par *fb_par = (struct rk_fb_par *)fbi->par;
 237         struct rk_lcdc_driver *dev_drv = fb_par->lcdc_drv;
 238         u32 order;
 239         int ret;
 240
 241         ret = kstrtou32(buf, 0, &order);
 242         if ((order != FB0_WIN2_FB1_WIN1_FB2_WIN0) &&
 243             (order != FB0_WIN1_FB1_WIN2_FB2_WIN0) &&
 244             (order != FB0_WIN2_FB1_WIN0_FB2_WIN1) &&
 245             (order != FB0_WIN0_FB1_WIN2_FB2_WIN1) &&
 246             (order != FB0_WIN0_FB1_WIN1_FB2_WIN2) &&
 247             (order != FB0_WIN1_FB1_WIN0_FB2_WIN2)) {
 248                 dev_info(dev, "un supported map\n"
 249                        "you can use the following order:\n" "201:\n"
 250                        "fb0-win1\n" "fb1-win0\n" "fb2-win2\n" "210:\n"
 251                        "fb0-win0\n" "fb1-win1\n" "fb2-win2\n" "120:\n"
 252                        "fb0-win0\n" "fb1-win2\n" "fb2-win1\n" "102:\n"
 253                        "fb0-win2\n" "fb1-win0\n" "fb2-win1\n" "021:\n"
 254                        "fb0-win1\n" "fb1-win2\n" "fb2-win0\n" "012:\n"
 255                        "fb0-win2\n" "fb1-win1\n" "fb2-win0\n");
 256                 return count;
 257         } else {
 258                 if (dev_drv->ops->fb_win_remap)
 259                         dev_drv->ops->fb_win_remap(dev_drv, order);
 260         }
 261
 262         return count;
 263 }
 264
 265 static ssize_t show_hwc_lut(struct device *dev,
 266                             struct device_attribute *attr, char *buf)
 267 {
 268         return 0;
 269 }
 270
 271 static ssize_t set_hwc_lut(struct device *dev, struct device_attribute *attr,
 272                            const char *buf, size_t count)
 273 {
 274         int hwc_lut[256];
 275         const char *start = buf;
 276         int i = 256, temp;
 277         int space_max;
 278
 279         struct fb_info *fbi = dev_get_drvdata(dev);
 280         struct rk_fb_par *fb_par = (struct rk_fb_par *)fbi->par;
 281         struct rk_lcdc_driver *dev_drv = fb_par->lcdc_drv;
 282
 283         /*printk("count:%d\n>>%s\n\n",count,start);*/
 284         for (i = 0; i < 256; i++) {
 285                 space_max = 15; /*max space number 15*/
 286                 temp = simple_strtoul(start, NULL, 16);
 287                 hwc_lut[i] = temp;
 288                 do {
 289                         start++;
 290                         space_max--;
 291                 } while ((*start != ' ') && space_max);
 292
 293                 if (!space_max)
 294                         break;
 295                 else
 296                         start++;
 297         }
 298 #if 0
 299         for (i = 0; i < 16; i++) {
 300                 for (j = 0; j < 16; j++)
 301                         printk("0x%08x ", hwc_lut[i * 16 + j]);
 302                 printk("\n");
 303         }
 304 #endif
 305         if (dev_drv->ops->set_hwc_lut)
 306                 dev_drv->ops->set_hwc_lut(dev_drv, hwc_lut, 1);
 307
 308         return count;
 309 }
 310
 311 static ssize_t show_dsp_lut(struct device *dev,
 312                             struct device_attribute *attr, char *buf)
 313 {
 314         return 0;
 315 }
 316
 317 static ssize_t set_dsp_lut(struct device *dev, struct device_attribute *attr,
 318                            const char *buf, size_t count)
 319 {
 320         int dsp_lut[256];
 321         const char *start = buf;
 322         int i = 256, temp;
 323         int space_max = 10;
 324
 325         struct fb_info *fbi = dev_get_drvdata(dev);
 326         struct rk_fb_par *fb_par = (struct rk_fb_par *)fbi->par;
 327         struct rk_lcdc_driver *dev_drv = fb_par->lcdc_drv;
 328
 329         for (i = 0; i < 256; i++) {
 330                 temp = i;
 331                 /*init by default value*/
 332                 dsp_lut[i] = temp + (temp << 8) + (temp << 16);
 333         }
 334         /*printk("count:%d\n>>%s\n\n",count,start);*/
 335         for (i = 0; i < 256; i++) {
 336                 space_max = 10; /*max space number 10*/
 337                 temp = simple_strtoul(start, NULL, 10);
 338                 dsp_lut[i] = temp;
 339                 do {
 340                         start++;
 341                         space_max--;
 342                 } while ((*start != ' ') && space_max);
 343
 344                 if (!space_max)
 345                         break;
 346                 else
 347                         start++;
 348         }
 349 #if 0
 350         for (i = 0; i < 16; i++) {
 351                 for (j = 0; j < 16; j++)
 352                         printk("0x%08x ", dsp_lut[i * 16 + j]);
 353                 printk("\n");
 354         }
 355 #endif
 356         if (dev_drv->ops->set_dsp_lut)
 357                 dev_drv->ops->set_dsp_lut(dev_drv, dsp_lut);
 358
 359         return count;
 360 }
 361
 362 static ssize_t show_dsp_cabc(struct device *dev,
 363                              struct device_attribute *attr, char *buf)
 364 {
 365         struct fb_info *fbi = dev_get_drvdata(dev);
 366         struct rk_fb_par *fb_par = (struct rk_fb_par *)fbi->par;
 367         struct rk_lcdc_driver *dev_drv = fb_par->lcdc_drv;
 368
 369         return snprintf(buf, PAGE_SIZE, "cabc mode=%d\n",
 370                 dev_drv->cabc_mode);
 371         return 0;
 372 }
 373
 374 static ssize_t set_dsp_cabc(struct device *dev, struct device_attribute *attr,
 375                             const char *buf, size_t count)
 376 {
 377         struct fb_info *fbi = dev_get_drvdata(dev);
 378         struct rk_fb_par *fb_par = (struct rk_fb_par *)fbi->par;
 379         struct rk_lcdc_driver *dev_drv = fb_par->lcdc_drv;
 380         int ret, mode = 0;
 381
 382         ret = kstrtoint(buf, 0, &mode);
 383         if (ret)
 384                 return ret;
 385
 386         if (dev_drv->ops->set_dsp_cabc)
 387                 ret = dev_drv->ops->set_dsp_cabc(dev_drv, mode);
 388         if (ret < 0)
 389                 return ret;
 390
 391         return count;
 392 }
 393
 394 static ssize_t show_dsp_bcsh(struct device *dev,
 395                              struct device_attribute *attr, char *buf)
 396 {
 397         struct fb_info *fbi = dev_get_drvdata(dev);
 398         struct rk_fb_par *fb_par = (struct rk_fb_par *)fbi->par;
 399         struct rk_lcdc_driver *dev_drv = fb_par->lcdc_drv;
 400         int brightness, contrast, sat_con, sin_hue, cos_hue;
 401
 402         if (dev_drv->ops->get_dsp_bcsh_bcs) {
 403                 brightness = dev_drv->ops->get_dsp_bcsh_bcs(dev_drv,
 404                                                             BRIGHTNESS);
 405                 contrast = dev_drv->ops->get_dsp_bcsh_bcs(dev_drv, CONTRAST);
 406                 sat_con = dev_drv->ops->get_dsp_bcsh_bcs(dev_drv, SAT_CON);
 407         }
 408         if (dev_drv->ops->get_dsp_bcsh_hue) {
 409                 sin_hue = dev_drv->ops->get_dsp_bcsh_hue(dev_drv, H_SIN);
 410                 cos_hue = dev_drv->ops->get_dsp_bcsh_hue(dev_drv, H_COS);
 411         }
 412         return snprintf(buf, PAGE_SIZE,
 413                         "brightness:%4d,contrast:%4d,sat_con:%4d,"
 414                         "sin_hue:%4d,cos_hue:%4d\n",
 415                         brightness, contrast, sat_con, sin_hue, cos_hue);
 416 }
 417
 418 static ssize_t set_dsp_bcsh(struct device *dev, struct device_attribute *attr,
 419                             const char *buf, size_t count)
 420 {
 421         struct fb_info *fbi = dev_get_drvdata(dev);
 422         struct rk_fb_par *fb_par = (struct rk_fb_par *)fbi->par;
 423         struct rk_lcdc_driver *dev_drv = fb_par->lcdc_drv;
 424         int brightness, contrast, sat_con, ret = 0, sin_hue, cos_hue;
 425
 426         if (!strncmp(buf, "open", 4)) {
 427                 if (dev_drv->ops->open_bcsh)
 428                         ret = dev_drv->ops->open_bcsh(dev_drv, 1);
 429                 else
 430                         ret = -1;
 431         } else if (!strncmp(buf, "close", 5)) {
 432                 if (dev_drv->ops->open_bcsh)
 433                         ret = dev_drv->ops->open_bcsh(dev_drv, 0);
 434                 else
 435                         ret = -1;
 436         } else if (!strncmp(buf, "brightness", 10)) {
 437                 sscanf(buf, "brightness %d", &brightness);
 438                 if (unlikely(brightness > 255)) {
 439                         dev_err(fbi->dev,
 440                                 "brightness should be [0:255],now=%d\n\n",
 441                                 brightness);
 442                         brightness = 255;
 443                 }
 444                 if (dev_drv->ops->set_dsp_bcsh_bcs)
 445                         ret = dev_drv->ops->set_dsp_bcsh_bcs(dev_drv,
 446                                                              BRIGHTNESS,
 447                                                              brightness);
 448                 else
 449                         ret = -1;
 450         } else if (!strncmp(buf, "contrast", 8)) {
 451                 sscanf(buf, "contrast %d", &contrast);
 452                 if (unlikely(contrast > 510)) {
 453                         dev_err(fbi->dev,
 454                                 "contrast should be [0:510],now=%d\n",
 455                                 contrast);
 456                         contrast = 510;
 457                 }
 458                 if (dev_drv->ops->set_dsp_bcsh_bcs)
 459                         ret = dev_drv->ops->set_dsp_bcsh_bcs(dev_drv,
 460                                                              CONTRAST,
 461                                                              contrast);
 462                 else
 463                         ret = -1;
 464         } else if (!strncmp(buf, "sat_con", 7)) {
 465                 sscanf(buf, "sat_con %d", &sat_con);
 466                 if (unlikely(sat_con > 1015)) {
 467                         dev_err(fbi->dev,
 468                                 "sat_con should be [0:1015],now=%d\n",
 469                                 sat_con);
 470                         sat_con = 1015;
 471                 }
 472                 if (dev_drv->ops->set_dsp_bcsh_bcs)
 473                         ret = dev_drv->ops->set_dsp_bcsh_bcs(dev_drv,
 474                                                              SAT_CON,
 475                                                              sat_con);
 476                 else
 477                         ret = -1;
 478         } else if (!strncmp(buf, "hue", 3)) {
 479                 sscanf(buf, "hue %d %d", &sin_hue, &cos_hue);
 480                 if (unlikely(sin_hue > 511 || cos_hue > 511)) {
 481                         dev_err(fbi->dev, "sin_hue=%d,cos_hue=%d\n",
 482                                 sin_hue, cos_hue);
 483                 }
 484                 if (dev_drv->ops->set_dsp_bcsh_hue)
 485                         ret = dev_drv->ops->set_dsp_bcsh_hue(dev_drv,
 486                                                              sin_hue,
 487                                                              cos_hue);
 488                 else
 489                         ret = -1;
 490         } else {
 491                 dev_info(dev, "format error\n");
 492         }
 493
 494         if (ret < 0)
 495                 return ret;
 496
 497         return count;
 498 }
 499
 500 static ssize_t show_scale(struct device *dev,
 501                           struct device_attribute *attr, char *buf)
 502 {
 503         struct fb_info *fbi = dev_get_drvdata(dev);
 504         struct rk_fb_par *fb_par = (struct rk_fb_par *)fbi->par;
 505         struct rk_lcdc_driver *dev_drv = fb_par->lcdc_drv;
 506         struct rk_screen *screen = dev_drv->cur_screen;
 507
 508         return snprintf(buf, PAGE_SIZE,
 509                 "xscale=%d yscale=%d\nleft=%d top=%d right=%d bottom=%d\n",
 510                 (screen->overscan.left + screen->overscan.right)/2,
 511                 (screen->overscan.top + screen->overscan.bottom)/2,
 512                 screen->overscan.left, screen->overscan.top,
 513                 screen->overscan.right, screen->overscan.bottom);
 514 }
 515
 516 static ssize_t set_scale(struct device *dev, struct device_attribute *attr,
 517                          const char *buf, size_t count)
 518 {
 519         struct fb_info *fbi = dev_get_drvdata(dev);
 520         struct rk_fb_par *fb_par = (struct rk_fb_par *)fbi->par;
 521         struct rk_lcdc_driver *dev_drv = fb_par->lcdc_drv;
 522         struct rk_screen *screen = dev_drv->cur_screen;
 523         u32 left, top, right, bottom;
 524
 525         if (!strncmp(buf, "overscan", 8)) {
 526                 sscanf(buf,
 527                        "overscan %d,%d,%d,%d", &left, &top, &right, &bottom);
 528                 if (left > 0 && left <= 100)
 529                         screen->overscan.left = left;
 530                 if (top > 0 && top <= 100)
 531                         screen->overscan.top = top;
 532                 if (right > 0 && right <= 100)
 533                         screen->overscan.right = right;
 534                 if (bottom > 0 && bottom <= 100)
 535                         screen->overscan.bottom = bottom;
 536         } else if (!strncmp(buf, "left", 4)) {
 537                 sscanf(buf, "left=%d", &left);
 538                 if (left > 0 && left <= 100)
 539                         screen->overscan.left = left;
 540         } else if (!strncmp(buf, "top", 3)) {
 541                 sscanf(buf, "top=%d", &top);
 542                 if (top > 0 && top <= 100)
 543                         screen->overscan.top = top;
 544         } else if (!strncmp(buf, "right", 5)) {
 545                 sscanf(buf, "right=%d", &right);
 546                 if (right > 0 && right <= 100)
 547                         screen->overscan.right = right;
 548         } else if (!strncmp(buf, "bottom", 6)) {
 549                 sscanf(buf, "bottom=%d", &bottom);
 550                 if (bottom > 0 && bottom <= 100)
 551                         screen->overscan.bottom = bottom;
 552         } else if (!strncmp(buf, "xscale", 6)) {
 553                 sscanf(buf, "xscale=%d", &left);
 554                 if (left > 0 && left <= 100) {
 555                         screen->overscan.left = left;
 556                         screen->overscan.right = left;
 557                 }
 558         } else if (!strncmp(buf, "yscale", 6)) {
 559                 sscanf(buf, "yscale=%d", &left);
 560                 if (left > 0 && left <= 100) {
 561                         screen->overscan.top = left;
 562                         screen->overscan.bottom = left;
 563                 }
 564         } else {
 565                 sscanf(buf, "%d", &left);
 566                 if (left > 0 && left <= 100) {
 567                         screen->overscan.left = left;
 568                         screen->overscan.right = left;
 569                         screen->overscan.top = left;
 570                         screen->overscan.bottom = left;
 571                 }
 572         }
 573
 574         if (dev_drv->ops->set_overscan)
 575                 dev_drv->ops->set_overscan(dev_drv, &screen->overscan);
 576
 577         return count;
 578 }
 579
 580 static struct device_attribute rkfb_attrs[] = {
 581         __ATTR(phys_addr, S_IRUGO, show_phys, NULL),
 582         __ATTR(virt_addr, S_IRUGO, show_virt, NULL),
 583         __ATTR(disp_info, S_IRUGO, show_disp_info, NULL),
 584         __ATTR(screen_info, S_IRUGO, show_screen_info, NULL),
 585         __ATTR(dual_mode, S_IRUGO, show_dual_mode, NULL),
 586         __ATTR(enable, S_IRUGO | S_IWUSR, show_fb_state, set_fb_state),
 587         __ATTR(overlay, S_IRUGO | S_IWUSR, show_overlay, set_overlay),
 588         __ATTR(fps, S_IRUGO | S_IWUSR, show_fps, set_fps),
 589         __ATTR(map, S_IRUGO | S_IWUSR, show_fb_win_map, set_fb_win_map),
 590         __ATTR(dsp_lut, S_IRUGO | S_IWUSR, show_dsp_lut, set_dsp_lut),
 591         __ATTR(hwc_lut, S_IRUGO | S_IWUSR, show_hwc_lut, set_hwc_lut),
 592         __ATTR(cabc, S_IRUGO | S_IWUSR, show_dsp_cabc, set_dsp_cabc),
 593         __ATTR(bcsh, S_IRUGO | S_IWUSR, show_dsp_bcsh, set_dsp_bcsh),
 594         __ATTR(scale, S_IRUGO | S_IWUSR, show_scale, set_scale),
 595 };
 596
 597 int rkfb_create_sysfs(struct fb_info *fbi)
 598 {
 599         int r, t;
 600
 601         for (t = 0; t < ARRAY_SIZE(rkfb_attrs); t++) {
 602                 r = device_create_file(fbi->dev, &rkfb_attrs[t]);
 603                 if (r) {
 604                         dev_err(fbi->dev, "failed to create sysfs " "file\n");
 605                         return r;
 606                 }
 607         }
 608
 609         return 0;
 610 }
 611
 612 void rkfb_remove_sysfs(struct rk_fb *rk_fb)
 613 {
 614         int i, t;
 615
 616         for (i = 0; i < rk_fb->num_fb; i++) {
 617                 for (t = 0; t < ARRAY_SIZE(rkfb_attrs); t++)
 618                         device_remove_file(rk_fb->fb[i]->dev, &rkfb_attrs[t]);
 619         }
 620 }