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