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