1/* 2 * linux/drivers/video/imxfb.c 3 * 4 * Freescale i.MX Frame Buffer device driver 5 * 6 * Copyright (C) 2004 Sascha Hauer, Pengutronix 7 * Based on acornfb.c Copyright (C) Russell King. 8 * 9 * This file is subject to the terms and conditions of the GNU General Public 10 * License. See the file COPYING in the main directory of this archive for 11 * more details. 12 * 13 * Please direct your questions and comments on this driver to the following 14 * email address: 15 * 16 * linux-arm-kernel@lists.arm.linux.org.uk 17 */ 18 19//#define DEBUG 1 20 21#include <linux/module.h> 22#include <linux/kernel.h> 23#include <linux/errno.h> 24#include <linux/string.h> 25#include <linux/interrupt.h> 26#include <linux/slab.h> 27#include <linux/fb.h> 28#include <linux/delay.h> 29#include <linux/init.h> 30#include <linux/ioport.h> 31#include <linux/cpufreq.h> 32#include <linux/platform_device.h> 33#include <linux/dma-mapping.h> 34 35#include <asm/hardware.h> 36#include <asm/io.h> 37#include <asm/uaccess.h> 38#include <asm/arch/imxfb.h> 39 40/* 41 * Complain if VAR is out of range. 42 */ 43#define DEBUG_VAR 1 44 45#include "imxfb.h" 46 47static struct imxfb_rgb def_rgb_16 = { 48 .red = { .offset = 8, .length = 4, }, 49 .green = { .offset = 4, .length = 4, }, 50 .blue = { .offset = 0, .length = 4, }, 51 .transp = { .offset = 0, .length = 0, }, 52}; 53 54static struct imxfb_rgb def_rgb_8 = { 55 .red = { .offset = 0, .length = 8, }, 56 .green = { .offset = 0, .length = 8, }, 57 .blue = { .offset = 0, .length = 8, }, 58 .transp = { .offset = 0, .length = 0, }, 59}; 60 61static int imxfb_activate_var(struct fb_var_screeninfo *var, struct fb_info *info); 62 63static inline u_int chan_to_field(u_int chan, struct fb_bitfield *bf) 64{ 65 chan &= 0xffff; 66 chan >>= 16 - bf->length; 67 return chan << bf->offset; 68} 69 70#define LCDC_PALETTE(x) __REG2(IMX_LCDC_BASE+0x800, (x)<<2) 71static int 72imxfb_setpalettereg(u_int regno, u_int red, u_int green, u_int blue, 73 u_int trans, struct fb_info *info) 74{ 75 struct imxfb_info *fbi = info->par; 76 u_int val, ret = 1; 77 78#define CNVT_TOHW(val,width) ((((val)<<(width))+0x7FFF-(val))>>16) 79 if (regno < fbi->palette_size) { 80 val = (CNVT_TOHW(red, 4) << 8) | 81 (CNVT_TOHW(green,4) << 4) | 82 CNVT_TOHW(blue, 4); 83 84 LCDC_PALETTE(regno) = val; 85 ret = 0; 86 } 87 return ret; 88} 89 90static int 91imxfb_setcolreg(u_int regno, u_int red, u_int green, u_int blue, 92 u_int trans, struct fb_info *info) 93{ 94 struct imxfb_info *fbi = info->par; 95 unsigned int val; 96 int ret = 1; 97 98 /* 99 * If inverse mode was selected, invert all the colours 100 * rather than the register number. The register number 101 * is what you poke into the framebuffer to produce the 102 * colour you requested. 103 */ 104 if (fbi->cmap_inverse) { 105 red = 0xffff - red; 106 green = 0xffff - green; 107 blue = 0xffff - blue; 108 } 109 110 /* 111 * If greyscale is true, then we convert the RGB value 112 * to greyscale no mater what visual we are using. 113 */ 114 if (info->var.grayscale) 115 red = green = blue = (19595 * red + 38470 * green + 116 7471 * blue) >> 16; 117 118 switch (info->fix.visual) { 119 case FB_VISUAL_TRUECOLOR: 120 /* 121 * 12 or 16-bit True Colour. We encode the RGB value 122 * according to the RGB bitfield information. 123 */ 124 if (regno < 16) { 125 u32 *pal = info->pseudo_palette; 126 127 val = chan_to_field(red, &info->var.red); 128 val |= chan_to_field(green, &info->var.green); 129 val |= chan_to_field(blue, &info->var.blue); 130 131 pal[regno] = val; 132 ret = 0; 133 } 134 break; 135 136 case FB_VISUAL_STATIC_PSEUDOCOLOR: 137 case FB_VISUAL_PSEUDOCOLOR: 138 ret = imxfb_setpalettereg(regno, red, green, blue, trans, info); 139 break; 140 } 141 142 return ret; 143} 144 145/* 146 * imxfb_check_var(): 147 * Round up in the following order: bits_per_pixel, xres, 148 * yres, xres_virtual, yres_virtual, xoffset, yoffset, grayscale, 149 * bitfields, horizontal timing, vertical timing. 150 */ 151static int 152imxfb_check_var(struct fb_var_screeninfo *var, struct fb_info *info) 153{ 154 struct imxfb_info *fbi = info->par; 155 int rgbidx; 156 157 if (var->xres < MIN_XRES) 158 var->xres = MIN_XRES; 159 if (var->yres < MIN_YRES) 160 var->yres = MIN_YRES; 161 if (var->xres > fbi->max_xres) 162 var->xres = fbi->max_xres; 163 if (var->yres > fbi->max_yres) 164 var->yres = fbi->max_yres; 165 var->xres_virtual = max(var->xres_virtual, var->xres); 166 var->yres_virtual = max(var->yres_virtual, var->yres); 167 168 pr_debug("var->bits_per_pixel=%d\n", var->bits_per_pixel); 169 switch (var->bits_per_pixel) { 170 case 16: 171 rgbidx = RGB_16; 172 break; 173 case 8: 174 rgbidx = RGB_8; 175 break; 176 default: 177 rgbidx = RGB_16; 178 } 179 180 /* 181 * Copy the RGB parameters for this display 182 * from the machine specific parameters. 183 */ 184 var->red = fbi->rgb[rgbidx]->red; 185 var->green = fbi->rgb[rgbidx]->green; 186 var->blue = fbi->rgb[rgbidx]->blue; 187 var->transp = fbi->rgb[rgbidx]->transp; 188 189 pr_debug("RGBT length = %d:%d:%d:%d\n", 190 var->red.length, var->green.length, var->blue.length, 191 var->transp.length); 192 193 pr_debug("RGBT offset = %d:%d:%d:%d\n", 194 var->red.offset, var->green.offset, var->blue.offset, 195 var->transp.offset); 196 197 return 0; 198} 199 200/* 201 * imxfb_set_par(): 202 * Set the user defined part of the display for the specified console 203 */ 204static int imxfb_set_par(struct fb_info *info) 205{ 206 struct imxfb_info *fbi = info->par; 207 struct fb_var_screeninfo *var = &info->var; 208 209 pr_debug("set_par\n"); 210 211 if (var->bits_per_pixel == 16) 212 info->fix.visual = FB_VISUAL_TRUECOLOR; 213 else if (!fbi->cmap_static) 214 info->fix.visual = FB_VISUAL_PSEUDOCOLOR; 215 else { 216 /* 217 * Some people have weird ideas about wanting static 218 * pseudocolor maps. I suspect their user space 219 * applications are broken. 220 */ 221 info->fix.visual = FB_VISUAL_STATIC_PSEUDOCOLOR; 222 } 223 224 info->fix.line_length = var->xres_virtual * 225 var->bits_per_pixel / 8; 226 fbi->palette_size = var->bits_per_pixel == 8 ? 256 : 16; 227 228 imxfb_activate_var(var, info); 229 230 return 0; 231} 232 233static void imxfb_enable_controller(struct imxfb_info *fbi) 234{ 235 pr_debug("Enabling LCD controller\n"); 236 237 /* initialize LCDC */ 238 LCDC_RMCR &= ~RMCR_LCDC_EN; /* just to be safe... */ 239 240 LCDC_SSA = fbi->screen_dma; 241 /* physical screen start address */ 242 LCDC_VPW = VPW_VPW(fbi->max_xres * fbi->max_bpp / 8 / 4); 243 244 LCDC_POS = 0x00000000; /* panning offset 0 (0 pixel offset) */ 245 246 /* disable hardware cursor */ 247 LCDC_CPOS &= ~(CPOS_CC0 | CPOS_CC1); 248 249 LCDC_RMCR = RMCR_LCDC_EN; 250 251 if(fbi->backlight_power) 252 fbi->backlight_power(1); 253 if(fbi->lcd_power) 254 fbi->lcd_power(1); 255} 256 257static void imxfb_disable_controller(struct imxfb_info *fbi) 258{ 259 pr_debug("Disabling LCD controller\n"); 260 261 if(fbi->backlight_power) 262 fbi->backlight_power(0); 263 if(fbi->lcd_power) 264 fbi->lcd_power(0); 265 266 LCDC_RMCR = 0; 267} 268 269static int imxfb_blank(int blank, struct fb_info *info) 270{ 271 struct imxfb_info *fbi = info->par; 272 273 pr_debug("imxfb_blank: blank=%d\n", blank); 274 275 switch (blank) { 276 case FB_BLANK_POWERDOWN: 277 case FB_BLANK_VSYNC_SUSPEND: 278 case FB_BLANK_HSYNC_SUSPEND: 279 case FB_BLANK_NORMAL: 280 imxfb_disable_controller(fbi); 281 break; 282 283 case FB_BLANK_UNBLANK: 284 imxfb_enable_controller(fbi); 285 break; 286 } 287 return 0; 288} 289 290static struct fb_ops imxfb_ops = { 291 .owner = THIS_MODULE, 292 .fb_check_var = imxfb_check_var, 293 .fb_set_par = imxfb_set_par, 294 .fb_setcolreg = imxfb_setcolreg, 295 .fb_fillrect = cfb_fillrect, 296 .fb_copyarea = cfb_copyarea, 297 .fb_imageblit = cfb_imageblit, 298 .fb_blank = imxfb_blank, 299}; 300 301/* 302 * imxfb_activate_var(): 303 * Configures LCD Controller based on entries in var parameter. Settings are 304 * only written to the controller if changes were made. 305 */ 306static int imxfb_activate_var(struct fb_var_screeninfo *var, struct fb_info *info) 307{ 308 struct imxfb_info *fbi = info->par; 309 pr_debug("var: xres=%d hslen=%d lm=%d rm=%d\n", 310 var->xres, var->hsync_len, 311 var->left_margin, var->right_margin); 312 pr_debug("var: yres=%d vslen=%d um=%d bm=%d\n", 313 var->yres, var->vsync_len, 314 var->upper_margin, var->lower_margin); 315 316#if DEBUG_VAR 317 if (var->xres < 16 || var->xres > 1024) 318 printk(KERN_ERR "%s: invalid xres %d\n", 319 info->fix.id, var->xres); 320 if (var->hsync_len < 1 || var->hsync_len > 64) 321 printk(KERN_ERR "%s: invalid hsync_len %d\n", 322 info->fix.id, var->hsync_len); 323 if (var->left_margin > 255) 324 printk(KERN_ERR "%s: invalid left_margin %d\n", 325 info->fix.id, var->left_margin); 326 if (var->right_margin > 255) 327 printk(KERN_ERR "%s: invalid right_margin %d\n", 328 info->fix.id, var->right_margin); 329 if (var->yres < 1 || var->yres > 511) 330 printk(KERN_ERR "%s: invalid yres %d\n", 331 info->fix.id, var->yres); 332 if (var->vsync_len > 100) 333 printk(KERN_ERR "%s: invalid vsync_len %d\n", 334 info->fix.id, var->vsync_len); 335 if (var->upper_margin > 63) 336 printk(KERN_ERR "%s: invalid upper_margin %d\n", 337 info->fix.id, var->upper_margin); 338 if (var->lower_margin > 255) 339 printk(KERN_ERR "%s: invalid lower_margin %d\n", 340 info->fix.id, var->lower_margin); 341#endif 342 343 LCDC_HCR = HCR_H_WIDTH(var->hsync_len) | 344 HCR_H_WAIT_1(var->left_margin) | 345 HCR_H_WAIT_2(var->right_margin); 346 347 LCDC_VCR = VCR_V_WIDTH(var->vsync_len) | 348 VCR_V_WAIT_1(var->upper_margin) | 349 VCR_V_WAIT_2(var->lower_margin); 350 351 LCDC_SIZE = SIZE_XMAX(var->xres) | SIZE_YMAX(var->yres); 352 LCDC_PCR = fbi->pcr; 353 LCDC_PWMR = fbi->pwmr; 354 LCDC_LSCR1 = fbi->lscr1; 355 LCDC_DMACR = fbi->dmacr; 356 357 return 0; 358} 359 360static void imxfb_setup_gpio(struct imxfb_info *fbi) 361{ 362 int width; 363 364 LCDC_RMCR &= ~(RMCR_LCDC_EN | RMCR_SELF_REF); 365 366 if( fbi->pcr & PCR_TFT ) 367 width = 16; 368 else 369 width = 1 << ((fbi->pcr >> 28) & 0x3); 370 371 switch(width) { 372 case 16: 373 imx_gpio_mode(PD30_PF_LD15); 374 imx_gpio_mode(PD29_PF_LD14); 375 imx_gpio_mode(PD28_PF_LD13); 376 imx_gpio_mode(PD27_PF_LD12); 377 imx_gpio_mode(PD26_PF_LD11); 378 imx_gpio_mode(PD25_PF_LD10); 379 imx_gpio_mode(PD24_PF_LD9); 380 imx_gpio_mode(PD23_PF_LD8); 381 case 8: 382 imx_gpio_mode(PD22_PF_LD7); 383 imx_gpio_mode(PD21_PF_LD6); 384 imx_gpio_mode(PD20_PF_LD5); 385 imx_gpio_mode(PD19_PF_LD4); 386 case 4: 387 imx_gpio_mode(PD18_PF_LD3); 388 imx_gpio_mode(PD17_PF_LD2); 389 case 2: 390 imx_gpio_mode(PD16_PF_LD1); 391 case 1: 392 imx_gpio_mode(PD15_PF_LD0); 393 } 394 395 /* initialize GPIOs */ 396 imx_gpio_mode(PD6_PF_LSCLK); 397 imx_gpio_mode(PD11_PF_CONTRAST); 398 imx_gpio_mode(PD14_PF_FLM_VSYNC); 399 imx_gpio_mode(PD13_PF_LP_HSYNC); 400 imx_gpio_mode(PD12_PF_ACD_OE); 401 402 /* These are only needed for Sharp HR TFT displays */ 403 if (fbi->pcr & PCR_SHARP) { 404 imx_gpio_mode(PD7_PF_REV); 405 imx_gpio_mode(PD8_PF_CLS); 406 imx_gpio_mode(PD9_PF_PS); 407 imx_gpio_mode(PD10_PF_SPL_SPR); 408 } 409} 410 411#ifdef CONFIG_PM 412/* 413 * Power management hooks. Note that we won't be called from IRQ context, 414 * unlike the blank functions above, so we may sleep. 415 */ 416static int imxfb_suspend(struct platform_device *dev, pm_message_t state) 417{ 418 struct imxfb_info *fbi = platform_get_drvdata(dev); 419 pr_debug("%s\n",__FUNCTION__); 420 421 imxfb_disable_controller(fbi); 422 return 0; 423} 424 425static int imxfb_resume(struct platform_device *dev) 426{ 427 struct imxfb_info *fbi = platform_get_drvdata(dev); 428 pr_debug("%s\n",__FUNCTION__); 429 430 imxfb_enable_controller(fbi); 431 return 0; 432} 433#else 434#define imxfb_suspend NULL 435#define imxfb_resume NULL 436#endif 437 438static int __init imxfb_init_fbinfo(struct device *dev) 439{ 440 struct imxfb_mach_info *inf = dev->platform_data; 441 struct fb_info *info = dev_get_drvdata(dev); 442 struct imxfb_info *fbi = info->par; 443 444 pr_debug("%s\n",__FUNCTION__); 445 446 info->pseudo_palette = kmalloc( sizeof(u32) * 16, GFP_KERNEL); 447 if (!info->pseudo_palette) 448 return -ENOMEM; 449 450 memset(fbi, 0, sizeof(struct imxfb_info)); 451 fbi->dev = dev; 452 453 strlcpy(info->fix.id, IMX_NAME, sizeof(info->fix.id)); 454 455 info->fix.type = FB_TYPE_PACKED_PIXELS; 456 info->fix.type_aux = 0; 457 info->fix.xpanstep = 0; 458 info->fix.ypanstep = 0; 459 info->fix.ywrapstep = 0; 460 info->fix.accel = FB_ACCEL_NONE; 461 462 info->var.nonstd = 0; 463 info->var.activate = FB_ACTIVATE_NOW; 464 info->var.height = -1; 465 info->var.width = -1; 466 info->var.accel_flags = 0; 467 info->var.vmode = FB_VMODE_NONINTERLACED; 468 469 info->fbops = &imxfb_ops; 470 info->flags = FBINFO_FLAG_DEFAULT; 471 472 fbi->rgb[RGB_16] = &def_rgb_16; 473 fbi->rgb[RGB_8] = &def_rgb_8; 474 475 fbi->max_xres = inf->xres; 476 info->var.xres = inf->xres; 477 info->var.xres_virtual = inf->xres; 478 fbi->max_yres = inf->yres; 479 info->var.yres = inf->yres; 480 info->var.yres_virtual = inf->yres; 481 fbi->max_bpp = inf->bpp; 482 info->var.bits_per_pixel = inf->bpp; 483 info->var.pixclock = inf->pixclock; 484 info->var.hsync_len = inf->hsync_len; 485 info->var.left_margin = inf->left_margin; 486 info->var.right_margin = inf->right_margin; 487 info->var.vsync_len = inf->vsync_len; 488 info->var.upper_margin = inf->upper_margin; 489 info->var.lower_margin = inf->lower_margin; 490 info->var.sync = inf->sync; 491 info->var.grayscale = inf->cmap_greyscale; 492 fbi->cmap_inverse = inf->cmap_inverse; 493 fbi->cmap_static = inf->cmap_static; 494 fbi->pcr = inf->pcr; 495 fbi->lscr1 = inf->lscr1; 496 fbi->dmacr = inf->dmacr; 497 fbi->pwmr = inf->pwmr; 498 fbi->lcd_power = inf->lcd_power; 499 fbi->backlight_power = inf->backlight_power; 500 info->fix.smem_len = fbi->max_xres * fbi->max_yres * 501 fbi->max_bpp / 8; 502 503 return 0; 504} 505 506/* 507 * Allocates the DRAM memory for the frame buffer. This buffer is 508 * remapped into a non-cached, non-buffered, memory region to 509 * allow pixel writes to occur without flushing the cache. 510 * Once this area is remapped, all virtual memory access to the 511 * video memory should occur at the new region. 512 */ 513static int __init imxfb_map_video_memory(struct fb_info *info) 514{ 515 struct imxfb_info *fbi = info->par; 516 517 fbi->map_size = PAGE_ALIGN(info->fix.smem_len); 518 fbi->map_cpu = dma_alloc_writecombine(fbi->dev, fbi->map_size, 519 &fbi->map_dma,GFP_KERNEL); 520 521 if (fbi->map_cpu) { 522 info->screen_base = fbi->map_cpu; 523 fbi->screen_cpu = fbi->map_cpu; 524 fbi->screen_dma = fbi->map_dma; 525 info->fix.smem_start = fbi->screen_dma; 526 } 527 528 return fbi->map_cpu ? 0 : -ENOMEM; 529} 530 531static int __init imxfb_probe(struct platform_device *pdev) 532{ 533 struct imxfb_info *fbi; 534 struct fb_info *info; 535 struct imxfb_mach_info *inf; 536 struct resource *res; 537 int ret; 538 539 printk("i.MX Framebuffer driver\n"); 540 541 res = platform_get_resource(pdev, IORESOURCE_MEM, 0); 542 if(!res) 543 return -ENODEV; 544 545 inf = pdev->dev.platform_data; 546 if(!inf) { 547 dev_err(&pdev->dev,"No platform_data available\n"); 548 return -ENOMEM; 549 } 550 551 info = framebuffer_alloc(sizeof(struct imxfb_info), &pdev->dev); 552 if(!info) 553 return -ENOMEM; 554 555 fbi = info->par; 556 557 platform_set_drvdata(pdev, info); 558 559 ret = imxfb_init_fbinfo(&pdev->dev); 560 if( ret < 0 ) 561 goto failed_init; 562 563 res = request_mem_region(res->start, res->end - res->start + 1, "IMXFB"); 564 if (!res) { 565 ret = -EBUSY; 566 goto failed_regs; 567 } 568 569 if (!inf->fixed_screen_cpu) { 570 ret = imxfb_map_video_memory(info); 571 if (ret) { 572 dev_err(&pdev->dev, "Failed to allocate video RAM: %d\n", ret); 573 ret = -ENOMEM; 574 goto failed_map; 575 } 576 } else { 577 /* Fixed framebuffer mapping enables location of the screen in eSRAM */ 578 fbi->map_cpu = inf->fixed_screen_cpu; 579 fbi->map_dma = inf->fixed_screen_dma; 580 info->screen_base = fbi->map_cpu; 581 fbi->screen_cpu = fbi->map_cpu; 582 fbi->screen_dma = fbi->map_dma; 583 info->fix.smem_start = fbi->screen_dma; 584 } 585 586 /* 587 * This makes sure that our colour bitfield 588 * descriptors are correctly initialised. 589 */ 590 imxfb_check_var(&info->var, info); 591 592 ret = fb_alloc_cmap(&info->cmap, 1<<info->var.bits_per_pixel, 0); 593 if (ret < 0) 594 goto failed_cmap; 595 596 imxfb_setup_gpio(fbi); 597 598 imxfb_set_par(info); 599 ret = register_framebuffer(info); 600 if (ret < 0) { 601 dev_err(&pdev->dev, "failed to register framebuffer\n"); 602 goto failed_register; 603 } 604 605 imxfb_enable_controller(fbi); 606 607 return 0; 608 609failed_register: 610 fb_dealloc_cmap(&info->cmap); 611failed_cmap: 612 if (!inf->fixed_screen_cpu) 613 dma_free_writecombine(&pdev->dev,fbi->map_size,fbi->map_cpu, 614 fbi->map_dma); 615failed_map: 616 kfree(info->pseudo_palette); 617failed_regs: 618 release_mem_region(res->start, res->end - res->start); 619failed_init: 620 platform_set_drvdata(pdev, NULL); 621 framebuffer_release(info); 622 return ret; 623} 624 625static int imxfb_remove(struct platform_device *pdev) 626{ 627 struct fb_info *info = platform_get_drvdata(pdev); 628 struct imxfb_info *fbi = info->par; 629 struct resource *res; 630 631 res = platform_get_resource(pdev, IORESOURCE_MEM, 0); 632 633 imxfb_disable_controller(fbi); 634 635 unregister_framebuffer(info); 636 637 fb_dealloc_cmap(&info->cmap); 638 kfree(info->pseudo_palette); 639 framebuffer_release(info); 640 641 release_mem_region(res->start, res->end - res->start + 1); 642 platform_set_drvdata(pdev, NULL); 643 644 return 0; 645} 646 647void imxfb_shutdown(struct platform_device * dev) 648{ 649 struct fb_info *info = platform_get_drvdata(dev); 650 struct imxfb_info *fbi = info->par; 651 imxfb_disable_controller(fbi); 652} 653 654static struct platform_driver imxfb_driver = { 655 .probe = imxfb_probe, 656 .suspend = imxfb_suspend, 657 .resume = imxfb_resume, 658 .remove = imxfb_remove, 659 .shutdown = imxfb_shutdown, 660 .driver = { 661 .name = "imx-fb", 662 }, 663}; 664 665int __init imxfb_init(void) 666{ 667 return platform_driver_register(&imxfb_driver); 668} 669 670static void __exit imxfb_cleanup(void) 671{ 672 platform_driver_unregister(&imxfb_driver); 673} 674 675module_init(imxfb_init); 676module_exit(imxfb_cleanup); 677 678MODULE_DESCRIPTION("Motorola i.MX framebuffer driver"); 679MODULE_AUTHOR("Sascha Hauer, Pengutronix"); 680MODULE_LICENSE("GPL"); 681