开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > 嵌入式Linux > 查看源码
s3c2410fb_6448.c
资源名称：SBC-2410X_kernel.tar.gz　[点击查看]
上传用户：lgb322
上传日期：2013-02-24
资源大小：30529k
文件大小：21k
源码类别：

嵌入式Linux

开发平台：

Unix_Linux

s3c2410fb_6448.c：源码内容
  1. #include <linux/config.h>
  2. #include <linux/module.h>
  3. #include <linux/kernel.h>
  4. #include <linux/sched.h>
  5. #include <linux/errno.h>
  6. #include <linux/string.h>
  7. #include <linux/interrupt.h>
  8. #include <linux/slab.h>
  9. #include <linux/fb.h>
  10. #include <linux/delay.h>
  11. #include <linux/pm.h>
  12. #include <linux/init.h>
  14. #include <asm/hardware.h>
  15. #include <asm/io.h>
  16. #include <asm/irq.h>
  17. #include <asm/mach-types.h>
  18. #include <asm/uaccess.h>
  20. #include <video/fbcon.h>
  21. #include <video/fbcon-mfb.h>
  22. #include <video/fbcon-cfb4.h>
  23. #include <video/fbcon-cfb8.h>
  24. #include <video/fbcon-cfb16.h>
  26. #include "s3c2410fb.h"
  29. void (*s3c2410fb_blank_helper)(int blank);
  30. EXPORT_SYMBOL(s3c2410fb_blank_helper);
  32. /*
  33.  * CONFIG_FB_S3C2410_EMUL
  34.  *
  35.  * 伙己 炮饭皋平胶 ? : 96*320 俊鼓饭捞记.
  36.  *
  37.  *  var.xres = 96 栏肺 窍绊,
  38.  *  fix.line_length = 240*2 肺 茄促.
  39.  *  app 啊 linux FB spec. 阑 霖荐茄促搁 巩力啊 绝阑 巴捞促.
  40.  *
  41.  *  var.xres_virtual 阑 炼沥窍绰 规过档 积阿秦 杭 荐 乐瘤父, spec. 苞绰 喊档肺
  43.  *  app. 啊 决没 度度秦具 且 挥父 酒聪扼, panning/wrapping 苞 部老 堪妨啊
  45.  *  乐栏骨肺 硅力茄促.
  46.  */
  48. static struct s3c2410fb_rgb rgb_8 = {
  49. red: {offset: 0, length: 4, },
  50. green: {offset: 0, length: 4, },
  51. blue: {offset: 0, length: 4, },
  52. transp: {offset: 0, length: 0, },
  53. };
  55. static struct s3c2410fb_rgb def_rgb_16 = {
  56.      red: {offset: 11, length: 5, },
  57. green: {offset: 5,  length: 6, },
  58. blue: {offset: 0,  length: 5, },
  59. transp: {offset: 0,  length: 0, },
  60. };
  62. #if 0
  63. static struct s3c2410fb_rgb xxx_tft_rgb_16 = {
  64.      red: {offset: 11, length: 5, },
  65. green: {offset: 6, length: 5, },
  66. blue: {offset: 1, length: 5, },
  67. transp: {offset: 0, length: 1, },
  68. };
  69. #else
  70. static struct s3c2410fb_rgb xxx_tft_rgb_16 = {
  71.      red: {offset: 11, length: 5, },
  72. green: {offset: 5, length: 6, },
  73. blue: {offset: 0, length: 5, },
  74. transp: {offset: 0, length: 0, },
  75. };
  76. #endif
  78. #if 0
  79. #ifdef CONFIG_S3C2410_SMDK
  80. static struct s3c2410fb_mach_info xxx_stn_info __initdata = {
  81.      pixclock: 174757, bpp: 16,
  82. #ifdef CONFIG_FB_S3C2410_EMUL
  83. xres: 96,
  84. #else
  85. xres: 240,
  86. #endif
  87. yres: 320,
  90. hsync_len   :  5,    vsync_len    :  1,
  91. left_margin :  7,    upper_margin :  1,
  92. right_margin:  3,    lower_margin :  3,
  94. sync: 0, cmap_static: 1,
  95. reg : {
  96. lcdcon1 : LCD1_BPP_16T | LCD1_PNR_TFT | LCD1_CLKVAL(1) ,
  97. lcdcon2 : LCD2_VBPD(1) | LCD2_VFPD(2) | LCD2_VSPW(1),
  98. lcdcon3 : LCD3_HBPD(6) | LCD3_HFPD(2),
  99. lcdcon4 : LCD4_HSPW(4) | LCD4_MVAL(13),
  100. lcdcon5 : LCD5_FRM565 | LCD5_INVVLINE | LCD5_INVVFRAME | LCD5_HWSWP | LCD5_PWREN,
  101. },
  102. };
  103. #endif
  105. #else
  106. #ifdef CONFIG_S3C2410_SMDK
  107. static struct s3c2410fb_mach_info xxx_stn_info __initdata = {
  108.      pixclock: 39721, bpp: 16,
  109. #ifdef CONFIG_FB_S3C2410_EMUL
  110. xres: 96,
  111. #else
  112. xres: 640,
  113. #endif
  114. yres: 480,
  117. hsync_len   :  96,    vsync_len    :  2,
  118. left_margin :  40,    upper_margin :  24,
  119. right_margin:  32,    lower_margin :  11,
  121. sync: 0, cmap_static: 1,
  122. reg : {
  123. lcdcon1 : LCD1_BPP_16T | LCD1_PNR_TFT | LCD1_CLKVAL(1) ,
  124. lcdcon2 : LCD2_VBPD(32) | LCD2_VFPD(9) | LCD2_VSPW(1),
  125. lcdcon3 : LCD3_HBPD(47) | LCD3_HFPD(15),
  126. lcdcon4 : LCD4_HSPW(95) | LCD4_MVAL(13),
  127. // lcdcon5 : LCD5_FRM565 | LCD5_INVVLINE | LCD5_INVVFRAME | LCD5_HWSWP | LCD5_PWREN,
  128. //LCD5_PWREN:enable power, LDC5_HWSWP:enable half word swap,I am not sure,so I delete it.
  129. lcdcon5 : LCD5_FRM565 | LCD5_INVVLINE | LCD5_INVVFRAME | LCD5_HWSWP | LCD5_PWREN,
  130. },
  131. };
  132. #endif
  134. #endif
  136. static inline u_int
  137. chan_to_field(u_int chan, struct fb_bitfield *bf)
  138. {
  139.     chan &= 0xffff;
  140.     chan >>= 16 - bf->length;
  141.     return chan << bf->offset;
  142. }
  144. /*
  145.  * Convert bits-per-pixel to a hardware palette PBS value.
  146.  */
  147. static inline u_int
  148. palette_pbs(struct fb_var_screeninfo *var)
  149. {
  150.    int ret = 0;
  151.    switch (var->bits_per_pixel) {
  152. #ifdef FBCON_HAS_CFB4
  153.       case 4:  ret = 0 << 12; break;
  154. #endif
  155. #ifdef FBCON_HAS_CFB8
  156.       case 8:  ret = 1 << 12; break;
  157. #endif
  158. #ifdef FBCON_HAS_CFB16
  159.       case 16: ret = 2 << 12; break;
  160. #endif
  161.    }
  162.    return ret;
  163. }
  165. static struct s3c2410fb_mach_info * __init
  166. s3c2410fb_get_machine_info(struct s3c2410fb_info *fbi)
  167. {
  168.     struct s3c2410fb_mach_info *inf = NULL;
  170.     inf = &xxx_stn_info;
  171. fbi->reg = inf->reg;
  172.     fbi->rgb[RGB_16] = &xxx_tft_rgb_16;
  174.     return inf;
  175. }
  177. static inline struct fb_var_screeninfo *get_con_var(struct fb_info *info, int con)
  178. {
  179.     struct s3c2410fb_info *fbi = (struct s3c2410fb_info *)info;
  180.     return (con == fbi->currcon || con == -1) ? &fbi->fb.var : &fb_display[con].var;
  181. }
  183. static inline struct fb_cmap *get_con_cmap(struct fb_info *info, int con)
  184. {
  185.     struct s3c2410fb_info *fbi = (struct s3c2410fb_info *)info;
  186.     return (con == fbi->currcon || con == -1) ? &fbi->fb.cmap : &fb_display[con].cmap;
  187. }
  189. static inline struct display *get_con_display(struct fb_info *info, int con)
  190. {
  191.     struct s3c2410fb_info *fbi = (struct s3c2410fb_info *)info;
  192.     return (con < 0) ? (fbi->fb.disp) : &(fb_display[con]);
  193. }
  195. static int
  196. s3c2410fb_validate_var(struct fb_var_screeninfo *var,
  197.       struct s3c2410fb_info *fbi)
  198. {
  199.     int ret = -EINVAL;
  201.     if (var->xres < MIN_XRES)
  202. var->xres = MIN_XRES;
  203.     if (var->yres < MIN_YRES)
  204. var->yres = MIN_YRES;
  205.     if (var->xres > fbi->max_xres)
  206. var->xres = fbi->max_xres;
  207.     if (var->yres > fbi->max_yres)
  208. var->yres = fbi->max_yres;
  209.     var->xres_virtual =
  210. var->xres_virtual < var->xres ? var->xres : var->xres_virtual;
  211.     var->yres_virtual =
  212. var->yres_virtual < var->yres ? var->yres : var->yres_virtual;
  214.     switch(var->bits_per_pixel) {
  215. #ifdef FBCON_HAS_CFB4
  216. case 4: ret = 0; break;
  217. #endif
  218. #ifdef FBCON_HAS_CFB8
  219. case 8: ret = 0; break;
  220. #endif
  221. #ifdef FBCON_HAS_CFB16
  222. case 16: ret = 0; break;
  223. #endif
  224. default:
  225. break;
  226.     }
  228.     return ret;
  229. }
  230. static int
  231. s3c2410fb_setpalettereg(u_int regno, u_int red, u_int green, u_int blue,
  232. u_int trans, struct fb_info *info)
  233. {
  234.     struct s3c2410fb_info *fbi = (struct s3c2410fb_info *)info;
  235.     u_int val, ret = 1;
  237.     if (regno < fbi->palette_size) {
  238. #ifndef CONFIG_S3C2400_GAMEPARK
  239. val = ((red >> 4) & 0xf00);
  240. val |= ((green >> 8) & 0x0f0);
  241. val |= ((blue >> 12) & 0x00f);
  242. #else
  243. val = ((blue >> 16) & 0x001f);
  244.     val |= ((green >> 11) & 0x07e0);
  245.     val |= ((red >> 5) & 0x0f800);
  246. val |= 1; /* intensity bit */
  247. #endif
  248. if (regno == 0)
  249.     val |= palette_pbs(&fbi->fb.var);
  251. fbi->palette_cpu[regno] = val;
  252. ret = 0;
  253.     }
  254.     return ret;
  255. }
  258. static int
  259. s3c2410fb_setcolreg(u_int regno, u_int red, u_int green, u_int blue,
  260.     u_int trans, struct fb_info *info)
  261. {
  262.     struct s3c2410fb_info *fbi = (struct s3c2410fb_info *)info;
  263.     struct display *disp = get_con_display(info, fbi->currcon);
  264.     u_int var;
  265.     int ret = 1;
  267.     if (disp->inverse) {
  268. red  = 0xffff - red;
  269. green  = 0xffff - green;
  270. blue = 0xffff - blue;
  271.     }
  273.     if (fbi->fb.var.grayscale)
  274. red = green = blue = (19595 * red + 38470 * green + 7471 * blue) >> 16;
  276.     switch (fbi->fb.disp->visual) {
  277. case FB_VISUAL_TRUECOLOR:
  278.     if (regno < 16) {
  279. u16 *pal = fbi->fb.pseudo_palette;
  281. var = chan_to_field(red, &fbi->fb.var.red);
  282. var |= chan_to_field(green, &fbi->fb.var.green);
  283. var |= chan_to_field(blue, &fbi->fb.var.blue);
  285. pal[regno] = var;
  286. ret = 0;
  287.     }
  288.     break;
  290. case FB_VISUAL_STATIC_PSEUDOCOLOR:
  291. case FB_VISUAL_PSEUDOCOLOR:
  292.     ret = s3c2410fb_setpalettereg(regno, red, green, blue, trans, info);
  293.     break;
  294.     }
  296.     return ret;
  297. }
  299. static int s3c2410fb_activate_var(struct fb_var_screeninfo *var, struct s3c2410fb_info *fbi)
  300. {
  301.     struct s3c2410fb_lcd_reg new_regs;
  302.     u_int half_screen_size, yres;
  303.     u_long flags;
  305.     /*new_reg 啊 绢录绊 历录绊 */
  307.     unsigned long VideoPhysicalTemp = fbi->screen_dma;
  309.     save_flags_cli(flags);
  311.     new_regs.lcdcon1 = fbi->reg.lcdcon1 & ~LCD1_ENVID;
  313.     new_regs.lcdcon2 = (fbi->reg.lcdcon2 & ~LCD2_LINEVAL_MSK)
  314. | LCD2_LINEVAL(var->yres - 1);
  316. /* TFT LCD only ! */
  317.     new_regs.lcdcon3 = (fbi->reg.lcdcon3 & ~LCD3_HOZVAL_MSK)
  318. | LCD3_HOZVAL(var->xres - 1);
  319.      new_regs.lcdcon4 = fbi->reg.lcdcon4;
  321.     new_regs.lcdcon5 = fbi->reg.lcdcon5;
  323.     new_regs.lcdsaddr1 =
  324. LCDADDR_BANK(((unsigned long)VideoPhysicalTemp >> 22))
  325. | LCDADDR_BASEU(((unsigned long)VideoPhysicalTemp >> 1));
  327. /* 16bpp */
  328.     new_regs.lcdsaddr2 = LCDADDR_BASEL(
  329. ((unsigned long)VideoPhysicalTemp + (var->xres * 2 * (var->yres/*-1*/)))
  330. >> 1);
  332.     new_regs.lcdsaddr3 = LCDADDR_OFFSET(0) | (LCDADDR_PAGE(var->xres) /*>> 1*/);
  334.     yres = var->yres;
  335.     /* if ( dual 捞搁) */
  336.     //yres /= 2;
  338.     half_screen_size = var->bits_per_pixel;
  339.     half_screen_size = half_screen_size * var->xres * var->yres / 16;
  341. fbi->reg.lcdcon1 = new_regs.lcdcon1;
  342. fbi->reg.lcdcon2 = new_regs.lcdcon2;
  343. fbi->reg.lcdcon3 = new_regs.lcdcon3;
  344. fbi->reg.lcdcon4 = new_regs.lcdcon4;
  345. fbi->reg.lcdcon5 = new_regs.lcdcon5;
  346. fbi->reg.lcdsaddr1 = new_regs.lcdsaddr1;
  347. fbi->reg.lcdsaddr2 = new_regs.lcdsaddr2;
  348. fbi->reg.lcdsaddr3 = new_regs.lcdsaddr3;
  350.     LCDCON1 = fbi->reg.lcdcon1;
  351.     LCDCON2 = fbi->reg.lcdcon2;
  352.     LCDCON3 = fbi->reg.lcdcon3;
  353.     LCDCON4 = fbi->reg.lcdcon4;
  354.     LCDCON5 = fbi->reg.lcdcon5;
  355.     LCDADDR1 = fbi->reg.lcdsaddr1;
  356.     LCDADDR2 = fbi->reg.lcdsaddr2;
  357.     LCDADDR3 = fbi->reg.lcdsaddr3;
  359. //softmcu
  360. //#if defined(CONFIG_S3C2410_SMDK) && !defined(CONFIG_SMDK_AIJI)
  361. //    LCDLPCSEL = 0x2;
  362. //#elif defined(CONFIG_S3C2410_SMDK) && defined(CONFIG_SMDK_AIJI)
  363. //    LCDLPCSEL = 0x7;
  364. //#endif
  365. //LCDINTMSK |=(3);
  367. LCDLPCSEL &= (~7);
  369.     TPAL = 0;
  370.     LCDCON1 |= LCD1_ENVID;
  374. printk("testing the lcd by softmcun");
  376. #if 0
  377. {
  378. printk("con1 = 0x%08lxn", LCDCON1);
  379. printk("con2 = 0x%08lxn", LCDCON2);
  381. printk("con3 = 0x%08lxn", LCDCON3);
  382. printk("con4 = 0x%08lxn", LCDCON4);
  383. printk("con5 = 0x%08lxn", LCDCON5);
  384. printk("addr1 = 0x%08lxn", LCDADDR1);
  385. printk("addr2 = 0x%08lxn", LCDADDR2);
  386. printk("addr3 = 0x%08lxn", LCDADDR3);
  387. }
  388. #endif
  390.     restore_flags(flags);
  392.     return 0;
  393. }
  396. static inline void s3c2410fb_set_truecolor(u_int is_true_color)
  397. {
  398.     if (is_true_color) {
  399.     }
  400.     else {
  401.     }
  402. }
  405. static void
  406. s3c2410fb_hw_set_var(struct fb_var_screeninfo *var, struct s3c2410fb_info *fbi)
  407. {
  408.     u_long palette_mem_size;
  410.     fbi->palette_size = var->bits_per_pixel == 8 ? 256 : 16;
  412.     palette_mem_size = fbi->palette_size * sizeof(u16);
  414.     fbi->palette_cpu = (u16 *)(fbi->map_cpu + PAGE_SIZE - palette_mem_size);
  415.     fbi->palette_dma = fbi->map_dma + PAGE_SIZE - palette_mem_size;
  417.     fb_set_cmap(&fbi->fb.cmap, 1, s3c2410fb_setcolreg, &fbi->fb);
  419.     s3c2410fb_set_truecolor(var->bits_per_pixel >= 16);
  421.     s3c2410fb_activate_var(var, fbi);
  423.     fbi->palette_cpu[0] = (fbi->palette_cpu[0] &
  424. 0xcfff) | palette_pbs(var);
  425. }
  429. static int
  430. s3c2410fb_set_var(struct fb_var_screeninfo *var, int con, struct fb_info *info)
  431. {
  432.     struct s3c2410fb_info *fbi = (struct s3c2410fb_info *)info;
  433.     struct fb_var_screeninfo *dvar = get_con_var(&fbi->fb, con);
  434.     struct display *display = get_con_display(&fbi->fb, con);
  435.     int err, chgvar = 0, rgbidx;
  438.     err = s3c2410fb_validate_var(var, fbi);
  440.     if (err)
  441. return err;
  443.     if (var->activate & FB_ACTIVATE_TEST)
  444. return 0;
  445.     if ((var->activate & FB_ACTIVATE_MASK) != FB_ACTIVATE_NOW)
  446. return -EINVAL;
  448.     if (dvar->xres != var->xres)
  449. chgvar = 1;
  450.     if (dvar->yres != var->yres)
  451. chgvar = 1;
  452.     if (dvar->xres_virtual != var->xres_virtual)
  453. chgvar = 1;
  454.     if (dvar->yres_virtual != var->yres_virtual)
  455. chgvar = 1;
  456.     if (dvar->bits_per_pixel != var->bits_per_pixel)
  457. chgvar = 1;
  458.     if (con < 0)
  459. chgvar = 0;
  461.     switch (var->bits_per_pixel) {
  462. #ifdef FBCON_HAS_CFB4
  463. case 4:
  464.      if (fbi->cmap_static)
  465.     display->visual = FB_VISUAL_STATIC_PSEUDOCOLOR;
  466. else
  467.     display->visual = FB_VISUAL_PSEUDOCOLOR;
  468. display->line_length  = var->xres / 2;
  469. display->dispsw = &fbcon_cfb4;
  470. rgbidx = RGB_8;
  471. break;
  472. #endif
  473. #ifdef FBCON_HAS_CFB8
  474. case 8:
  475. if (fbi->cmap_static)
  476.     display->visual = FB_VISUAL_STATIC_PSEUDOCOLOR;
  477. else
  478.     display->visual = FB_VISUAL_PSEUDOCOLOR;
  479. display->line_length  = var->xres;
  480.      display->dispsw = &fbcon_cfb8;
  481. rgbidx = RGB_8;
  482. break;
  483. #endif
  484. #ifdef FBCON_HAS_CFB16
  485. case 16:
  486. display->visual = FB_VISUAL_TRUECOLOR;
  487. #ifdef CONFIG_FB_S3C2410_EMUL
  488. display->line_length    = 240*2;
  489. #else
  490. display->line_length = var->xres * 2;
  491. #endif
  492. display->dispsw = &fbcon_cfb16;
  493. display->dispsw_data = fbi->fb.pseudo_palette;
  494. rgbidx = RGB_16;
  495. break;
  496. #endif
  497. default:
  498. rgbidx = 0;
  499. display->dispsw = &fbcon_dummy;
  500. break;
  501.     }
  503.     display->screen_base  = fbi->screen_cpu;
  504.     display->next_line = display->line_length;
  505.     display->type = fbi->fb.fix.type;
  506.     display->type_aux = fbi->fb.fix.type_aux;
  507.     display->ypanstep = fbi->fb.fix.ypanstep;
  508.     display->ywrapstep = fbi->fb.fix.ywrapstep;
  509.     display->can_soft_blank = 0;
  510.     display->inverse = fbi->cmap_inverse;
  512.     *dvar = *var;
  513.     dvar->activate &= ~FB_ACTIVATE_ALL;
  515.     dvar->red = fbi->rgb[rgbidx]->red;
  516.     dvar->green = fbi->rgb[rgbidx]->green;
  517.     dvar->blue = fbi->rgb[rgbidx]->blue;
  518.     dvar->transp = fbi->rgb[rgbidx]->transp;
  520.     display->var = *dvar;
  522.     if (var->activate & FB_ACTIVATE_ALL)
  523. fbi->fb.disp->var = *dvar;
  525.     if (chgvar && info && fbi->fb.changevar)
  526. fbi->fb.changevar(con);
  528.     if (con != fbi->currcon)
  529. return 0;
  531.     s3c2410fb_hw_set_var(dvar, fbi);
  533.     return 0;
  534. }
  536. static int
  537. __do_set_cmap(struct fb_cmap *cmap, int kspc, int con,
  538.       struct fb_info *info)
  539. {
  540.     struct s3c2410fb_info *fbi = (struct s3c2410fb_info *)info;
  541.     struct fb_cmap *dcmap = get_con_cmap(info, con);
  542.     int err = 0;
  544.     if (con == -1)
  545. con = fbi->currcon;
  547.     if (con >= 0)
  548. err = fb_alloc_cmap(&fb_display[con].cmap, fbi->palette_size, 0);
  550.     if (!err && con == fbi->currcon)
  551. err = fb_set_cmap(cmap, kspc, s3c2410fb_setcolreg, info);
  553.     if (!err)
  554. fb_copy_cmap(cmap, dcmap, kspc ? 0 : 1);
  556.     return err;
  557. }
  559. static int
  560. s3c2410fb_set_cmap(struct fb_cmap *cmap, int kspc, int con,
  561.    struct fb_info *info)
  562. {
  563.     struct display *disp = get_con_display(info, con);
  565.     if (disp->visual == FB_VISUAL_TRUECOLOR ||
  566.         disp->visual == FB_VISUAL_STATIC_PSEUDOCOLOR)
  567. return -EINVAL;
  569.     return __do_set_cmap(cmap, kspc, con, info);
  570. }
  573. static int
  574. s3c2410fb_get_fix(struct fb_fix_screeninfo *fix, int con, struct fb_info *info)
  575. {
  576.     struct display *display = get_con_display(info, con);
  578.     *fix = info->fix;
  580.     fix->line_length = display->line_length;
  581.     fix->visual      = display->visual;
  582.     return 0;
  583. }
  585. static int
  586. s3c2410fb_get_var(struct fb_var_screeninfo *var, int con, struct fb_info *info)
  587. {
  588.     *var = *get_con_var(info, con);
  589.     return 0;
  590. }
  592. static int
  593. s3c2410fb_get_cmap(struct fb_cmap *cmap, int kspc, int con, struct fb_info *info)
  594. {
  595.     struct fb_cmap *dcmap = get_con_cmap(info, con);
  596.     fb_copy_cmap(dcmap, cmap, kspc ? 0 : 2);
  597.     return 0;
  598. }
  600. #ifdef CONFIG_PM
  601. static int
  602. s3c2410fb_ioctl(struct inode *inode, struct file *file, unsigned int cmd,
  603.                unsigned long arg, int con, struct fb_info *info) {
  604. #ifdef CONFIG_MIZI
  605.     if (mz_pm_ops.fb_ioctl == NULL)
  606.       return -EINVAL;
  607.     return (*(mz_pm_ops.fb_ioctl))(inode, file, cmd, arg, PROC_CONSOLE(info), info);
  608. #endif /* CONFIG_MIZI */
  609. }
  610. #endif /* CONFIG_PM */
  612. static struct fb_ops s3c2410fb_ops = {
  613. owner: THIS_MODULE,
  614. fb_get_fix: s3c2410fb_get_fix,
  615. fb_get_var: s3c2410fb_get_var,
  616. fb_set_var: s3c2410fb_set_var,
  617. fb_get_cmap: s3c2410fb_get_cmap,
  618. fb_set_cmap: s3c2410fb_set_cmap,
  619. #ifdef CONFIG_PM
  620.     fb_ioctl:   s3c2410fb_ioctl,
  621. #endif /* CONFIG_PM */
  622. };
  624. static int s3c2410fb_switch(int con, struct fb_info *info)
  625. {
  626.     struct s3c2410fb_info *fbi = (struct s3c2410fb_info *)info;
  627.     struct display *disp;
  628.     struct fb_cmap *cmap;
  630.     if (con == fbi->currcon)
  631. return 0;
  633.     if (fbi->currcon >= 0) {
  634. disp = fb_display + fbi->currcon;
  636. disp->var = fbi->fb.var;
  638. if (disp->cmap.len)
  639.     fb_copy_cmap(&fbi->fb.cmap, &disp->cmap, 0);
  641.     }
  643.     fbi->currcon = con;
  644.     disp = fb_display + con;
  646.     fb_alloc_cmap(&fbi->fb.cmap, 256, 0);
  648.     if (disp->cmap.len)
  649. cmap = &disp->cmap;
  650.     else
  651. cmap = fb_default_cmap(1 << disp->var.bits_per_pixel);
  653.     fb_copy_cmap(cmap, &fbi->fb.cmap, 0);
  655.     fbi->fb.var = disp->var;
  656.     fbi->fb.var.activate = FB_ACTIVATE_NOW;
  658.     s3c2410fb_set_var(&fbi->fb.var, con, info);
  660.     return 0;
  661. }
  663. #ifdef CONFIG_PM
  664. /*
  665.  * Power management hook. Note that we won't be called from IRQ context,
  666.  * unlike the blank functions above, so we may sleep
  667.  */
  668. static int s3c2410_pm_callback(struct pm_dev *pm_dev, pm_request_t req, void *data)
  669. {
  670. struct s3c2410fb_info *fbi = pm_dev->data;
  671. u_long flags;
  673. //printk("pm_callback: %dn", req);
  675. if (req == PM_SUSPEND) {
  676. /* disable LCD controller */
  677. LCDCON1 &= ~(1 << 0);
  678. } else if (req == PM_RESUME) {
  679. /* reinitialize LCD controllers and GPIOs */
  680. save_flags_cli(flags);
  682. LCDCON1 = fbi->reg.lcdcon1;
  683. LCDCON2 = fbi->reg.lcdcon2;
  684. LCDCON3 = fbi->reg.lcdcon3;
  685. LCDCON4 = fbi->reg.lcdcon4;
  686. LCDCON5 = fbi->reg.lcdcon5;
  687. LCDADDR1 = fbi->reg.lcdsaddr1;
  688. LCDADDR2 = fbi->reg.lcdsaddr2;
  689. LCDADDR3 = fbi->reg.lcdsaddr3;
  691. //#if defined(CONFIG_S3C2410_SMDK) && !defined(CONFIG_SMDK_AIJI)
  692. LCDLPCSEL = 0x2;
  693. //#elif defined(CONFIG_S3C2410_SMDK) && defined(CONFIG_SMDK_AIJI)
  694. LCDLPCSEL = 0x7;
  695. //#endif
  696. LCDLPCSEL &= (~7);
  697. TPAL = 0;
  698. LCDCON1 |= LCD1_ENVID;
  700. restore_flags(flags);
  701. }
  702. //printk("donen");
  703. return 0;
  704. }
  705. #endif
  707. static int __init s3c2410fb_map_video_memory(struct s3c2410fb_info *fbi)
  708. {
  709.     fbi->map_size = PAGE_ALIGN(fbi->fb.fix.smem_len + PAGE_SIZE);
  710.     fbi->map_cpu = consistent_alloc(GFP_KERNEL, fbi->map_size,
  711.          &fbi->map_dma);
  713.     if (fbi->map_cpu) {
  714. fbi->screen_cpu = fbi->map_cpu + PAGE_SIZE;
  715. fbi->screen_dma = fbi->map_dma + PAGE_SIZE;
  716. fbi->fb.fix.smem_start = fbi->screen_dma;
  717.     }
  719.     return fbi->map_cpu ? 0 : -ENOMEM;
  720. }
  722. static int s3c2410fb_updatevar(int con, struct fb_info *info)
  723. {
  724.     return 0;
  725. }
  727. static void s3c2410fb_blank(int blank, struct fb_info *info)
  728. {
  729. }
  731. static struct fb_monspecs monspecs __initdata = {
  732.     30000, 70000, 50, 65, 0
  733. };
  735. static struct s3c2410fb_info * __init s3c2410fb_init_fbinfo(void)
  736. {
  737.     struct s3c2410fb_mach_info *inf;
  738.     struct s3c2410fb_info *fbi;
  740.     fbi = kmalloc(sizeof(struct s3c2410fb_info) + sizeof(struct display) +
  741.        sizeof(u16)*16, GFP_KERNEL);
  743.     if (!fbi)
  744. return NULL;
  746.     memset(fbi, 0, sizeof(struct s3c2410fb_info) + sizeof(struct display));
  748.     fbi->currcon = -1;
  750.     strcpy(fbi->fb.fix.id, S3C2410_NAME);
  752.     fbi->fb.fix.type = FB_TYPE_PACKED_PIXELS;
  753.     fbi->fb.fix.type_aux = 0;
  754.     fbi->fb.fix.xpanstep = 0;
  755.     fbi->fb.fix.ypanstep = 0;
  756.     fbi->fb.fix.ywrapstep = 0;
  757.     fbi->fb.fix.accel = FB_ACCEL_NONE;
  759.     fbi->fb.var.nonstd = 0;
  760.     fbi->fb.var.activate = FB_ACTIVATE_NOW;
  761.     fbi->fb.var.height = -1;
  762.     fbi->fb.var.width = -1;
  763.     fbi->fb.var.accel_flags = 0;
  764.     fbi->fb.var.vmode = FB_VMODE_NONINTERLACED;
  766.     strcpy(fbi->fb.modename, S3C2410_NAME);
  767.     strcpy(fbi->fb.fontname, "Acorn8x8");
  769.     fbi->fb.fbops = &s3c2410fb_ops;
  770.     fbi->fb.changevar = NULL;
  771.     fbi->fb.switch_con = s3c2410fb_switch;
  772.     fbi->fb.updatevar = s3c2410fb_updatevar;
  773.     fbi->fb.blank = s3c2410fb_blank;
  774.     fbi->fb.flags = FBINFO_FLAG_DEFAULT;
  775.     fbi->fb.node = -1;
  776.     fbi->fb.monspecs = monspecs;
  777.     fbi->fb.disp = (struct display *)(fbi + 1);
  778.     fbi->fb.pseudo_palette = (void *)(fbi->fb.disp + 1);
  780.     fbi->rgb[RGB_8] = &rgb_8;
  781.     fbi->rgb[RGB_16] = &def_rgb_16;
  783.     inf = s3c2410fb_get_machine_info(fbi);
  785. #ifdef CONFIG_FB_S3C2410_EMUL
  786. fbi->max_xres  = 240;
  787. #else
  788.     fbi->max_xres = inf->xres;
  789. #endif
  790.     fbi->fb.var.xres = inf->xres;
  791.     fbi->fb.var.xres_virtual = inf->xres;
  792.     fbi->max_yres = inf->yres;
  793.     fbi->fb.var.yres = inf->yres;
  794.     fbi->fb.var.yres_virtual = inf->yres;
  795.     fbi->max_bpp = inf->bpp;
  796.     fbi->fb.var.bits_per_pixel  = inf->bpp;
  797.     fbi->fb.var.pixclock = inf->pixclock;
  798.     fbi->fb.var.hsync_len = inf->hsync_len;
  799.     fbi->fb.var.left_margin = inf->left_margin;
  800.     fbi->fb.var.right_margin = inf->right_margin;
  801.     fbi->fb.var.vsync_len = inf->vsync_len;
  802.     fbi->fb.var.upper_margin = inf->upper_margin;
  803.     fbi->fb.var.lower_margin = inf->lower_margin;
  804.     fbi->fb.var.sync = inf->sync;
  805.     fbi->fb.var.grayscale = inf->cmap_grayscale;
  806.     fbi->cmap_inverse = inf->cmap_inverse;
  807.     fbi->cmap_static = inf->cmap_static;
  808.     fbi->fb.fix.smem_len = fbi->max_xres * fbi->max_yres *
  809.   fbi->max_bpp / 8;
  810.     return fbi;
  811. }
  813. void s3c2410_lcd_init(void)
  814. {
  815. //softmcu
  816. GPCUP = 0xffffffff;
  817. GPDUP = 0xffffffff;
  819.     GPDCON = 0xaaaaaaaa;
  821. #ifdef CONFIG_S3C2410_SMDK
  822.     GPCCON = 0xaaaaaaaa;
  824. //softmcu
  825. //set_gpio_ctrl(GPIO_G4 | GPIO_PULLUP_EN | GPIO_MODE_LCD_PWRDN);
  826. set_gpio_ctrl(GPIO_G4 | GPIO_PULLUP_DIS | GPIO_MODE_LCD_PWRDN);
  827. #endif
  829. #if defined(CONFIG_MIZI) && defined(CONFIG_PM)
  830.     if (mz_pm_ops.blank_helper != NULL)
  831.         (*(mz_pm_ops.blank_helper))(MZ_BLANK_ON);
  832. #endif
  833. }
  835. int __init s3c2410fb_init(void)
  836. {
  837.     struct s3c2410fb_info *fbi;
  838.     int ret;
  840. //softmcu
  841. printk("test lcd start 0719n");
  842.     fbi = s3c2410fb_init_fbinfo();
  843.     ret = -ENOMEM;
  844.     if (!fbi)
  845. goto failed;
  847.     ret = s3c2410fb_map_video_memory(fbi);
  848.     if (ret)
  849. goto failed;
  851.     s3c2410_lcd_init();
  852.     s3c2410fb_set_var(&fbi->fb.var, -1, &fbi->fb);
  854.     ret = register_framebuffer(&fbi->fb);
  855.    if (ret < 0)
  856.       goto failed;
  858. #ifdef CONFIG_PM
  859. /*
  860.  * Note that console registers this as well, but we want to
  861.  * power donw the display prior to sleeping
  862.  */
  863. fbi->pm = pm_register(PM_DEBUG_DEV, PM_SYS_VGA, s3c2410_pm_callback);
  864. if (fbi->pm)
  865. fbi->pm->data = fbi;
  866. #endif
  868.    /* enable the LCD controller) */
  869. printk("Installed S3C2410 frame buffern");
  871.     MOD_INC_USE_COUNT ;
  872.     return 0;
  874. failed:
  875.     if (fbi)
  876. kfree(fbi);
  877.     return ret;
  878. }
  880. int __init s3c2410fb_setup(char *options)
  881. {
  882.     return 0;
  883. }
  885. #ifdef MODULE
  886. module_init(s3c2410fb_init);
  887. #endif