← Back to branch summary

~ubuntu-branches/ubuntu/lucid/skyeye/lucid-proposed

« back to all changes in this revision

Viewing changes to device/lcd/skyeye_lcd.c

  • Committer: Bazaar Package Importer
  • Author(s): Yu Guanghui
  • Date: 2007-08-07 13:25:49 UTC
  • mfrom: (1.1.2 upstream) (2.1.1 lenny)
  • Revision ID: james.westby@ubuntu.com-20070807132549-96159k1obat1fxr0
Tags: 1.2.3-1
http://bugs.debian.org/423933
* New upstream release
* Added NO_BFD=1, don't require libbfd now. (Closes:Bug#423933) 

Show diffs side-by-side

added added

removed removed

Lines of Context:
device/lcd/skyeye_lcd.c
29
29
#include <unistd.h>
30
30
 
31
31
#include "armdefs.h"
 
32
#include "arch/mips/common/mipsdef.h"
32
33
#include "skyeye_device.h"
33
34
#include "skyeye_options.h"
34
35
#include "skyeye.h"
35
36
#include "skyeye_lcd.h"
36
37
 
37
 
unsigned int Pen_buffer[8];
38
 
 
39
38
/* initialize the lcd module set.
40
39
 * If you want to add a new lcd simulation, just add a "lcd_*_init" function to it.
41
40
 * */
46
45
        lcd_pxa_init (mod_set);
47
46
        lcd_s3c2410_init (mod_set);
48
47
        lcd_s3c44b0x_init (mod_set);
 
48
        lcd_au1100_init (mod_set);
49
49
}
50
50
static int
51
51
lcd_setup (struct device_desc *dev, void *option)
63
63
        printf ("lcd_mod:%d\n", lcd_dev->mod);
64
64
        switch (lcd_dev->mod) {
65
65
#ifdef GTK_LCD
66
 
        case LCD_MOD_GTK:
67
 
                lcd_dev->lcd_open = gtk_lcd_open;
68
 
                lcd_dev->lcd_close = gtk_lcd_close;
69
 
                lcd_dev->lcd_update = gtk_lcd_update;
70
 
                lcd_dev->lcd_read = gtk_lcd_read;
71
 
                lcd_dev->lcd_write = gtk_lcd_write;
72
 
                break;
 
66
                case LCD_MOD_GTK:
 
67
                        ret = gtk_lcd_init(lcd_dev);
 
68
                        break;
73
69
#endif
74
70
#ifdef WIN32_LCD
75
 
        case LCD_MOD_WIN32:
76
 
                lcd_dev->lcd_open = win32_lcd_open;
77
 
                lcd_dev->lcd_close = win32_lcd_close;
78
 
                lcd_dev->lcd_update = win32_lcd_update;
79
 
                lcd_dev->lcd_read = win32_lcd_read;
80
 
                lcd_dev->lcd_write = win32_lcd_write;
81
 
                break;
 
71
                case LCD_MOD_WIN32:
 
72
                        ret = win32_lcd_init(lcd_dev);
 
73
                        break;
82
74
#endif
83
75
#ifdef BEOS_LCD
84
 
        case LCD_MOD_BEOS:
85
 
                lcd_dev->lcd_open = beos_lcd_open;
86
 
                lcd_dev->lcd_close = beos_lcd_close;
87
 
                lcd_dev->lcd_update = beos_lcd_update;
88
 
                lcd_dev->lcd_read = beos_lcd_read;
89
 
                lcd_dev->lcd_write = beos_lcd_write;
90
 
                break;
 
76
                case LCD_MOD_BEOS:
 
77
                        ret = beos_lcd_init(lcd_dev);
 
78
                        break;
91
79
#endif
92
 
        default:
 
80
                default:
 
81
                        ret = -1;
 
82
                        break;
 
83
        }
 
84
 
 
85
        if (ret != 0) {
93
86
                free(lcd_dev);
94
87
                lcd_dev = NULL;
95
 
                ret = -1;
96
 
                break;
97
88
        }
98
89
 
99
90
        dev->dev = (void *) lcd_dev;
100
91
        return ret;
 
92
}
101
93
 
102
 
}
103
94
static struct device_module_set lcd_mod_set = {
104
95
        .name = "lcd",
105
96
        .count = 0,
120
111
}
121
112
 
122
113
/* help functions. */
 
114
unsigned char* skyeye_find_lcd_dma (struct lcd_device *lcd_dev)
 
115
{
 
116
        unsigned char *dma = NULL;
 
117
 
 
118
        if (lcd_dev == NULL ||
 
119
            skyeye_config.arch == NULL ||
 
120
            skyeye_config.arch->arch_name == NULL) return NULL;
 
121
 
 
122
        if (strcmp(skyeye_config.arch->arch_name, "arm") == 0) { /* arm */
 
123
                extern mem_bank_t *bank_ptr(ARMword addr);
 
124
                mem_bank_t *mbp;
 
125
                ARMul_State *state = (ARMul_State*)lcd_dev->state;
 
126
 
 
127
                if(!(state == NULL || (mbp = bank_ptr(lcd_dev->lcd_addr_begin)) == NULL)) {
 
128
                        dma = (unsigned char*)(&state->mem.rom[(mbp - state->mem_bank->mem_banks)]
 
129
                                                              [(lcd_dev->lcd_addr_begin - mbp->addr) >> 2]);
 
130
                }
 
131
        }
 
132
 
 
133
        if (strcmp(skyeye_config.arch->arch_name, "mips") == 0) { /* mips */
 
134
                extern mips_mem_state_t mips_mem;
 
135
                extern mips_mem_bank_t *mips_global_mbp;
 
136
                extern mips_mem_config_t mips_mem_config;
 
137
                int i;
 
138
                unsigned long addr, len;
 
139
 
 
140
                for (i = 0; i < mips_mem_config.bank_num; i++) {
 
141
                        addr = mips_mem_config.mem_banks[i].addr;
 
142
                        len = mips_mem_config.mem_banks[i].len;
 
143
                        if (addr <= lcd_dev->lcd_addr_begin && addr + len > lcd_dev->lcd_addr_begin) break;
 
144
                }
 
145
 
 
146
                if (i != mips_mem_config.bank_num) {
 
147
                        dma = (unsigned char*)&(mips_mem.rom[mips_global_mbp - mips_mem_config.mem_banks]
 
148
                                                            [(lcd_dev->lcd_addr_begin - mips_global_mbp->addr) >> 2]);
 
149
                }
 
150
        }
 
151
 
 
152
        /* TODO: blackfin, coldfire, etc. */
 
153
 
 
154
        return dma;
 
155
}
 
156
 
 
157
void skyeye_convert_color_from_lcd_dma (struct lcd_device *lcd,
 
158
                                        int x, int y, int w, int h,
 
159
                                        void (*func)(u32, void*, void*),
 
160
                                        void *user_data1, void *user_data2)
 
161
{
 
162
        const u8 *dma = skyeye_find_lcd_dma(lcd);
 
163
        const u32 *buf;
 
164
        const u16 *buf16;
 
165
        const u8 *buf8;
 
166
        u32 block, color, c;
 
167
        int dx, dy, exw, exb, line_width;
 
168
        int i, k;
 
169
 
 
170
        if (dma == NULL || lcd->lcd_lookup_color == NULL || func == NULL) return;
 
171
        if (!(lcd->depth == 1 || lcd->depth == 2 || lcd->depth == 4 ||
 
172
              lcd->depth == 8 || lcd->depth == 16 || lcd->depth == 32)) return;
 
173
        if (lcd->width <= 0 || x < 0 || w <= 0 || x + w > lcd->width) return;
 
174
        if (lcd->height <= 0 || y < 0 || h <= 0 || y + h > lcd->height) return;
 
175
 
 
176
        line_width = (lcd->width + (int)lcd->lcd_line_offset);
 
177
 
 
178
        for (dy = y; dy < y + h; dy++) {
 
179
 
 
180
                exw = (((line_width * dy + x) * lcd->depth) % 32) / 8;
 
181
                exb = ((line_width * dy + x) * lcd->depth) % 8;
 
182
                buf = (const u32*)(dma + 4 * (((line_width * dy + x) * lcd->depth) / 32));
 
183
 
 
184
                for (dx = x; dx < x + w; buf++) {
 
185
 
 
186
                        block = *buf;
 
187
#ifndef HOST_IS_BIG_ENDIAN
 
188
                        if (lcd->lcd_dma_swap_word == 1) {
 
189
#else
 
190
                        if (lcd->lcd_dma_swap_word == 0) {
 
191
#endif
 
192
                                block = (((block & 0xff) << 24) |
 
193
                                         ((block & 0xff00) << 8) |
 
194
                                         ((block & 0xff0000) >> 8) |
 
195
                                         (block >> 24));
 
196
                        }
 
197
                        buf8 = (u8*)&block;
 
198
                        buf16 = (u16*)&block;
 
199
 
 
200
                        for (i = exw; i < 4 && dx < x + w; exw = 0) {
 
201
                                if (lcd->depth < 16) { /* lcd->depth: 1, 2, 4, 8 */
 
202
                                        color = (u32)(*(buf8 + (lcd->lcd_color_right_to_left == 0 ? i : 3 - i)));
 
203
                                        for (k = exb; k < 8 && dx < x + w; k += lcd->depth, exb = 0) {
 
204
                                                if (lcd->lcd_color_right_to_left == 0)
 
205
                                                        c = ((color >> (8 - (k + lcd->depth))) & ((1 << lcd->depth) - 1));
 
206
                                                else
 
207
                                                        c = ((color >> k) & ((1 << lcd->depth) - 1));
 
208
                                                (*func)(lcd->lcd_lookup_color(lcd, c), user_data1, user_data2);
 
209
                                                dx++;
 
210
                                        }
 
211
                                        i += 1;
 
212
                                }
 
213
                                else if (lcd->depth == 16) {
 
214
                                        if (lcd->lcd_color_right_to_left == 0)
 
215
                                                color = (u32)(*(buf16 + (i == 0 ? 0 : 1)));
 
216
                                        else
 
217
                                                color = (u32)(*(buf16 + (i == 0 ? 1 : 0)));
 
218
                                        (*func)(lcd->lcd_lookup_color(lcd, color), user_data1, user_data2);
 
219
                                        dx++;
 
220
                                        i += 2;
 
221
                                } else { /* lcd->depth: 32 */
 
222
                                        color = block;
 
223
                                        (*func)(lcd->lcd_lookup_color(lcd, color), user_data1, user_data2);
 
224
                                        dx++;
 
225
                                        break;
 
226
                                }
 
227
                        }
 
228
                }
 
229
        }
 
230
}
 
231