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