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