static void gdc_sw_reset(void)
{
GraphicDevice *pGD = (GraphicDevice *)&mb862xx;
HOST_WR_REG (0x002c, 0x00000001);
udelay (500);
video_hw_init ();
}
static void gdc_sw_reset (void)
{
GraphicDevice *dev = &mb862xx;
HOST_WR_REG (GC_SRST, 0x1);
udelay (500);
video_hw_init ();
}
static int do_osd_open(cmd_tbl_t *cmdtp, int flag, int argc,
char *const argv[])
{
gdev = video_hw_init();
if (gdev == NULL) {
printf("Initialize video device failed!\n");
return 1;
}
return 0;
}
void video_select_renderer(int renderer) {
if(renderer == state.cur_renderer) {
return;
}
state.cb.render_close(&state);
state.cur_renderer = renderer;
switch(renderer) {
case VIDEO_RENDERER_QUIRKS:
video_soft_init(&state);
break;
case VIDEO_RENDERER_HW:
video_hw_init(&state);
break;
}
}
int video_init(int window_w,
int window_h,
int fullscreen,
int vsync,
const char* scaler_name,
int scale_factor) {
state.w = window_w;
state.h = window_h;
state.fs = fullscreen;
state.vsync = vsync;
state.fade = 1.0f;
state.target = NULL;
state.target_move_x = 0;
state.target_move_y = 0;
// Load scaler (if any)
memset(state.scaler_name, 0, sizeof(state.scaler_name));
strncpy(state.scaler_name, scaler_name, sizeof(state.scaler_name)-1);
if(video_load_scaler(scaler_name, scale_factor)) {
DEBUG("Scaler \"%s\" plugin not found; using Nearest neighbour scaling.", scaler_name);
state.scale_factor = 1;
} else {
DEBUG("Scaler \"%s\" loaded w/ factor %d", scaler_name, scale_factor);
state.scale_factor = scale_factor;
}
// Clear palettes
state.cur_palette = malloc(sizeof(screen_palette));
state.base_palette = malloc(sizeof(palette));
memset(state.cur_palette, 0, sizeof(screen_palette));
state.cur_palette->version = 1;
// Form title string
char title[32];
sprintf(title, "OpenOMF v%d.%d.%d", V_MAJOR, V_MINOR, V_PATCH);
// Open window
state.window = SDL_CreateWindow(
title,
SDL_WINDOWPOS_CENTERED,
SDL_WINDOWPOS_CENTERED,
window_w,
window_h,
SDL_WINDOW_SHOWN);
if(state.window == NULL) {
PERROR("Could not create window: %s", SDL_GetError());
return 1;
}
// Set fullscreen if needed
if(state.fs) {
if(SDL_SetWindowFullscreen(state.window, SDL_WINDOW_FULLSCREEN) != 0) {
PERROR("Could not set fullscreen mode!");
} else {
DEBUG("Fullscreen enabled!");
}
} else {
SDL_SetWindowFullscreen(state.window, 0);
}
// Form flags
int renderer_flags = SDL_RENDERER_ACCELERATED;
if(state.vsync) {
renderer_flags |= SDL_RENDERER_PRESENTVSYNC;
}
// Create renderer
state.renderer = SDL_CreateRenderer(
state.window,
-1,
renderer_flags);
if(state.renderer == NULL) {
PERROR("Could not create renderer: %s", SDL_GetError());
return 1;
}
// Default resolution for renderer. This will them get scaled up to screen size.
SDL_RenderSetLogicalSize(state.renderer,
NATIVE_W * state.scale_factor,
NATIVE_H * state.scale_factor);
// Disable screensaver :/
SDL_DisableScreenSaver();
// Set rendertargets
reset_targets();
// Init texture cache
tcache_init(state.renderer, state.scale_factor, &state.scaler);
// Init hardware renderer
state.cur_renderer = VIDEO_RENDERER_HW;
video_hw_init(&state);
// Get renderer data
SDL_RendererInfo rinfo;
SDL_GetRendererInfo(state.renderer, &rinfo);
// Show some info
INFO("Video Init OK");
INFO(" * Driver: %s", SDL_GetCurrentVideoDriver());
INFO(" * Renderer: %s", rinfo.name);
INFO(" * Accelerated: %s", (rinfo.flags & SDL_RENDERER_ACCELERATED) ? "Yes" : "No");
INFO(" * VSync support: %s", (rinfo.flags & SDL_RENDERER_PRESENTVSYNC) ? "Yes" : "No");
INFO(" * Target support: %s", (rinfo.flags & SDL_RENDERER_TARGETTEXTURE) ? "Yes" : "No");
return 0;
}
void lcd_ctrl_init(void *lcdbase)
{
int color_depth = 24;
char *vm;
unsigned long val;
int refresh = 60;
struct fb_videomode *p = &tx28_fb_modes[0];
int xres_set = 0, yres_set = 0, bpp_set = 0, refresh_set = 0;
if (!lcd_enabled) {
debug("LCD disabled\n");
return;
}
if (tstc()) {
debug("Disabling LCD\n");
lcd_enabled = 0;
return;
}
vm = getenv("video_mode");
if (vm == NULL) {
debug("Disabling LCD\n");
lcd_enabled = 0;
return;
}
while (p->name != NULL) {
if (strcmp(p->name, vm) == 0) {
printf("Using video mode: '%s'\n", p->name);
vm += strlen(vm);
break;
}
p++;
}
while (*vm != '\0') {
if (*vm >= '0' && *vm <= '9') {
char *end;
val = simple_strtoul(vm, &end, 0);
if (end > vm) {
if (!xres_set) {
if (val > panel_info.vl_col)
val = panel_info.vl_col;
p->xres = val;
xres_set = 1;
} else if (!yres_set) {
if (val > panel_info.vl_row)
val = panel_info.vl_row;
p->yres = val;
yres_set = 1;
} else if (!bpp_set) {
switch (val) {
case 8:
case 16:
case 18:
case 24:
color_depth = val;
break;
default:
printf("Invalid color depth: '%.*s' in video_mode; using default: '%u'\n",
end - vm, vm, color_depth);
}
bpp_set = 1;
} else if (!refresh_set) {
refresh = val;
refresh_set = 1;
}
}
vm = end;
}
switch (*vm) {
case '@':
bpp_set = 1;
/* fallthru */
case '-':
yres_set = 1;
/* fallthru */
case 'x':
xres_set = 1;
/* fallthru */
case 'M':
case 'R':
vm++;
break;
default:
if (*vm != '\0')
vm++;
}
}
if (p->xres == 0 || p->yres == 0) {
printf("Invalid video mode: %s\n", getenv("video_mode"));
lcd_enabled = 0;
printf("Supported video modes are:");
for (p = &tx28_fb_modes[0]; p->name != NULL; p++) {
printf(" %s", p->name);
}
printf("\n");
return;
}
p->pixclock = KHZ2PICOS(refresh *
(p->xres + p->left_margin + p->right_margin + p->hsync_len) *
(p->yres + p->upper_margin + p->lower_margin + p->vsync_len) /
1000);
debug("Pixel clock set to %lu.%03lu MHz\n",
PICOS2KHZ(p->pixclock) / 1000, PICOS2KHZ(p->pixclock) % 1000);
gpio_request_array(stk5_lcd_gpios, ARRAY_SIZE(stk5_lcd_gpios));
mxs_iomux_setup_multiple_pads(stk5_lcd_pads,
ARRAY_SIZE(stk5_lcd_pads));
debug("video format: %ux%u-%u@%u\n", p->xres, p->yres,
color_depth, refresh);
if (karo_load_splashimage(0) == 0) {
debug("Initializing LCD controller\n");
mxsfb_init(p, PIX_FMT_RGB24, color_depth);
video_hw_init(lcdbase);
} else {
debug("Skipping initialization of LCD controller\n");
}
}
