paul@33 | 1 | /* |
paul@224 | 2 | * jz4740 LCD controller configuration. |
paul@33 | 3 | * |
paul@33 | 4 | * Copyright (C) Xiangfu Liu <xiangfu@sharism.cc> |
paul@217 | 5 | * Copyright (C) 2015, 2016, 2017 Paul Boddie <paul@boddie.org.uk> |
paul@33 | 6 | * |
paul@33 | 7 | * This program is free software; you can redistribute it and/or |
paul@33 | 8 | * modify it under the terms of the GNU General Public License as |
paul@33 | 9 | * published by the Free Software Foundation; either version 2 of |
paul@33 | 10 | * the License, or (at your option) any later version. |
paul@33 | 11 | * |
paul@33 | 12 | * This program is distributed in the hope that it will be useful, |
paul@33 | 13 | * but WITHOUT ANY WARRANTY; without even the implied warranty of |
paul@33 | 14 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
paul@33 | 15 | * GNU General Public License for more details. |
paul@33 | 16 | * |
paul@33 | 17 | * You should have received a copy of the GNU General Public License |
paul@33 | 18 | * along with this program; if not, write to the Free Software |
paul@42 | 19 | * Foundation, Inc., 51 Franklin Street, Fifth Floor, |
paul@42 | 20 | * Boston, MA 02110-1301, USA |
paul@33 | 21 | */ |
paul@33 | 22 | |
paul@33 | 23 | #include "sdram.h" |
paul@33 | 24 | #include "jzlcd.h" |
paul@33 | 25 | #include "board.h" |
paul@229 | 26 | #include "xburst_types.h" /* for REG32 */ |
paul@223 | 27 | |
paul@223 | 28 | /* Useful alignment operations. */ |
paul@223 | 29 | |
paul@223 | 30 | static inline void align2(uint32_t *n) |
paul@223 | 31 | { |
paul@223 | 32 | *n = (((*n)+1)>>1)<<1; |
paul@223 | 33 | } |
paul@223 | 34 | |
paul@223 | 35 | static inline void align4(uint32_t *n) |
paul@223 | 36 | { |
paul@223 | 37 | *n = (((*n)+3)>>2)<<2; |
paul@223 | 38 | } |
paul@223 | 39 | |
paul@223 | 40 | static inline void align8(uint32_t *n) |
paul@223 | 41 | { |
paul@223 | 42 | *n = (((*n)+7)>>3)<<3; |
paul@223 | 43 | } |
paul@33 | 44 | |
paul@223 | 45 | |
paul@223 | 46 | |
paul@223 | 47 | /* Register operations. */ |
paul@223 | 48 | |
paul@223 | 49 | static inline uint32_t lcd_ctrl_get(vidinfo_t *vid, uint32_t reg) |
paul@223 | 50 | { |
paul@223 | 51 | return REG32(vid->lcd + reg); |
paul@223 | 52 | } |
paul@223 | 53 | |
paul@223 | 54 | static inline void lcd_ctrl_set(vidinfo_t *vid, uint32_t reg, uint32_t value) |
paul@223 | 55 | { |
paul@223 | 56 | REG32(vid->lcd + reg) = value; |
paul@223 | 57 | } |
paul@223 | 58 | |
paul@223 | 59 | |
paul@223 | 60 | |
paul@223 | 61 | /* Configuration operations. */ |
paul@223 | 62 | |
paul@223 | 63 | /* Return the number of panels available. */ |
paul@33 | 64 | |
paul@224 | 65 | static uint8_t lcd_get_panels(vidinfo_t *vid) |
paul@100 | 66 | { |
paul@221 | 67 | struct jzfb_info *jzfb = vid->jz_fb; |
paul@221 | 68 | return ((jzfb->cfg & MODE_MASK) == MODE_STN_MONO_DUAL) || |
paul@221 | 69 | ((jzfb->cfg & MODE_MASK) == MODE_STN_COLOR_DUAL) ? 2 : 1; |
paul@100 | 70 | } |
paul@100 | 71 | |
paul@223 | 72 | /* Calculate and return the pixel clock frequency. */ |
paul@223 | 73 | |
paul@224 | 74 | static uint32_t lcd_get_pixel_clock(vidinfo_t *vid) |
paul@223 | 75 | { |
paul@223 | 76 | struct jzfb_info *jzfb = vid->jz_fb; |
paul@223 | 77 | uint32_t pclk, width_cycles, mode = jzfb->cfg & MODE_MASK; |
paul@223 | 78 | |
paul@223 | 79 | /* |
paul@223 | 80 | Serial mode: 3 pixel clock cycles per pixel (one per channel). |
paul@223 | 81 | Parallel mode: 1 pixel clock cycle per pixel. |
paul@223 | 82 | */ |
paul@223 | 83 | |
paul@223 | 84 | if (mode == MODE_8BIT_SERIAL_TFT) |
paul@223 | 85 | width_cycles = jzfb->w * 3; |
paul@223 | 86 | else |
paul@223 | 87 | width_cycles = jzfb->w; |
paul@223 | 88 | |
paul@223 | 89 | /* Derive pixel clock from frame clock. */ |
paul@223 | 90 | |
paul@223 | 91 | pclk = jzfb->fclk * |
paul@223 | 92 | (width_cycles + jzfb->hsw + jzfb->elw + jzfb->blw) * |
paul@223 | 93 | (jzfb->h + jzfb->vsw + jzfb->efw + jzfb->bfw); |
paul@223 | 94 | |
paul@223 | 95 | if ((mode == MODE_STN_COLOR_SINGLE) || (mode == MODE_STN_COLOR_DUAL)) |
paul@223 | 96 | pclk = (pclk * 3); |
paul@223 | 97 | |
paul@223 | 98 | if ((mode == MODE_STN_COLOR_SINGLE) || (mode == MODE_STN_COLOR_DUAL) || |
paul@223 | 99 | (mode == MODE_STN_MONO_SINGLE) || (mode == MODE_STN_MONO_DUAL)) |
paul@223 | 100 | pclk = pclk >> ((jzfb->cfg & STN_DAT_PINMASK) >> 4); |
paul@223 | 101 | |
paul@223 | 102 | if ((mode == MODE_STN_COLOR_DUAL) || (mode == MODE_STN_MONO_DUAL)) |
paul@223 | 103 | pclk >>= 1; |
paul@223 | 104 | |
paul@223 | 105 | return pclk; |
paul@223 | 106 | } |
paul@223 | 107 | |
paul@102 | 108 | |
paul@102 | 109 | |
paul@102 | 110 | /* Functions returning region sizes. */ |
paul@102 | 111 | |
paul@217 | 112 | static uint32_t lcd_get_size(vidinfo_t *vid) |
paul@33 | 113 | { |
paul@100 | 114 | /* Lines must be aligned to a word boundary. */ |
paul@227 | 115 | |
paul@221 | 116 | uint32_t line_length = ALIGN((vid->jz_fb->w * vid->jz_fb->bpp) / 8, sizeof(uint32_t)); |
paul@221 | 117 | return line_length * vid->jz_fb->h; |
paul@33 | 118 | } |
paul@33 | 119 | |
paul@217 | 120 | static uint32_t lcd_get_aligned_size(vidinfo_t *vid) |
paul@100 | 121 | { |
paul@100 | 122 | /* LCD_CTRL_BST_16 requires 16-word alignment. */ |
paul@227 | 123 | |
paul@217 | 124 | return ALIGN(lcd_get_size(vid), 16 * sizeof(uint32_t)); |
paul@100 | 125 | } |
paul@100 | 126 | |
paul@217 | 127 | static uint32_t lcd_get_min_size(vidinfo_t *vid) |
paul@100 | 128 | { |
paul@100 | 129 | /* Lines must be aligned to a word boundary. */ |
paul@227 | 130 | |
paul@221 | 131 | uint32_t line_length = ALIGN((vid->jz_fb->w * 32) / 8, sizeof(uint32_t)); |
paul@221 | 132 | return line_length * vid->jz_fb->h; |
paul@100 | 133 | } |
paul@100 | 134 | |
paul@217 | 135 | static uint32_t lcd_get_aligned_min_size(vidinfo_t *vid) |
paul@100 | 136 | { |
paul@100 | 137 | /* LCD_CTRL_BST_16 requires 16-word alignment. */ |
paul@227 | 138 | |
paul@217 | 139 | return ALIGN(lcd_get_min_size(vid), 16 * sizeof(uint32_t)); |
paul@100 | 140 | } |
paul@100 | 141 | |
paul@217 | 142 | static uint32_t lcd_get_palette_size(vidinfo_t *vid) |
paul@97 | 143 | { |
paul@224 | 144 | /* Get a collection of two-byte entries, one per colour. */ |
paul@224 | 145 | |
paul@221 | 146 | if (vid->jz_fb->bpp < 12) |
paul@221 | 147 | return (1 << (vid->jz_fb->bpp)) * sizeof(uint16_t); |
paul@102 | 148 | else |
paul@102 | 149 | return 0; |
paul@97 | 150 | } |
paul@97 | 151 | |
paul@217 | 152 | static uint32_t lcd_get_aligned_palette_size(vidinfo_t *vid) |
paul@100 | 153 | { |
paul@100 | 154 | /* LCD_CTRL_BST_16 requires 16-word alignment. */ |
paul@217 | 155 | return ALIGN(lcd_get_palette_size(vid), 16 * sizeof(uint32_t)); |
paul@100 | 156 | } |
paul@100 | 157 | |
paul@217 | 158 | static uint32_t lcd_get_descriptors_size() |
paul@98 | 159 | { |
paul@98 | 160 | return 3 * sizeof(struct jz_fb_dma_descriptor); |
paul@98 | 161 | } |
paul@98 | 162 | |
paul@102 | 163 | |
paul@102 | 164 | |
paul@102 | 165 | /* Functions returning addresses of each data region. */ |
paul@102 | 166 | |
paul@224 | 167 | static uint32_t lcd_get_palette(vidinfo_t *vid) |
paul@93 | 168 | { |
paul@224 | 169 | /* Use memory at the end of the allocated region for the palette. */ |
paul@224 | 170 | |
paul@227 | 171 | return vid->jz_mem.screen + vid->jz_mem.total - lcd_get_aligned_palette_size(vid); |
paul@98 | 172 | } |
paul@98 | 173 | |
paul@224 | 174 | static uint32_t lcd_get_descriptors(vidinfo_t *vid) |
paul@98 | 175 | { |
paul@224 | 176 | /* Use memory before the palette for the descriptor array. */ |
paul@224 | 177 | |
paul@224 | 178 | return lcd_get_palette(vid) - lcd_get_descriptors_size(); |
paul@48 | 179 | } |
paul@48 | 180 | |
paul@227 | 181 | static uint32_t lcd_get_framebuffer(uint8_t panel, vidinfo_t *vid) |
paul@97 | 182 | { |
paul@224 | 183 | /* Framebuffers for panels are allocated at the start of the region. */ |
paul@224 | 184 | |
paul@227 | 185 | return vid->jz_mem.screen + (panel * lcd_get_aligned_size(vid)); |
paul@97 | 186 | } |
paul@97 | 187 | |
paul@102 | 188 | |
paul@102 | 189 | |
paul@102 | 190 | /* Initialisation functions. */ |
paul@102 | 191 | |
paul@221 | 192 | static uint32_t jz_lcd_stn_init(uint32_t stnH, vidinfo_t *vid) |
paul@96 | 193 | { |
paul@221 | 194 | struct jzfb_info *jzfb = vid->jz_fb; |
paul@217 | 195 | uint32_t val = 0; |
paul@96 | 196 | |
paul@221 | 197 | switch (jzfb->bpp) { |
paul@223 | 198 | case 1: |
paul@96 | 199 | /* val |= LCD_CTRL_PEDN; */ |
paul@223 | 200 | case 2: |
paul@96 | 201 | val |= LCD_CTRL_FRC_2; |
paul@96 | 202 | break; |
paul@223 | 203 | |
paul@223 | 204 | case 4: |
paul@96 | 205 | val |= LCD_CTRL_FRC_4; |
paul@96 | 206 | break; |
paul@223 | 207 | |
paul@223 | 208 | case 8: |
paul@223 | 209 | default: |
paul@96 | 210 | val |= LCD_CTRL_FRC_16; |
paul@96 | 211 | break; |
paul@96 | 212 | } |
paul@96 | 213 | |
paul@221 | 214 | switch (jzfb->cfg & STN_DAT_PINMASK) { |
paul@223 | 215 | case STN_DAT_PIN1: |
paul@96 | 216 | /* Do not adjust the hori-param value. */ |
paul@96 | 217 | break; |
paul@223 | 218 | |
paul@223 | 219 | case STN_DAT_PIN2: |
paul@223 | 220 | align2(&jzfb->hsw); |
paul@223 | 221 | align2(&jzfb->elw); |
paul@223 | 222 | align2(&jzfb->blw); |
paul@96 | 223 | break; |
paul@223 | 224 | |
paul@223 | 225 | case STN_DAT_PIN4: |
paul@223 | 226 | align4(&jzfb->hsw); |
paul@223 | 227 | align4(&jzfb->elw); |
paul@223 | 228 | align4(&jzfb->blw); |
paul@96 | 229 | break; |
paul@223 | 230 | |
paul@223 | 231 | case STN_DAT_PIN8: |
paul@223 | 232 | align8(&jzfb->hsw); |
paul@223 | 233 | align8(&jzfb->elw); |
paul@223 | 234 | align8(&jzfb->blw); |
paul@96 | 235 | break; |
paul@96 | 236 | } |
paul@96 | 237 | |
paul@223 | 238 | lcd_ctrl_set(vid, LCD_VSYNC, jzfb->vsw); |
paul@224 | 239 | lcd_ctrl_set(vid, LCD_HSYNC, ((jzfb->blw + jzfb->w) << 16) | (jzfb->blw + jzfb->w + jzfb->hsw)); |
paul@96 | 240 | |
paul@96 | 241 | /* Screen setting */ |
paul@223 | 242 | lcd_ctrl_set(vid, LCD_VAT, ((jzfb->blw + jzfb->w + jzfb->hsw + jzfb->elw) << 16) | (stnH + jzfb->vsw + jzfb->bfw + jzfb->efw)); |
paul@223 | 243 | lcd_ctrl_set(vid, LCD_DAH, (jzfb->blw << 16) | (jzfb->blw + jzfb->w)); |
paul@223 | 244 | lcd_ctrl_set(vid, LCD_DAV, stnH); |
paul@96 | 245 | |
paul@96 | 246 | /* AC BIAs signal */ |
paul@223 | 247 | lcd_ctrl_set(vid, LCD_PS, stnH+jzfb->vsw+jzfb->efw+jzfb->bfw); |
paul@96 | 248 | |
paul@96 | 249 | return val; |
paul@96 | 250 | } |
paul@96 | 251 | |
paul@221 | 252 | static void jz_lcd_tft_init(vidinfo_t *vid) |
paul@96 | 253 | { |
paul@221 | 254 | struct jzfb_info *jzfb = vid->jz_fb; |
paul@224 | 255 | |
paul@223 | 256 | lcd_ctrl_set(vid, LCD_VSYNC, jzfb->vsw); |
paul@223 | 257 | lcd_ctrl_set(vid, LCD_HSYNC, jzfb->hsw); |
paul@224 | 258 | lcd_ctrl_set(vid, LCD_DAV, ((jzfb->vsw + jzfb->bfw) << 16) | (jzfb->vsw + jzfb->bfw + jzfb->h)); |
paul@223 | 259 | lcd_ctrl_set(vid, LCD_DAH, ((jzfb->hsw + jzfb->blw) << 16) | (jzfb->hsw + jzfb->blw + jzfb->w)); |
paul@223 | 260 | lcd_ctrl_set(vid, LCD_VAT, (((jzfb->blw + jzfb->w + jzfb->elw + jzfb->hsw)) << 16) | |
paul@223 | 261 | (jzfb->vsw + jzfb->bfw + jzfb->h + jzfb->efw)); |
paul@96 | 262 | } |
paul@96 | 263 | |
paul@223 | 264 | static void jz_lcd_samsung_init(vidinfo_t *vid) |
paul@106 | 265 | { |
paul@221 | 266 | struct jzfb_info *jzfb = vid->jz_fb; |
paul@224 | 267 | uint32_t pclk = lcd_get_pixel_clock(vid); |
paul@217 | 268 | uint32_t total, tp_s, tp_e, ckv_s, ckv_e; |
paul@217 | 269 | uint32_t rev_s, rev_e, inv_s, inv_e; |
paul@106 | 270 | |
paul@221 | 271 | jz_lcd_tft_init(vid); |
paul@106 | 272 | |
paul@221 | 273 | total = jzfb->blw + jzfb->w + jzfb->elw + jzfb->hsw; |
paul@221 | 274 | tp_s = jzfb->blw + jzfb->w + 1; |
paul@106 | 275 | tp_e = tp_s + 1; |
paul@106 | 276 | /* ckv_s = tp_s - jz_clocks.pixclk/(1000000000/4100); */ |
paul@106 | 277 | ckv_s = tp_s - pclk/(1000000000/4100); |
paul@106 | 278 | ckv_e = tp_s + total; |
paul@106 | 279 | rev_s = tp_s - 11; /* -11.5 clk */ |
paul@106 | 280 | rev_e = rev_s + total; |
paul@106 | 281 | inv_s = tp_s; |
paul@106 | 282 | inv_e = inv_s + total; |
paul@223 | 283 | lcd_ctrl_set(vid, LCD_CLS, (tp_s << 16) | tp_e); |
paul@223 | 284 | lcd_ctrl_set(vid, LCD_PS, (ckv_s << 16) | ckv_e); |
paul@223 | 285 | lcd_ctrl_set(vid, LCD_SPL, (rev_s << 16) | rev_e); |
paul@223 | 286 | lcd_ctrl_set(vid, LCD_REV, (inv_s << 16) | inv_e); |
paul@221 | 287 | jzfb->cfg |= STFT_REVHI | STFT_SPLHI; |
paul@106 | 288 | } |
paul@106 | 289 | |
paul@221 | 290 | static void jz_lcd_sharp_init(vidinfo_t *vid) |
paul@106 | 291 | { |
paul@221 | 292 | struct jzfb_info *jzfb = vid->jz_fb; |
paul@217 | 293 | uint32_t total, cls_s, cls_e, ps_s, ps_e; |
paul@217 | 294 | uint32_t spl_s, spl_e, rev_s, rev_e; |
paul@106 | 295 | |
paul@221 | 296 | jz_lcd_tft_init(vid); |
paul@106 | 297 | |
paul@221 | 298 | total = jzfb->blw + jzfb->w + jzfb->elw + jzfb->hsw; |
paul@106 | 299 | spl_s = 1; |
paul@106 | 300 | spl_e = spl_s + 1; |
paul@106 | 301 | cls_s = 0; |
paul@106 | 302 | cls_e = total - 60; /* > 4us (pclk = 80ns) */ |
paul@106 | 303 | ps_s = cls_s; |
paul@106 | 304 | ps_e = cls_e; |
paul@106 | 305 | rev_s = total - 40; /* > 3us (pclk = 80ns) */ |
paul@106 | 306 | rev_e = rev_s + total; |
paul@221 | 307 | jzfb->cfg |= STFT_PSHI; |
paul@223 | 308 | lcd_ctrl_set(vid, LCD_SPL, (spl_s << 16) | spl_e); |
paul@223 | 309 | lcd_ctrl_set(vid, LCD_CLS, (cls_s << 16) | cls_e); |
paul@223 | 310 | lcd_ctrl_set(vid, LCD_PS, (ps_s << 16) | ps_e); |
paul@223 | 311 | lcd_ctrl_set(vid, LCD_REV, (rev_s << 16) | rev_e); |
paul@98 | 312 | } |
paul@98 | 313 | |
paul@33 | 314 | |
paul@96 | 315 | |
paul@223 | 316 | /* Palette initialisation. */ |
paul@102 | 317 | |
paul@217 | 318 | static inline uint16_t rgb8_to_rgb16(uint8_t rgb) |
paul@102 | 319 | { |
paul@103 | 320 | return ((((rgb & 0xe0) >> 5) * 4) << 11) | ((((rgb & 0x1c) >> 2) * 9) << 6) | ((rgb & 0x03) * 10); |
paul@103 | 321 | } |
paul@103 | 322 | |
paul@217 | 323 | static inline uint16_t rgb4_to_rgb16(uint8_t rgb) |
paul@103 | 324 | { |
paul@103 | 325 | return ((((rgb & 8) >> 3) * 0x1f) << 11) | ((((rgb & 6) >> 1) * 0x15) << 5) | ((rgb & 1) * 0x1f); |
paul@102 | 326 | } |
paul@102 | 327 | |
paul@102 | 328 | static void lcd_init_palette(vidinfo_t *vid) |
paul@102 | 329 | { |
paul@223 | 330 | uint16_t *palette = (uint16_t *) vid->jz_mem.palette; |
paul@221 | 331 | uint16_t *end = (uint16_t *) palette + (1 << (vid->jz_fb->bpp)); |
paul@217 | 332 | uint8_t value = 0; |
paul@102 | 333 | |
paul@102 | 334 | while (palette < end) |
paul@102 | 335 | { |
paul@221 | 336 | switch (vid->jz_fb->bpp) |
paul@103 | 337 | { |
paul@221 | 338 | case 4: |
paul@103 | 339 | *palette = rgb4_to_rgb16(value); |
paul@103 | 340 | break; |
paul@103 | 341 | |
paul@221 | 342 | case 8: |
paul@103 | 343 | default: |
paul@103 | 344 | *palette = rgb8_to_rgb16(value); |
paul@103 | 345 | break; |
paul@103 | 346 | } |
paul@103 | 347 | |
paul@102 | 348 | value++; |
paul@102 | 349 | palette++; |
paul@102 | 350 | } |
paul@33 | 351 | } |
paul@33 | 352 | |
paul@223 | 353 | |
paul@223 | 354 | |
paul@227 | 355 | /* Public functions. */ |
paul@227 | 356 | |
paul@227 | 357 | /* Return the total size of the required memory. */ |
paul@223 | 358 | |
paul@227 | 359 | uint32_t jz4740_lcd_get_total_size(vidinfo_t *vid) |
paul@227 | 360 | { |
paul@227 | 361 | uint32_t size = lcd_get_aligned_size(vid) * lcd_get_panels(vid); |
paul@227 | 362 | uint32_t min_size = lcd_get_aligned_min_size(vid); |
paul@227 | 363 | |
paul@227 | 364 | /* Round up to nearest full page, or MMU section if defined. */ |
paul@223 | 365 | |
paul@227 | 366 | return ALIGN((size >= min_size ? size : min_size) + |
paul@227 | 367 | lcd_get_aligned_palette_size(vid) + lcd_get_descriptors_size(), |
paul@227 | 368 | PAGE_SIZE); |
paul@227 | 369 | } |
paul@223 | 370 | |
paul@227 | 371 | /* Return the calculated pixel clock frequency for the display. */ |
paul@227 | 372 | |
paul@227 | 373 | uint32_t jz4740_lcd_get_pixel_clock(vidinfo_t *vid) |
paul@227 | 374 | { |
paul@227 | 375 | return lcd_get_pixel_clock(vid); |
paul@223 | 376 | } |
paul@223 | 377 | |
paul@224 | 378 | /* Initialise the LCD controller with the memory, panel and framebuffer details. |
paul@224 | 379 | Return the pixel clock frequency. */ |
paul@224 | 380 | |
paul@227 | 381 | void jz4740_lcd_ctrl_init(void *lcd_base, void *fb_vaddr, vidinfo_t *vid) |
paul@224 | 382 | { |
paul@224 | 383 | struct jz_mem_info *fbi = &vid->jz_mem; |
paul@227 | 384 | struct jz_fb_dma_descriptor *descriptors; |
paul@224 | 385 | |
paul@224 | 386 | /* Set the LCD controller address. */ |
paul@224 | 387 | |
paul@224 | 388 | vid->lcd = lcd_base; |
paul@224 | 389 | |
paul@227 | 390 | /* Initialise the total region size. */ |
paul@227 | 391 | |
paul@227 | 392 | fbi->total = jz4740_lcd_get_total_size(vid); |
paul@227 | 393 | |
paul@227 | 394 | /* Obtain a reference to the descriptors. */ |
paul@227 | 395 | |
paul@227 | 396 | descriptors = (struct jz_fb_dma_descriptor *) lcd_get_descriptors(vid); |
paul@227 | 397 | |
paul@224 | 398 | /* Position framebuffer regions at the given address. */ |
paul@224 | 399 | |
paul@224 | 400 | fbi->screen = (uint32_t) fb_vaddr; |
paul@224 | 401 | |
paul@224 | 402 | /* Obtain the palette address. */ |
paul@224 | 403 | |
paul@224 | 404 | fbi->palette = lcd_get_palette(vid); |
paul@224 | 405 | |
paul@224 | 406 | /* Initialise a palette for lower colour depths. */ |
paul@224 | 407 | |
paul@224 | 408 | if (vid->jz_fb->bpp < 12) |
paul@224 | 409 | lcd_init_palette(vid); |
paul@224 | 410 | |
paul@224 | 411 | /* Reference the descriptors in memory. */ |
paul@224 | 412 | |
paul@224 | 413 | fbi->dmadesc_fb0 = &descriptors[0]; |
paul@224 | 414 | fbi->dmadesc_fb1 = &descriptors[1]; |
paul@224 | 415 | fbi->dmadesc_palette = &descriptors[2]; |
paul@224 | 416 | |
paul@224 | 417 | /* Populate descriptors. */ |
paul@224 | 418 | |
paul@224 | 419 | /* Provide the first framebuffer descriptor in single and dual modes. */ |
paul@224 | 420 | |
paul@224 | 421 | fbi->dmadesc_fb0->fsadr = lcd_get_framebuffer(0, vid); |
paul@224 | 422 | fbi->dmadesc_fb0->fidr = 0; |
paul@224 | 423 | fbi->dmadesc_fb0->ldcmd = lcd_get_size(vid) / 4; /* length in words */ |
paul@224 | 424 | |
paul@224 | 425 | /* Provide the second framebuffer descriptor only in dual-panel mode. */ |
paul@224 | 426 | |
paul@224 | 427 | if (lcd_get_panels(vid) == 2) |
paul@224 | 428 | { |
paul@224 | 429 | fbi->dmadesc_fb1->fdadr = fbi->dmadesc_fb1; |
paul@224 | 430 | fbi->dmadesc_fb1->fsadr = lcd_get_framebuffer(1, vid); |
paul@224 | 431 | fbi->dmadesc_fb1->fidr = 0; |
paul@224 | 432 | fbi->dmadesc_fb1->ldcmd = lcd_get_size(vid) / 4; |
paul@224 | 433 | |
paul@224 | 434 | /* Note the address to be provided for the second channel. */ |
paul@224 | 435 | |
paul@224 | 436 | fbi->fdadr1 = fbi->dmadesc_fb1; |
paul@224 | 437 | } |
paul@224 | 438 | |
paul@224 | 439 | /* Initialise palette descriptor details if a palette is to be used. */ |
paul@224 | 440 | |
paul@224 | 441 | /* Assume any mode with <12 bpp is palette driven. */ |
paul@224 | 442 | |
paul@224 | 443 | if (vid->jz_fb->bpp < 12) |
paul@224 | 444 | { |
paul@224 | 445 | fbi->dmadesc_palette->fsadr = fbi->palette; |
paul@224 | 446 | fbi->dmadesc_palette->fidr = 0; |
paul@224 | 447 | fbi->dmadesc_palette->ldcmd = (lcd_get_palette_size(vid) / 4) | LCD_CMD_PAL; |
paul@224 | 448 | |
paul@224 | 449 | /* Flip back and forth between the palette and framebuffer. */ |
paul@224 | 450 | |
paul@224 | 451 | fbi->dmadesc_palette->fdadr = fbi->dmadesc_fb0; |
paul@224 | 452 | fbi->dmadesc_fb0->fdadr = fbi->dmadesc_palette; |
paul@224 | 453 | |
paul@224 | 454 | /* Provide the palette descriptor address first. */ |
paul@224 | 455 | |
paul@224 | 456 | fbi->fdadr0 = fbi->dmadesc_palette; |
paul@224 | 457 | } |
paul@224 | 458 | else |
paul@224 | 459 | { |
paul@224 | 460 | /* No palette: always use the framebuffer descriptor. */ |
paul@224 | 461 | |
paul@224 | 462 | fbi->dmadesc_fb0->fdadr = fbi->dmadesc_fb0; |
paul@224 | 463 | fbi->fdadr0 = fbi->dmadesc_fb0; |
paul@224 | 464 | } |
paul@224 | 465 | } |
paul@224 | 466 | |
paul@224 | 467 | /* Initialise the LCD registers. */ |
paul@224 | 468 | |
paul@227 | 469 | void jz4740_lcd_hw_init(vidinfo_t *vid) |
paul@223 | 470 | { |
paul@223 | 471 | struct jzfb_info *jzfb = vid->jz_fb; |
paul@223 | 472 | uint32_t val = 0; |
paul@223 | 473 | |
paul@223 | 474 | /* Compute control register flags. */ |
paul@223 | 475 | |
paul@223 | 476 | switch (jzfb->bpp) { |
paul@223 | 477 | case 1: |
paul@223 | 478 | val |= LCD_CTRL_BPP_1; |
paul@223 | 479 | break; |
paul@223 | 480 | |
paul@223 | 481 | case 2: |
paul@223 | 482 | val |= LCD_CTRL_BPP_2; |
paul@223 | 483 | break; |
paul@223 | 484 | |
paul@223 | 485 | case 4: |
paul@223 | 486 | val |= LCD_CTRL_BPP_4; |
paul@223 | 487 | break; |
paul@223 | 488 | |
paul@223 | 489 | case 8: |
paul@223 | 490 | val |= LCD_CTRL_BPP_8; |
paul@223 | 491 | break; |
paul@223 | 492 | |
paul@223 | 493 | case 15: |
paul@223 | 494 | val |= LCD_CTRL_RGB555; |
paul@223 | 495 | case 16: |
paul@223 | 496 | val |= LCD_CTRL_BPP_16; |
paul@223 | 497 | break; |
paul@223 | 498 | |
paul@223 | 499 | case 17 ... 32: |
paul@223 | 500 | val |= LCD_CTRL_BPP_18_24; /* target is 4bytes/pixel */ |
paul@223 | 501 | break; |
paul@223 | 502 | |
paul@223 | 503 | default: |
paul@223 | 504 | val |= LCD_CTRL_BPP_16; /* default to 16bpp */ |
paul@223 | 505 | break; |
paul@223 | 506 | } |
paul@223 | 507 | |
paul@223 | 508 | /* Set various configuration registers for the panel. */ |
paul@223 | 509 | |
paul@223 | 510 | switch (jzfb->cfg & MODE_MASK) { |
paul@223 | 511 | case MODE_STN_MONO_DUAL: |
paul@223 | 512 | case MODE_STN_COLOR_DUAL: |
paul@223 | 513 | val |= jz_lcd_stn_init(jzfb->h >> 1, vid); |
paul@223 | 514 | break; |
paul@223 | 515 | |
paul@223 | 516 | case MODE_STN_MONO_SINGLE: |
paul@223 | 517 | case MODE_STN_COLOR_SINGLE: |
paul@223 | 518 | val |= jz_lcd_stn_init(jzfb->h, vid); |
paul@223 | 519 | break; |
paul@223 | 520 | |
paul@223 | 521 | case MODE_TFT_GEN: |
paul@223 | 522 | case MODE_TFT_CASIO: |
paul@223 | 523 | case MODE_8BIT_SERIAL_TFT: |
paul@223 | 524 | case MODE_TFT_18BIT: |
paul@223 | 525 | jz_lcd_tft_init(vid); |
paul@223 | 526 | break; |
paul@223 | 527 | |
paul@223 | 528 | case MODE_TFT_SAMSUNG: |
paul@223 | 529 | jz_lcd_samsung_init(vid); |
paul@223 | 530 | break; |
paul@223 | 531 | |
paul@223 | 532 | case MODE_TFT_SHARP: |
paul@223 | 533 | jz_lcd_sharp_init(vid); |
paul@223 | 534 | break; |
paul@223 | 535 | |
paul@223 | 536 | default: |
paul@223 | 537 | break; |
paul@223 | 538 | } |
paul@223 | 539 | |
paul@224 | 540 | /* Further control register and panel configuration. */ |
paul@223 | 541 | |
paul@223 | 542 | val |= LCD_CTRL_BST_16; /* Burst Length is 16WORD=64Byte */ |
paul@223 | 543 | val |= LCD_CTRL_OFUP; /* OutFIFO underrun protect */ |
paul@223 | 544 | |
paul@223 | 545 | lcd_ctrl_set(vid, LCD_CTRL, val); |
paul@223 | 546 | lcd_ctrl_set(vid, LCD_CFG, jzfb->cfg); |
paul@223 | 547 | } |
paul@223 | 548 | |
paul@223 | 549 | /* Initialise DMA for the driver. */ |
paul@223 | 550 | |
paul@227 | 551 | void jz4740_lcd_dma_init(vidinfo_t *vid) |
paul@223 | 552 | { |
paul@224 | 553 | struct jz_mem_info *fbi = &vid->jz_mem; |
paul@224 | 554 | uint32_t mode = vid->jz_fb->cfg & MODE_MASK; |
paul@223 | 555 | |
paul@224 | 556 | /* Configure DMA by setting frame descriptor addresses. */ |
paul@223 | 557 | |
paul@223 | 558 | lcd_ctrl_set(vid, LCD_DA0, (uint32_t) fbi->fdadr0); |
paul@223 | 559 | |
paul@223 | 560 | if ((mode == MODE_STN_COLOR_DUAL) || (mode == MODE_STN_MONO_DUAL)) |
paul@223 | 561 | lcd_ctrl_set(vid, LCD_DA1, (uint32_t) fbi->fdadr1); |
paul@223 | 562 | } |
paul@223 | 563 | |
paul@224 | 564 | /* Set the colour depth. */ |
paul@223 | 565 | |
paul@229 | 566 | void jz4740_lcd_set_bpp(uint8_t bpp, vidinfo_t *vid) |
paul@223 | 567 | { |
paul@224 | 568 | vid->jz_fb->bpp = bpp; |
paul@223 | 569 | } |
paul@223 | 570 | |
paul@229 | 571 | void jz4740_lcd_enable(vidinfo_t *vid) |
paul@223 | 572 | { |
paul@223 | 573 | /* Clear the disable bit (DIS) and set the enable bit (ENA). */ |
paul@223 | 574 | |
paul@223 | 575 | lcd_ctrl_set(vid, LCD_CTRL, (lcd_ctrl_get(vid, LCD_CTRL) & ~LCD_CTRL_DIS) | LCD_CTRL_ENA); |
paul@223 | 576 | } |
paul@223 | 577 | |
paul@229 | 578 | void jz4740_lcd_disable(vidinfo_t *vid) |
paul@223 | 579 | { |
paul@223 | 580 | /* Set the disable bit (DIS). */ |
paul@223 | 581 | |
paul@223 | 582 | lcd_ctrl_set(vid, LCD_CTRL, lcd_ctrl_get(vid, LCD_CTRL) | LCD_CTRL_DIS); |
paul@223 | 583 | } |
paul@223 | 584 | |
paul@229 | 585 | void jz4740_lcd_quick_disable(vidinfo_t *vid) |
paul@223 | 586 | { |
paul@223 | 587 | /* Clear the enable bit (ENA) for quick disable. */ |
paul@223 | 588 | |
paul@223 | 589 | lcd_ctrl_set(vid, LCD_CTRL, lcd_ctrl_get(vid, LCD_CTRL) & ~LCD_CTRL_ENA); |
paul@223 | 590 | } |