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_cabc_lut(struct device *dev,
 496                              struct device_attribute *attr, char *buf)
 497 {
 498         return 0;
 499 }
 500
 501 static ssize_t set_cabc_lut(struct device *dev, struct device_attribute *attr,
 502                             const char *buf, size_t count)
 503 {
 504         int cabc_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                 cabc_lut[i] = temp + (temp << 8) + (temp << 16);
 517         }
 518         for (i = 0; i < 256; i++) {
 519                 space_max = 10; /*max space number 10*/
 520                 temp = simple_strtoul(start, NULL, 10);
 521                 cabc_lut[i] = temp;
 522                 do {
 523                         start++;
 524                         space_max--;
 525                 } while ((*start != ' ') && space_max);
 526
 527                 if (!space_max)
 528                         break;
 529                 else
 530                         start++;
 531         }
 532         if (dev_drv->ops->set_cabc_lut)
 533                 dev_drv->ops->set_cabc_lut(dev_drv, cabc_lut);
 534
 535         return count;
 536 }
 537
 538
 539 static ssize_t show_dsp_lut(struct device *dev,
 540                             struct device_attribute *attr, char *buf)
 541 {
 542         return 0;
 543 }
 544
 545 static ssize_t set_dsp_lut(struct device *dev, struct device_attribute *attr,
 546                            const char *buf, size_t count)
 547 {
 548         int dsp_lut[256];
 549         const char *start = buf;
 550         int i = 256, temp;
 551         int space_max = 10;
 552
 553         struct fb_info *fbi = dev_get_drvdata(dev);
 554         struct rk_fb_par *fb_par = (struct rk_fb_par *)fbi->par;
 555         struct rk_lcdc_driver *dev_drv = fb_par->lcdc_drv;
 556
 557         for (i = 0; i < 256; i++) {
 558                 temp = i;
 559                 /*init by default value*/
 560                 dsp_lut[i] = temp + (temp << 8) + (temp << 16);
 561         }
 562         /*printk("count:%d\n>>%s\n\n",count,start);*/
 563         for (i = 0; i < 256; i++) {
 564                 space_max = 10; /*max space number 10*/
 565                 temp = simple_strtoul(start, NULL, 10);
 566                 dsp_lut[i] = temp;
 567                 do {
 568                         start++;
 569                         space_max--;
 570                 } while ((*start != ' ') && space_max);
 571
 572                 if (!space_max)
 573                         break;
 574                 else
 575                         start++;
 576         }
 577 #if 0
 578         for (i = 0; i < 16; i++) {
 579                 for (j = 0; j < 16; j++)
 580                         printk("0x%08x ", dsp_lut[i * 16 + j]);
 581                 printk("\n");
 582         }
 583 #endif
 584         if (dev_drv->ops->set_dsp_lut)
 585                 dev_drv->ops->set_dsp_lut(dev_drv, dsp_lut);
 586
 587         return count;
 588 }
 589
 590 static ssize_t show_dsp_cabc(struct device *dev,
 591                              struct device_attribute *attr, char *buf)
 592 {
 593         struct fb_info *fbi = dev_get_drvdata(dev);
 594         struct rk_fb_par *fb_par = (struct rk_fb_par *)fbi->par;
 595         struct rk_lcdc_driver *dev_drv = fb_par->lcdc_drv;
 596
 597         return snprintf(buf, PAGE_SIZE, "cabc mode=%d\n",
 598                 dev_drv->cabc_mode);
 599         return 0;
 600 }
 601
 602 static ssize_t set_dsp_cabc(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 ret, mode = 0;
 609
 610         ret = kstrtoint(buf, 0, &mode);
 611         if (ret)
 612                 return ret;
 613
 614         if (dev_drv->ops->set_dsp_cabc)
 615                 ret = dev_drv->ops->set_dsp_cabc(dev_drv, mode);
 616         if (ret < 0)
 617                 return ret;
 618
 619         return count;
 620 }
 621
 622 static ssize_t show_dsp_bcsh(struct device *dev,
 623                              struct device_attribute *attr, char *buf)
 624 {
 625         struct fb_info *fbi = dev_get_drvdata(dev);
 626         struct rk_fb_par *fb_par = (struct rk_fb_par *)fbi->par;
 627         struct rk_lcdc_driver *dev_drv = fb_par->lcdc_drv;
 628         int brightness, contrast, sat_con, sin_hue, cos_hue;
 629
 630         if (dev_drv->ops->get_dsp_bcsh_bcs) {
 631                 brightness = dev_drv->ops->get_dsp_bcsh_bcs(dev_drv,
 632                                                             BRIGHTNESS);
 633                 contrast = dev_drv->ops->get_dsp_bcsh_bcs(dev_drv, CONTRAST);
 634                 sat_con = dev_drv->ops->get_dsp_bcsh_bcs(dev_drv, SAT_CON);
 635         }
 636         if (dev_drv->ops->get_dsp_bcsh_hue) {
 637                 sin_hue = dev_drv->ops->get_dsp_bcsh_hue(dev_drv, H_SIN);
 638                 cos_hue = dev_drv->ops->get_dsp_bcsh_hue(dev_drv, H_COS);
 639         }
 640         return snprintf(buf, PAGE_SIZE,
 641                         "brightness:%4d,contrast:%4d,sat_con:%4d,"
 642                         "sin_hue:%4d,cos_hue:%4d\n",
 643                         brightness, contrast, sat_con, sin_hue, cos_hue);
 644 }
 645
 646 static ssize_t set_dsp_bcsh(struct device *dev, struct device_attribute *attr,
 647                             const char *buf, size_t count)
 648 {
 649         struct fb_info *fbi = dev_get_drvdata(dev);
 650         struct rk_fb_par *fb_par = (struct rk_fb_par *)fbi->par;
 651         struct rk_lcdc_driver *dev_drv = fb_par->lcdc_drv;
 652         int brightness, contrast, sat_con, ret = 0, sin_hue, cos_hue;
 653
 654         if (!strncmp(buf, "open", 4)) {
 655                 if (dev_drv->ops->open_bcsh)
 656                         ret = dev_drv->ops->open_bcsh(dev_drv, 1);
 657                 else
 658                         ret = -1;
 659         } else if (!strncmp(buf, "close", 5)) {
 660                 if (dev_drv->ops->open_bcsh)
 661                         ret = dev_drv->ops->open_bcsh(dev_drv, 0);
 662                 else
 663                         ret = -1;
 664         } else if (!strncmp(buf, "brightness", 10)) {
 665                 sscanf(buf, "brightness %d", &brightness);
 666                 if (unlikely(brightness > 255)) {
 667                         dev_err(fbi->dev,
 668                                 "brightness should be [0:255],now=%d\n\n",
 669                                 brightness);
 670                         brightness = 255;
 671                 }
 672                 if (dev_drv->ops->set_dsp_bcsh_bcs)
 673                         ret = dev_drv->ops->set_dsp_bcsh_bcs(dev_drv,
 674                                                              BRIGHTNESS,
 675                                                              brightness);
 676                 else
 677                         ret = -1;
 678         } else if (!strncmp(buf, "contrast", 8)) {
 679                 sscanf(buf, "contrast %d", &contrast);
 680                 if (unlikely(contrast > 510)) {
 681                         dev_err(fbi->dev,
 682                                 "contrast should be [0:510],now=%d\n",
 683                                 contrast);
 684                         contrast = 510;
 685                 }
 686                 if (dev_drv->ops->set_dsp_bcsh_bcs)
 687                         ret = dev_drv->ops->set_dsp_bcsh_bcs(dev_drv,
 688                                                              CONTRAST,
 689                                                              contrast);
 690                 else
 691                         ret = -1;
 692         } else if (!strncmp(buf, "sat_con", 7)) {
 693                 sscanf(buf, "sat_con %d", &sat_con);
 694                 if (unlikely(sat_con > 1015)) {
 695                         dev_err(fbi->dev,
 696                                 "sat_con should be [0:1015],now=%d\n",
 697                                 sat_con);
 698                         sat_con = 1015;
 699                 }
 700                 if (dev_drv->ops->set_dsp_bcsh_bcs)
 701                         ret = dev_drv->ops->set_dsp_bcsh_bcs(dev_drv,
 702                                                              SAT_CON,
 703                                                              sat_con);
 704                 else
 705                         ret = -1;
 706         } else if (!strncmp(buf, "hue", 3)) {
 707                 sscanf(buf, "hue %d %d", &sin_hue, &cos_hue);
 708                 if (unlikely(sin_hue > 511 || cos_hue > 511)) {
 709                         dev_err(fbi->dev, "sin_hue=%d,cos_hue=%d\n",
 710                                 sin_hue, cos_hue);
 711                 }
 712                 if (dev_drv->ops->set_dsp_bcsh_hue)
 713                         ret = dev_drv->ops->set_dsp_bcsh_hue(dev_drv,
 714                                                              sin_hue,
 715                                                              cos_hue);
 716                 else
 717                         ret = -1;
 718         } else {
 719                 dev_info(dev, "format error\n");
 720         }
 721
 722         if (ret < 0)
 723                 return ret;
 724
 725         return count;
 726 }
 727
 728 static ssize_t show_scale(struct device *dev,
 729                           struct device_attribute *attr, char *buf)
 730 {
 731         struct fb_info *fbi = dev_get_drvdata(dev);
 732         struct rk_fb_par *fb_par = (struct rk_fb_par *)fbi->par;
 733         struct rk_lcdc_driver *dev_drv = fb_par->lcdc_drv;
 734
 735         return snprintf(buf, PAGE_SIZE,
 736                 "xscale=%d yscale=%d\nleft=%d top=%d right=%d bottom=%d\n",
 737                 (dev_drv->overscan.left + dev_drv->overscan.right) / 2,
 738                 (dev_drv->overscan.top + dev_drv->overscan.bottom) / 2,
 739                 dev_drv->overscan.left, dev_drv->overscan.top,
 740                 dev_drv->overscan.right, dev_drv->overscan.bottom);
 741 }
 742
 743 static ssize_t set_scale(struct device *dev, struct device_attribute *attr,
 744                          const char *buf, size_t count)
 745 {
 746         struct fb_info *fbi = dev_get_drvdata(dev);
 747         struct rk_fb_par *fb_par = (struct rk_fb_par *)fbi->par;
 748         struct rk_lcdc_driver *dev_drv = fb_par->lcdc_drv;
 749         u32 left, top, right, bottom;
 750
 751         if (!strncmp(buf, "overscan", 8)) {
 752                 sscanf(buf,
 753                        "overscan %d,%d,%d,%d", &left, &top, &right, &bottom);
 754                 if (left > 0 && left <= 100)
 755                         dev_drv->overscan.left = left;
 756                 if (top > 0 && top <= 100)
 757                         dev_drv->overscan.top = top;
 758                 if (right > 0 && right <= 100)
 759                         dev_drv->overscan.right = right;
 760                 if (bottom > 0 && bottom <= 100)
 761                         dev_drv->overscan.bottom = bottom;
 762         } else if (!strncmp(buf, "left", 4)) {
 763                 sscanf(buf, "left=%d", &left);
 764                 if (left > 0 && left <= 100)
 765                         dev_drv->overscan.left = left;
 766         } else if (!strncmp(buf, "top", 3)) {
 767                 sscanf(buf, "top=%d", &top);
 768                 if (top > 0 && top <= 100)
 769                         dev_drv->overscan.top = top;
 770         } else if (!strncmp(buf, "right", 5)) {
 771                 sscanf(buf, "right=%d", &right);
 772                 if (right > 0 && right <= 100)
 773                         dev_drv->overscan.right = right;
 774         } else if (!strncmp(buf, "bottom", 6)) {
 775                 sscanf(buf, "bottom=%d", &bottom);
 776                 if (bottom > 0 && bottom <= 100)
 777                         dev_drv->overscan.bottom = bottom;
 778         } else if (!strncmp(buf, "xscale", 6)) {
 779                 sscanf(buf, "xscale=%d", &left);
 780                 if (left > 0 && left <= 100) {
 781                         dev_drv->overscan.left = left;
 782                         dev_drv->overscan.right = left;
 783                 }
 784         } else if (!strncmp(buf, "yscale", 6)) {
 785                 sscanf(buf, "yscale=%d", &left);
 786                 if (left > 0 && left <= 100) {
 787                         dev_drv->overscan.top = left;
 788                         dev_drv->overscan.bottom = left;
 789                 }
 790         } else {
 791                 sscanf(buf, "%d", &left);
 792                 if (left > 0 && left <= 100) {
 793                         dev_drv->overscan.left = left;
 794                         dev_drv->overscan.right = left;
 795                         dev_drv->overscan.top = left;
 796                         dev_drv->overscan.bottom = left;
 797                 }
 798         }
 799
 800         if (dev_drv->ops->set_overscan)
 801                 dev_drv->ops->set_overscan(dev_drv, &dev_drv->overscan);
 802
 803         return count;
 804 }
 805
 806 static struct device_attribute rkfb_attrs[] = {
 807         __ATTR(phys_addr, S_IRUGO, show_phys, NULL),
 808         __ATTR(virt_addr, S_IRUGO, show_virt, NULL),
 809         __ATTR(disp_info, S_IRUGO | S_IWUSR, show_disp_info, set_dump_info),
 810         __ATTR(screen_info, S_IRUGO, show_screen_info, NULL),
 811         __ATTR(dual_mode, S_IRUGO, show_dual_mode, NULL),
 812         __ATTR(enable, S_IRUGO | S_IWUSR, show_fb_state, set_fb_state),
 813         __ATTR(overlay, S_IRUGO | S_IWUSR, show_overlay, set_overlay),
 814         __ATTR(fps, S_IRUGO | S_IWUSR, show_fps, set_fps),
 815         __ATTR(map, S_IRUGO | S_IWUSR, show_fb_win_map, set_fb_win_map),
 816         __ATTR(dsp_lut, S_IRUGO | S_IWUSR, show_dsp_lut, set_dsp_lut),
 817         __ATTR(cabc_lut, S_IRUGO | S_IWUSR, show_cabc_lut, set_cabc_lut),
 818         __ATTR(hwc_lut, S_IRUGO | S_IWUSR, show_hwc_lut, set_hwc_lut),
 819         __ATTR(cabc, S_IRUGO | S_IWUSR, show_dsp_cabc, set_dsp_cabc),
 820         __ATTR(bcsh, S_IRUGO | S_IWUSR, show_dsp_bcsh, set_dsp_bcsh),
 821         __ATTR(scale, S_IRUGO | S_IWUSR, show_scale, set_scale),
 822 };
 823
 824 int rkfb_create_sysfs(struct fb_info *fbi)
 825 {
 826         int r, t;
 827
 828         for (t = 0; t < ARRAY_SIZE(rkfb_attrs); t++) {
 829                 r = device_create_file(fbi->dev, &rkfb_attrs[t]);
 830                 if (r) {
 831                         dev_err(fbi->dev, "failed to create sysfs " "file\n");
 832                         return r;
 833                 }
 834         }
 835
 836         return 0;
 837 }
 838
 839 void rkfb_remove_sysfs(struct rk_fb *rk_fb)
 840 {
 841         int i, t;
 842
 843         for (i = 0; i < rk_fb->num_fb; i++) {
 844                 for (t = 0; t < ARRAY_SIZE(rkfb_attrs); t++)
 845                         device_remove_file(rk_fb->fb[i]->dev, &rkfb_attrs[t]);
 846         }
 847 }