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 <linux/vmalloc.h>
  33 #include <asm/div64.h>
  34 #include <linux/rk_screen.h>
  35 #include <linux/rk_fb.h>
  36 #if defined(CONFIG_ION_ROCKCHIP)
  37 #include <linux/rockchip_ion.h>
  38 #endif
  39 #include "bmp_helper.h"
  40
  41 static char *get_format_str(enum data_format format)
  42 {
  43         switch (format) {
  44         case ARGB888:
  45                 return "ARGB888";
  46         case RGB888:
  47                 return "RGB888";
  48         case RGB565:
  49                 return "RGB565";
  50         case YUV420:
  51                 return "YUV420";
  52         case YUV422:
  53                 return "YUV422";
  54         case YUV444:
  55                 return "YUV444";
  56         case YUV420_A:
  57                 return "YUV420_A";
  58         case YUV422_A:
  59                 return "YUV422_A";
  60         case YUV444_A:
  61                 return "YUV444_A";
  62         case XRGB888:
  63                 return "XRGB888";
  64         case XBGR888:
  65                 return "XBGR888";
  66         case ABGR888:
  67                 return "ABGR888";
  68         }
  69
  70         return "invalid";
  71 }
  72
  73 static ssize_t show_screen_info(struct device *dev,
  74                                 struct device_attribute *attr, char *buf)
  75 {
  76         struct fb_info *fbi = dev_get_drvdata(dev);
  77         struct rk_fb_par *fb_par = (struct rk_fb_par *)fbi->par;
  78         struct rk_lcdc_driver *dev_drv = fb_par->lcdc_drv;
  79         struct rk_screen *screen = dev_drv->cur_screen;
  80         int fps = 0;
  81         u32 x = screen->mode.left_margin + screen->mode.right_margin +
  82                 screen->mode.xres + screen->mode.hsync_len;
  83         u32 y = screen->mode.upper_margin + screen->mode.lower_margin +
  84                 screen->mode.yres + screen->mode.vsync_len;
  85         u64 ft = (u64)x * y * (dev_drv->pixclock);
  86
  87         if (ft > 0)
  88                 fps = div64_u64(1000000000000llu, ft);
  89         return snprintf(buf, PAGE_SIZE, "xres:%d\nyres:%d\nfps:%d\n",
  90                         screen->mode.xres, screen->mode.yres, fps);
  91 }
  92
  93 static ssize_t show_disp_info(struct device *dev,
  94                               struct device_attribute *attr, char *buf)
  95 {
  96         struct fb_info *fbi = dev_get_drvdata(dev);
  97         struct rk_fb_par *fb_par = (struct rk_fb_par *)fbi->par;
  98         struct rk_lcdc_driver *dev_drv = fb_par->lcdc_drv;
  99         int win_id = dev_drv->ops->fb_get_win_id(dev_drv, fbi->fix.id);
 100
 101         if (dev_drv->ops->get_disp_info)
 102                 return dev_drv->ops->get_disp_info(dev_drv, buf, win_id);
 103
 104         return 0;
 105 }
 106
 107 static void fill_buffer(void *handle, void *vaddr, int size)
 108 {
 109         struct file *filp = handle;
 110
 111         if (filp)
 112                 vfs_write(filp, vaddr, size, &filp->f_pos);
 113 }
 114
 115 static int dump_win(struct rk_fb *rk_fb, struct rk_fb_reg_area_data *area_data,
 116                     u8 data_format, int win_id, int area_id, bool is_bmp)
 117 {
 118         void __iomem *vaddr;
 119         struct file *filp;
 120         mm_segment_t old_fs;
 121         char name[100];
 122         struct ion_handle *ion_handle = area_data->ion_handle;
 123         int width = area_data->xvir;
 124         int height = area_data->yvir;
 125
 126         if (ion_handle) {
 127                 vaddr = ion_map_kernel(rk_fb->ion_client, ion_handle);
 128         } else if (area_data->smem_start && area_data->smem_start != -1) {
 129                 unsigned long start;
 130                 unsigned int nr_pages;
 131                 struct page **pages;
 132                 int i = 0;
 133
 134                 start = area_data->smem_start;
 135                 nr_pages = width * height * 3 / 2 / PAGE_SIZE;
 136                 pages = kzalloc(sizeof(struct page) * nr_pages,GFP_KERNEL);
 137                 while (i < nr_pages) {
 138                         pages[i] = phys_to_page(start);
 139                         start += PAGE_SIZE;
 140                         i++;
 141                 }
 142                 vaddr = vmap(pages, nr_pages, VM_MAP, pgprot_writecombine(PAGE_KERNEL));
 143         } else {
 144                 return -1;
 145         }
 146
 147         snprintf(name, 100, "/data/win%d_%d_%dx%d_%s.%s", win_id, area_id,
 148                  width, height, get_format_str(data_format),
 149                  is_bmp ? "bmp" : "bin");
 150
 151         pr_info("dump win == > /data/win%d_%d_%dx%d_%s.%s\n", win_id, area_id,
 152                 width, height, get_format_str(data_format),
 153                 is_bmp ? "bmp" : "bin");
 154
 155         filp = filp_open(name, O_RDWR | O_CREAT, 0x664);
 156         if (!filp)
 157                 printk("fail to create %s\n", name);
 158
 159         old_fs = get_fs();
 160         set_fs(KERNEL_DS);
 161
 162         if (is_bmp)
 163                 datatobmp(vaddr, width, height, data_format, filp, fill_buffer);
 164         else
 165                 fill_buffer(filp, vaddr, width * height * 4);
 166
 167         set_fs(old_fs);
 168
 169         if (ion_handle) {
 170                 ion_unmap_kernel(rk_fb->ion_client, ion_handle);
 171
 172                 ion_handle_put(ion_handle);
 173         }
 174
 175         filp_close(filp, NULL);
 176
 177         return 0;
 178 }
 179
 180 static ssize_t set_dump_info(struct device *dev, struct device_attribute *attr,
 181                              const char *buf, size_t count)
 182
 183 {
 184         struct fb_info *fbi = dev_get_drvdata(dev);
 185         struct rk_fb_par *fb_par = (struct rk_fb_par *)fbi->par;
 186         struct rk_lcdc_driver *dev_drv = fb_par->lcdc_drv;
 187         struct rk_fb *rk_fb = dev_get_drvdata(fbi->device);
 188         struct rk_fb_reg_data *front_regs;
 189         struct rk_fb_reg_win_data *win_data;
 190         struct rk_fb_reg_area_data *area_data;
 191         bool is_img;
 192         int i, j;
 193
 194         if (!rk_fb->ion_client)
 195                 return 0;
 196
 197         front_regs = kmalloc(sizeof(*front_regs), GFP_KERNEL);
 198         if (!front_regs)
 199                 return -ENOMEM;
 200
 201         mutex_lock(&dev_drv->front_lock);
 202
 203         if (!dev_drv->front_regs) {
 204                 mutex_unlock(&dev_drv->front_lock);
 205                 return 0;
 206         }
 207         memcpy(front_regs, dev_drv->front_regs, sizeof(*front_regs));
 208         for (i = 0; i < front_regs->win_num; i++) {
 209                 for (j = 0; j < RK_WIN_MAX_AREA; j++) {
 210                         win_data = &front_regs->reg_win_data[i];
 211                         area_data = &win_data->reg_area_data[j];
 212                         if (area_data->ion_handle) {
 213                                 ion_handle_get(area_data->ion_handle);
 214                         }
 215                 }
 216         }
 217         mutex_unlock(&dev_drv->front_lock);
 218
 219         if (strncmp(buf, "bin", 3))
 220                 is_img = true;
 221         else
 222                 is_img = false;
 223
 224         for (i = 0; i < front_regs->win_num; i++) {
 225                 for (j = 0; j < RK_WIN_MAX_AREA; j++) {
 226                         win_data = &front_regs->reg_win_data[i];
 227                         if (dump_win(rk_fb, &win_data->reg_area_data[j],
 228                                      win_data->data_format, i, j, is_img))
 229                                 continue;
 230                 }
 231         }
 232         kfree(front_regs);
 233
 234         return count;
 235 }
 236
 237 static ssize_t show_phys(struct device *dev,
 238                          struct device_attribute *attr, char *buf)
 239 {
 240         struct fb_info *fbi = dev_get_drvdata(dev);
 241
 242         return snprintf(buf, PAGE_SIZE, "0x%lx-----0x%x\n",
 243                         fbi->fix.smem_start, fbi->fix.smem_len);
 244 }
 245
 246 static ssize_t show_virt(struct device *dev,
 247                          struct device_attribute *attr, char *buf)
 248 {
 249         struct fb_info *fbi = dev_get_drvdata(dev);
 250
 251         return snprintf(buf, PAGE_SIZE, "0x%p-----0x%x\n",
 252                         fbi->screen_base, fbi->fix.smem_len);
 253 }
 254
 255 static ssize_t show_fb_state(struct device *dev,
 256                              struct device_attribute *attr, char *buf)
 257 {
 258         struct fb_info *fbi = dev_get_drvdata(dev);
 259         struct rk_fb_par *fb_par = (struct rk_fb_par *)fbi->par;
 260         struct rk_lcdc_driver *dev_drv = fb_par->lcdc_drv;
 261
 262         int win_id = dev_drv->ops->fb_get_win_id(dev_drv, fbi->fix.id);
 263         int state = dev_drv->ops->get_win_state(dev_drv, win_id);
 264
 265         return snprintf(buf, PAGE_SIZE, "%s\n", state ? "enabled" : "disabled");
 266 }
 267
 268 static ssize_t show_dual_mode(struct device *dev,
 269                               struct device_attribute *attr, char *buf)
 270 {
 271         struct fb_info *fbi = dev_get_drvdata(dev);
 272         struct rk_fb *rk_fb = dev_get_drvdata(fbi->device);
 273         int mode = rk_fb->disp_mode;
 274
 275         return snprintf(buf, PAGE_SIZE, "%d\n", mode);
 276 }
 277
 278 static ssize_t set_fb_state(struct device *dev, struct device_attribute *attr,
 279                             const char *buf, size_t count)
 280 {
 281         struct fb_info *fbi = dev_get_drvdata(dev);
 282         struct rk_fb_par *fb_par = (struct rk_fb_par *)fbi->par;
 283         struct rk_lcdc_driver *dev_drv = fb_par->lcdc_drv;
 284         int win_id = dev_drv->ops->fb_get_win_id(dev_drv, fbi->fix.id);
 285         int state;
 286         int ret;
 287
 288         ret = kstrtoint(buf, 0, &state);
 289         if (ret)
 290                 return ret;
 291         dev_drv->ops->open(dev_drv, win_id, state);
 292         if (state) {
 293                 dev_drv->ops->set_par(dev_drv, win_id);
 294                 dev_drv->ops->pan_display(dev_drv, win_id);
 295                 dev_drv->ops->cfg_done(dev_drv);
 296         }
 297         return count;
 298 }
 299
 300 static ssize_t show_overlay(struct device *dev,
 301                             struct device_attribute *attr, char *buf)
 302 {
 303         struct fb_info *fbi = dev_get_drvdata(dev);
 304         struct rk_fb_par *fb_par = (struct rk_fb_par *)fbi->par;
 305         struct rk_lcdc_driver *dev_drv = fb_par->lcdc_drv;
 306         int ovl;
 307
 308         if (dev_drv->ops->ovl_mgr)
 309                 ovl = dev_drv->ops->ovl_mgr(dev_drv, 0, 0);
 310
 311         if (ovl < 0)
 312                 return ovl;
 313
 314         return snprintf(buf, PAGE_SIZE, "%s\n",
 315                         ovl ? "win0 on the top of win1" :
 316                         "win1 on the top of win0");
 317 }
 318
 319 static ssize_t set_overlay(struct device *dev, struct device_attribute *attr,
 320                            const char *buf, size_t count)
 321 {
 322         struct fb_info *fbi = dev_get_drvdata(dev);
 323         struct rk_fb_par *fb_par = (struct rk_fb_par *)fbi->par;
 324         struct rk_lcdc_driver *dev_drv = fb_par->lcdc_drv;
 325         u32 ovl;
 326         int ret;
 327
 328         ret = kstrtou32(buf, 0, &ovl);
 329         if (ret)
 330                 return ret;
 331         if (dev_drv->ops->ovl_mgr)
 332                 ret = dev_drv->ops->ovl_mgr(dev_drv, ovl, 1);
 333         if (ret < 0)
 334                 return ret;
 335
 336         return count;
 337 }
 338
 339 static ssize_t show_fps(struct device *dev,
 340                         struct device_attribute *attr, char *buf)
 341 {
 342         struct fb_info *fbi = dev_get_drvdata(dev);
 343         struct rk_fb_par *fb_par = (struct rk_fb_par *)fbi->par;
 344         struct rk_lcdc_driver *dev_drv = fb_par->lcdc_drv;
 345         int fps;
 346
 347         if (dev_drv->ops->fps_mgr)
 348                 fps = dev_drv->ops->fps_mgr(dev_drv, 0, 0);
 349         if (fps < 0)
 350                 return fps;
 351
 352         return snprintf(buf, PAGE_SIZE, "fps:%d\n", fps);
 353 }
 354
 355 static ssize_t set_fps(struct device *dev, struct device_attribute *attr,
 356                        const char *buf, size_t count)
 357 {
 358         struct fb_info *fbi = dev_get_drvdata(dev);
 359         struct rk_fb_par *fb_par = (struct rk_fb_par *)fbi->par;
 360         struct rk_lcdc_driver *dev_drv = fb_par->lcdc_drv;
 361         u32 fps;
 362         int ret;
 363
 364         ret = kstrtou32(buf, 0, &fps);
 365         if (ret)
 366                 return ret;
 367
 368         if (fps == 0 || fps > 60) {
 369                 dev_info(dev, "unsupport fps value,pelase set 1~60\n");
 370                 return count;
 371         }
 372
 373         if (dev_drv->ops->fps_mgr)
 374                 ret = dev_drv->ops->fps_mgr(dev_drv, fps, 1);
 375         if (ret < 0)
 376                 return ret;
 377
 378         return count;
 379 }
 380
 381 static ssize_t show_fb_win_map(struct device *dev,
 382                                struct device_attribute *attr, char *buf)
 383 {
 384         int ret;
 385         struct fb_info *fbi = dev_get_drvdata(dev);
 386         struct rk_fb_par *fb_par = (struct rk_fb_par *)fbi->par;
 387         struct rk_lcdc_driver *dev_drv = fb_par->lcdc_drv;
 388
 389         mutex_lock(&dev_drv->fb_win_id_mutex);
 390         ret =
 391             snprintf(buf, PAGE_SIZE, "fb0:win%d\nfb1:win%d\nfb2:win%d\n",
 392                      dev_drv->fb0_win_id, dev_drv->fb1_win_id,
 393                      dev_drv->fb2_win_id);
 394         mutex_unlock(&dev_drv->fb_win_id_mutex);
 395
 396         return ret;
 397 }
 398
 399 static ssize_t set_fb_win_map(struct device *dev, struct device_attribute *attr,
 400                               const char *buf, size_t count)
 401 {
 402         struct fb_info *fbi = dev_get_drvdata(dev);
 403         struct rk_fb_par *fb_par = (struct rk_fb_par *)fbi->par;
 404         struct rk_lcdc_driver *dev_drv = fb_par->lcdc_drv;
 405         u32 order;
 406         int ret;
 407
 408         ret = kstrtou32(buf, 0, &order);
 409         if ((order != FB0_WIN2_FB1_WIN1_FB2_WIN0) &&
 410             (order != FB0_WIN1_FB1_WIN2_FB2_WIN0) &&
 411             (order != FB0_WIN2_FB1_WIN0_FB2_WIN1) &&
 412             (order != FB0_WIN0_FB1_WIN2_FB2_WIN1) &&
 413             (order != FB0_WIN0_FB1_WIN1_FB2_WIN2) &&
 414             (order != FB0_WIN1_FB1_WIN0_FB2_WIN2)) {
 415                 dev_info(dev, "un supported map\n"
 416                        "you can use the following order:\n" "201:\n"
 417                        "fb0-win1\n" "fb1-win0\n" "fb2-win2\n" "210:\n"
 418                        "fb0-win0\n" "fb1-win1\n" "fb2-win2\n" "120:\n"
 419                        "fb0-win0\n" "fb1-win2\n" "fb2-win1\n" "102:\n"
 420                        "fb0-win2\n" "fb1-win0\n" "fb2-win1\n" "021:\n"
 421                        "fb0-win1\n" "fb1-win2\n" "fb2-win0\n" "012:\n"
 422                        "fb0-win2\n" "fb1-win1\n" "fb2-win0\n");
 423                 return count;
 424         } else {
 425                 if (dev_drv->ops->fb_win_remap)
 426                         dev_drv->ops->fb_win_remap(dev_drv, order);
 427         }
 428
 429         return count;
 430 }
 431
 432 static ssize_t show_hwc_lut(struct device *dev,
 433                             struct device_attribute *attr, char *buf)
 434 {
 435         return 0;
 436 }
 437
 438 static ssize_t set_hwc_lut(struct device *dev, struct device_attribute *attr,
 439                            const char *buf, size_t count)
 440 {
 441         int hwc_lut[256];
 442         const char *start = buf;
 443         int i = 256, temp;
 444         int space_max;
 445
 446         struct fb_info *fbi = dev_get_drvdata(dev);
 447         struct rk_fb_par *fb_par = (struct rk_fb_par *)fbi->par;
 448         struct rk_lcdc_driver *dev_drv = fb_par->lcdc_drv;
 449
 450         /*printk("count:%d\n>>%s\n\n",count,start);*/
 451         for (i = 0; i < 256; i++) {
 452                 space_max = 15; /*max space number 15*/
 453                 temp = simple_strtoul(start, NULL, 16);
 454                 hwc_lut[i] = temp;
 455                 do {
 456                         start++;
 457                         space_max--;
 458                 } while ((*start != ' ') && space_max);
 459
 460                 if (!space_max)
 461                         break;
 462                 else
 463                         start++;
 464         }
 465 #if 0
 466         for (i = 0; i < 16; i++) {
 467                 for (j = 0; j < 16; j++)
 468                         printk("0x%08x ", hwc_lut[i * 16 + j]);
 469                 printk("\n");
 470         }
 471 #endif
 472         if (dev_drv->ops->set_hwc_lut)
 473                 dev_drv->ops->set_hwc_lut(dev_drv, hwc_lut, 1);
 474
 475         return count;
 476 }
 477
 478 static ssize_t show_dsp_lut(struct device *dev,
 479                             struct device_attribute *attr, char *buf)
 480 {
 481         return 0;
 482 }
 483
 484 static ssize_t set_dsp_lut(struct device *dev, struct device_attribute *attr,
 485                            const char *buf, size_t count)
 486 {
 487         int dsp_lut[256];
 488         const char *start = buf;
 489         int i = 256, temp;
 490         int space_max = 10;
 491
 492         struct fb_info *fbi = dev_get_drvdata(dev);
 493         struct rk_fb_par *fb_par = (struct rk_fb_par *)fbi->par;
 494         struct rk_lcdc_driver *dev_drv = fb_par->lcdc_drv;
 495
 496         for (i = 0; i < 256; i++) {
 497                 temp = i;
 498                 /*init by default value*/
 499                 dsp_lut[i] = temp + (temp << 8) + (temp << 16);
 500         }
 501         /*printk("count:%d\n>>%s\n\n",count,start);*/
 502         for (i = 0; i < 256; i++) {
 503                 space_max = 10; /*max space number 10*/
 504                 temp = simple_strtoul(start, NULL, 10);
 505                 dsp_lut[i] = temp;
 506                 do {
 507                         start++;
 508                         space_max--;
 509                 } while ((*start != ' ') && space_max);
 510
 511                 if (!space_max)
 512                         break;
 513                 else
 514                         start++;
 515         }
 516 #if 0
 517         for (i = 0; i < 16; i++) {
 518                 for (j = 0; j < 16; j++)
 519                         printk("0x%08x ", dsp_lut[i * 16 + j]);
 520                 printk("\n");
 521         }
 522 #endif
 523         if (dev_drv->ops->set_dsp_lut)
 524                 dev_drv->ops->set_dsp_lut(dev_drv, dsp_lut);
 525
 526         return count;
 527 }
 528
 529 static ssize_t show_dsp_cabc(struct device *dev,
 530                              struct device_attribute *attr, char *buf)
 531 {
 532         struct fb_info *fbi = dev_get_drvdata(dev);
 533         struct rk_fb_par *fb_par = (struct rk_fb_par *)fbi->par;
 534         struct rk_lcdc_driver *dev_drv = fb_par->lcdc_drv;
 535
 536         return snprintf(buf, PAGE_SIZE, "cabc mode=%d\n",
 537                 dev_drv->cabc_mode);
 538         return 0;
 539 }
 540
 541 static ssize_t set_dsp_cabc(struct device *dev, struct device_attribute *attr,
 542                             const char *buf, size_t count)
 543 {
 544         struct fb_info *fbi = dev_get_drvdata(dev);
 545         struct rk_fb_par *fb_par = (struct rk_fb_par *)fbi->par;
 546         struct rk_lcdc_driver *dev_drv = fb_par->lcdc_drv;
 547         int ret, mode = 0;
 548
 549         ret = kstrtoint(buf, 0, &mode);
 550         if (ret)
 551                 return ret;
 552
 553         if (dev_drv->ops->set_dsp_cabc)
 554                 ret = dev_drv->ops->set_dsp_cabc(dev_drv, mode);
 555         if (ret < 0)
 556                 return ret;
 557
 558         return count;
 559 }
 560
 561 static ssize_t show_dsp_bcsh(struct device *dev,
 562                              struct device_attribute *attr, char *buf)
 563 {
 564         struct fb_info *fbi = dev_get_drvdata(dev);
 565         struct rk_fb_par *fb_par = (struct rk_fb_par *)fbi->par;
 566         struct rk_lcdc_driver *dev_drv = fb_par->lcdc_drv;
 567         int brightness, contrast, sat_con, sin_hue, cos_hue;
 568
 569         if (dev_drv->ops->get_dsp_bcsh_bcs) {
 570                 brightness = dev_drv->ops->get_dsp_bcsh_bcs(dev_drv,
 571                                                             BRIGHTNESS);
 572                 contrast = dev_drv->ops->get_dsp_bcsh_bcs(dev_drv, CONTRAST);
 573                 sat_con = dev_drv->ops->get_dsp_bcsh_bcs(dev_drv, SAT_CON);
 574         }
 575         if (dev_drv->ops->get_dsp_bcsh_hue) {
 576                 sin_hue = dev_drv->ops->get_dsp_bcsh_hue(dev_drv, H_SIN);
 577                 cos_hue = dev_drv->ops->get_dsp_bcsh_hue(dev_drv, H_COS);
 578         }
 579         return snprintf(buf, PAGE_SIZE,
 580                         "brightness:%4d,contrast:%4d,sat_con:%4d,"
 581                         "sin_hue:%4d,cos_hue:%4d\n",
 582                         brightness, contrast, sat_con, sin_hue, cos_hue);
 583 }
 584
 585 static ssize_t set_dsp_bcsh(struct device *dev, struct device_attribute *attr,
 586                             const char *buf, size_t count)
 587 {
 588         struct fb_info *fbi = dev_get_drvdata(dev);
 589         struct rk_fb_par *fb_par = (struct rk_fb_par *)fbi->par;
 590         struct rk_lcdc_driver *dev_drv = fb_par->lcdc_drv;
 591         int brightness, contrast, sat_con, ret = 0, sin_hue, cos_hue;
 592
 593         if (!strncmp(buf, "open", 4)) {
 594                 if (dev_drv->ops->open_bcsh)
 595                         ret = dev_drv->ops->open_bcsh(dev_drv, 1);
 596                 else
 597                         ret = -1;
 598         } else if (!strncmp(buf, "close", 5)) {
 599                 if (dev_drv->ops->open_bcsh)
 600                         ret = dev_drv->ops->open_bcsh(dev_drv, 0);
 601                 else
 602                         ret = -1;
 603         } else if (!strncmp(buf, "brightness", 10)) {
 604                 sscanf(buf, "brightness %d", &brightness);
 605                 if (unlikely(brightness > 255)) {
 606                         dev_err(fbi->dev,
 607                                 "brightness should be [0:255],now=%d\n\n",
 608                                 brightness);
 609                         brightness = 255;
 610                 }
 611                 if (dev_drv->ops->set_dsp_bcsh_bcs)
 612                         ret = dev_drv->ops->set_dsp_bcsh_bcs(dev_drv,
 613                                                              BRIGHTNESS,
 614                                                              brightness);
 615                 else
 616                         ret = -1;
 617         } else if (!strncmp(buf, "contrast", 8)) {
 618                 sscanf(buf, "contrast %d", &contrast);
 619                 if (unlikely(contrast > 510)) {
 620                         dev_err(fbi->dev,
 621                                 "contrast should be [0:510],now=%d\n",
 622                                 contrast);
 623                         contrast = 510;
 624                 }
 625                 if (dev_drv->ops->set_dsp_bcsh_bcs)
 626                         ret = dev_drv->ops->set_dsp_bcsh_bcs(dev_drv,
 627                                                              CONTRAST,
 628                                                              contrast);
 629                 else
 630                         ret = -1;
 631         } else if (!strncmp(buf, "sat_con", 7)) {
 632                 sscanf(buf, "sat_con %d", &sat_con);
 633                 if (unlikely(sat_con > 1015)) {
 634                         dev_err(fbi->dev,
 635                                 "sat_con should be [0:1015],now=%d\n",
 636                                 sat_con);
 637                         sat_con = 1015;
 638                 }
 639                 if (dev_drv->ops->set_dsp_bcsh_bcs)
 640                         ret = dev_drv->ops->set_dsp_bcsh_bcs(dev_drv,
 641                                                              SAT_CON,
 642                                                              sat_con);
 643                 else
 644                         ret = -1;
 645         } else if (!strncmp(buf, "hue", 3)) {
 646                 sscanf(buf, "hue %d %d", &sin_hue, &cos_hue);
 647                 if (unlikely(sin_hue > 511 || cos_hue > 511)) {
 648                         dev_err(fbi->dev, "sin_hue=%d,cos_hue=%d\n",
 649                                 sin_hue, cos_hue);
 650                 }
 651                 if (dev_drv->ops->set_dsp_bcsh_hue)
 652                         ret = dev_drv->ops->set_dsp_bcsh_hue(dev_drv,
 653                                                              sin_hue,
 654                                                              cos_hue);
 655                 else
 656                         ret = -1;
 657         } else {
 658                 dev_info(dev, "format error\n");
 659         }
 660
 661         if (ret < 0)
 662                 return ret;
 663
 664         return count;
 665 }
 666
 667 static ssize_t show_scale(struct device *dev,
 668                           struct device_attribute *attr, char *buf)
 669 {
 670         struct fb_info *fbi = dev_get_drvdata(dev);
 671         struct rk_fb_par *fb_par = (struct rk_fb_par *)fbi->par;
 672         struct rk_lcdc_driver *dev_drv = fb_par->lcdc_drv;
 673         struct rk_screen *screen = dev_drv->cur_screen;
 674
 675         return snprintf(buf, PAGE_SIZE,
 676                 "xscale=%d yscale=%d\nleft=%d top=%d right=%d bottom=%d\n",
 677                 (screen->overscan.left + screen->overscan.right)/2,
 678                 (screen->overscan.top + screen->overscan.bottom)/2,
 679                 screen->overscan.left, screen->overscan.top,
 680                 screen->overscan.right, screen->overscan.bottom);
 681 }
 682
 683 static ssize_t set_scale(struct device *dev, struct device_attribute *attr,
 684                          const char *buf, size_t count)
 685 {
 686         struct fb_info *fbi = dev_get_drvdata(dev);
 687         struct rk_fb_par *fb_par = (struct rk_fb_par *)fbi->par;
 688         struct rk_lcdc_driver *dev_drv = fb_par->lcdc_drv;
 689         struct rk_screen *screen = dev_drv->cur_screen;
 690         u32 left, top, right, bottom;
 691
 692         if (!strncmp(buf, "overscan", 8)) {
 693                 sscanf(buf,
 694                        "overscan %d,%d,%d,%d", &left, &top, &right, &bottom);
 695                 if (left > 0 && left <= 100)
 696                         screen->overscan.left = left;
 697                 if (top > 0 && top <= 100)
 698                         screen->overscan.top = top;
 699                 if (right > 0 && right <= 100)
 700                         screen->overscan.right = right;
 701                 if (bottom > 0 && bottom <= 100)
 702                         screen->overscan.bottom = bottom;
 703         } else if (!strncmp(buf, "left", 4)) {
 704                 sscanf(buf, "left=%d", &left);
 705                 if (left > 0 && left <= 100)
 706                         screen->overscan.left = left;
 707         } else if (!strncmp(buf, "top", 3)) {
 708                 sscanf(buf, "top=%d", &top);
 709                 if (top > 0 && top <= 100)
 710                         screen->overscan.top = top;
 711         } else if (!strncmp(buf, "right", 5)) {
 712                 sscanf(buf, "right=%d", &right);
 713                 if (right > 0 && right <= 100)
 714                         screen->overscan.right = right;
 715         } else if (!strncmp(buf, "bottom", 6)) {
 716                 sscanf(buf, "bottom=%d", &bottom);
 717                 if (bottom > 0 && bottom <= 100)
 718                         screen->overscan.bottom = bottom;
 719         } else if (!strncmp(buf, "xscale", 6)) {
 720                 sscanf(buf, "xscale=%d", &left);
 721                 if (left > 0 && left <= 100) {
 722                         screen->overscan.left = left;
 723                         screen->overscan.right = left;
 724                 }
 725         } else if (!strncmp(buf, "yscale", 6)) {
 726                 sscanf(buf, "yscale=%d", &left);
 727                 if (left > 0 && left <= 100) {
 728                         screen->overscan.top = left;
 729                         screen->overscan.bottom = left;
 730                 }
 731         } else {
 732                 sscanf(buf, "%d", &left);
 733                 if (left > 0 && left <= 100) {
 734                         screen->overscan.left = left;
 735                         screen->overscan.right = left;
 736                         screen->overscan.top = left;
 737                         screen->overscan.bottom = left;
 738                 }
 739         }
 740
 741         if (dev_drv->ops->set_overscan)
 742                 dev_drv->ops->set_overscan(dev_drv, &screen->overscan);
 743
 744         return count;
 745 }
 746
 747 static struct device_attribute rkfb_attrs[] = {
 748         __ATTR(phys_addr, S_IRUGO, show_phys, NULL),
 749         __ATTR(virt_addr, S_IRUGO, show_virt, NULL),
 750         __ATTR(disp_info, S_IRUGO | S_IWUSR, show_disp_info, set_dump_info),
 751         __ATTR(screen_info, S_IRUGO, show_screen_info, NULL),
 752         __ATTR(dual_mode, S_IRUGO, show_dual_mode, NULL),
 753         __ATTR(enable, S_IRUGO | S_IWUSR, show_fb_state, set_fb_state),
 754         __ATTR(overlay, S_IRUGO | S_IWUSR, show_overlay, set_overlay),
 755         __ATTR(fps, S_IRUGO | S_IWUSR, show_fps, set_fps),
 756         __ATTR(map, S_IRUGO | S_IWUSR, show_fb_win_map, set_fb_win_map),
 757         __ATTR(dsp_lut, S_IRUGO | S_IWUSR, show_dsp_lut, set_dsp_lut),
 758         __ATTR(hwc_lut, S_IRUGO | S_IWUSR, show_hwc_lut, set_hwc_lut),
 759         __ATTR(cabc, S_IRUGO | S_IWUSR, show_dsp_cabc, set_dsp_cabc),
 760         __ATTR(bcsh, S_IRUGO | S_IWUSR, show_dsp_bcsh, set_dsp_bcsh),
 761         __ATTR(scale, S_IRUGO | S_IWUSR, show_scale, set_scale),
 762 };
 763
 764 int rkfb_create_sysfs(struct fb_info *fbi)
 765 {
 766         int r, t;
 767
 768         for (t = 0; t < ARRAY_SIZE(rkfb_attrs); t++) {
 769                 r = device_create_file(fbi->dev, &rkfb_attrs[t]);
 770                 if (r) {
 771                         dev_err(fbi->dev, "failed to create sysfs " "file\n");
 772                         return r;
 773                 }
 774         }
 775
 776         return 0;
 777 }
 778
 779 void rkfb_remove_sysfs(struct rk_fb *rk_fb)
 780 {
 781         int i, t;
 782
 783         for (i = 0; i < rk_fb->num_fb; i++) {
 784                 for (t = 0; t < ARRAY_SIZE(rkfb_attrs); t++)
 785                         device_remove_file(rk_fb->fb[i]->dev, &rkfb_attrs[t]);
 786         }
 787 }