URL
https://opencores.org/ocsvn/openrisc/openrisc/trunk
Subversion Repositories openrisc
[/] [openrisc/] [trunk/] [rtos/] [ecos-3.0/] [packages/] [devs/] [framebuf/] [synth/] [current/] [src/] [synthfb.c] - Rev 863
Go to most recent revision | Compare with Previous | Blame | View Log
//========================================================================== // // synthfb.c // // Provide one or more framebuffer devices for the synthetic target. // //========================================================================== // ####ECOSGPLCOPYRIGHTBEGIN#### // ------------------------------------------- // This file is part of eCos, the Embedded Configurable Operating System. // Copyright (C) 2008 Free Software Foundation, Inc. // // eCos is free software; you can redistribute it and/or modify it under // the terms of the GNU General Public License as published by the Free // Software Foundation; either version 2 or (at your option) any later // version. // // eCos is distributed in the hope that it will be useful, but WITHOUT // ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or // FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License // for more details. // // You should have received a copy of the GNU General Public License // along with eCos; if not, write to the Free Software Foundation, Inc., // 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. // // As a special exception, if other files instantiate templates or use // macros or inline functions from this file, or you compile this file // and link it with other works to produce a work based on this file, // this file does not by itself cause the resulting work to be covered by // the GNU General Public License. However the source code for this file // must still be made available in accordance with section (3) of the GNU // General Public License v2. // // This exception does not invalidate any other reasons why a work based // on this file might be covered by the GNU General Public License. // ------------------------------------------- // ####ECOSGPLCOPYRIGHTEND#### //========================================================================== //###DESCRIPTIONBEGIN#### // // Author(s): bartv // Date: 2005-10-28 // //###DESCRIPTIONEND#### //======================================================================== #include <pkgconf/devs_framebuf_synth.h> #include <pkgconf/io_framebuf.h> #include <cyg/io/framebuf.h> #include <errno.h> #include <string.h> #include <cyg/infra/cyg_type.h> #include <cyg/infra/cyg_ass.h> #include <cyg/infra/diag.h> #include <cyg/hal/hal_io.h> #include "protocol.h" // Set the DEBUG_LEVEL to 0 for no debugging, 2 for maximum debugging. #define DEBUG_LEVEL 0 #define DEBUG(_level_, _str_, ...) \ CYG_MACRO_START \ if (_level_ <= DEBUG_LEVEL) { \ diag_printf( _str_, ## __VA_ARGS__); \ } \ CYG_MACRO_END // Achieving high performance graphics operations in the synthetic // target is difficult. Theoretically it might be possible to access // the Linux framebuffer directly using MIT-SHM or DGA. However there // is no practical way to handle the relevant parts of the X prococol, // e.g. expose events. We also don't want to go via the // general-purpose xchgmsg() functionality and a Tcl script, those // are not appropriate for high performance. // // Instead if the I/O auxiliary is running a framebuffer device is // instantiated, and the framebuf.tcl script will start a program // framebuf. That program will create a shared memory region which // then gets mapped into the synthetic target's address space. The // shared memory region holds a synth_fb_data structure followed by // the framebuffer data. If there are multiple framebuffer devices // then there will be multiple invocations of the framebuf program. // // The framebuf program needs to respond to requests from several // different sources. The X server may send events like expose. // The synthetic target application can send synchronization requests, // palette updates, and so on. The X events will come via a socket, // and the requests from framebuf.tcl can come via a pipe. select() // will serve for this. Several mechanisms can be used for the // communication between the synthetic target application and framebuf // including shared memory semaphores and reliable signals. To fit in // neatly with the select() a named fifo is used. // // So assuming a framebuf program is running fb_op() writes a single // byte to the fifo, then waits for framebuf to complete the // operation. That wait also uses a named fifo. This keeps everything // synchronous, and avoids some portability problems between // Linux on various architectures. static void fb_op(cyg_fb* fb, int command) { synth_fb_data* fb_data = (synth_fb_data*) fb->fb_driver2; DEBUG(2, "target synthfb: fb_op %d\n", command); if (fb_data->connected) { cyg_uint8 data[1]; int rc; data[0] = (cyg_uint8)command; do { rc = cyg_hal_sys_write(fb_data->fifo_to_framebuf, (const void*) data, 1); } while (-CYG_HAL_SYS_EINTR == rc); do { rc = cyg_hal_sys_read(fb_data->fifo_from_framebuf, (void*) data, 1); } while (-CYG_HAL_SYS_EINTR == rc); if (rc < 0) { diag_printf("Internal error: unexpected result %d when receiving response from the framebuf program.\n", rc); diag_printf(" : disabling framebuffer device fb%d.\n", fb->fb_driver0); fb_data->connected = 0; } } DEBUG(2, "target synthfb: fb_op %d done\n", command); } // Create a framebuffer device. This gets called from a C++ // static constructor, to ensure that all the framebuffer // windows are created early on during initialization before // the host-side ecosynth support performs any cleanups. void _cyg_synth_fb_instantiate(struct cyg_fb* fb) { synth_fb_data* local_fb_data = (synth_fb_data*) fb->fb_driver2; synth_fb_data* shared_fb_data; char device_data[512]; char fb_name[4]; char* fb_format = 0; char* ptr; char* filename; int fd; int len; int reply; cyg_uint8* fb_base; DEBUG(1, "target synth_fb_instantiate\n"); if (!synth_auxiliary_running) { diag_printf("cyg_synth_fb_instantiate(): no I/O auxiliary, sticking with in-memory framebuffer\n"); return; } diag_sprintf(fb_name, "fb%d", fb->fb_driver0); switch(fb->fb_format) { // Only bother with the formats used by gensynth_fb.tcl case CYG_FB_FORMAT_1BPP_PAL888: { static const cyg_uint8 fb_1bpp_palette[2 * 3] = { 0x00, 0x00, 0x00, // colour 0 == black 0xFF, 0xFF, 0xFF // colour 1 == white }; fb_format = "1BPP_PAL888"; memcpy(local_fb_data->palette, fb_1bpp_palette, sizeof(fb_1bpp_palette)); break; } case CYG_FB_FORMAT_2BPP_PAL888: { static const cyg_uint8 fb_2bpp_palette[4 * 3] = { 0x00, 0x00, 0x00, // colour 0 == black 0x54, 0x54, 0x54, // dark grey 0xA8, 0xA8, 0xA8, // light grey 0xFF, 0xFF, 0xFF // colour 3 == white } ; fb_format = "2BPP_PAL888"; memcpy(local_fb_data->palette, fb_2bpp_palette, sizeof(fb_2bpp_palette)); break; } case CYG_FB_FORMAT_4BPP_PAL888: fb_format = "4BPP_PAL888"; memcpy(local_fb_data->palette, cyg_fb_palette_ega, 16 * 3); break; case CYG_FB_FORMAT_8BPP_PAL888: fb_format = "8BPP_PAL888"; memcpy(local_fb_data->palette, cyg_fb_palette_vga, 256 * 3); break; case CYG_FB_FORMAT_8BPP_TRUE_332: fb_format = "8BPP_TRUE_332"; break; case CYG_FB_FORMAT_16BPP_TRUE_565: fb_format = "16BPP_TRUE_565"; break; case CYG_FB_FORMAT_16BPP_TRUE_555: fb_format = "16BPP_TRUE_555"; break; case CYG_FB_FORMAT_32BPP_TRUE_0888: fb_format = "32BPP_TRUE_0888"; break; } diag_sprintf(device_data, "%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%s", SYNTH_FB_PROTOCOL_VERSION, fb->fb_driver0, /* id 0-3 */ fb->fb_depth, fb->fb_flags0 & CYG_FB_FLAGS0_LE, fb->fb_width, fb->fb_height, #ifdef CYGHWR_IO_FRAMEBUF_FUNCTIONALITY_VIEWPORT fb->fb_viewport_width, fb->fb_viewport_height, #else fb->fb_width, fb->fb_height, #endif fb->fb_stride, fb->fb_driver1, /* number of pages */ fb_format); local_fb_data->devid = synth_auxiliary_instantiate("devs/framebuf/synth", SYNTH_MAKESTRING(CYGPKG_DEVS_FRAMEBUF_SYNTH), "framebuf", fb_name, device_data); if (local_fb_data->devid < 0) { // The I/O auxiliary should have reported a suitable error. // Just stick with an in-memory device. diag_printf("cyg_synth_fb_instantiate(): failed to instantiate device, sticking with in-memory framebuffer\n"); return; } else { DEBUG(1, "target synth_auxiliary_instantiate(), host-side framebuf utility running\n"); // At this point the framebuf.tcl script has run, the window has // been created, the framebuf program has been started, it will // have created the shared memory region and the two fifos, // passed the names back up to framebuf.tcl, and everything should // be running. This xchgmsg() retrieves the file names from // framebuf.tcl. synth_auxiliary_xchgmsg(local_fb_data->devid, SYNTH_FB_INIT, 0, 0, 0, 0, &reply, (unsigned char*)device_data, &len, 512); // First filename is the shared memory region. filename = device_data; for (ptr = device_data; *ptr != ';'; ptr++) ; *ptr++ = '\0'; DEBUG(1, "target : Opening shared memory region %s\n", filename); fd = cyg_hal_sys_open(filename, CYG_HAL_SYS_O_RDWR, 0); if (fd < 0) { synth_auxiliary_xchgmsg(local_fb_data->devid, SYNTH_FB_ABORT, 0, 0, 0, 0, 0, 0, 0, 0); return; } shared_fb_data = (synth_fb_data*)cyg_hal_sys_mmap(0, sizeof(synth_fb_data) + (fb->fb_height * fb->fb_stride * fb->fb_driver1), CYG_HAL_SYS_PROT_READ | CYG_HAL_SYS_PROT_WRITE, CYG_HAL_SYS_MAP_SHARED, fd, 0 ); if (shared_fb_data <= 0) { synth_auxiliary_xchgmsg(local_fb_data->devid, SYNTH_FB_ABORT, 0, 0, 0, 0, 0, 0, 0, 0); cyg_hal_sys_close(fd); return; } DEBUG(1, "target: mmap()'d shared memory region -> %p\n", shared_fb_data); shared_fb_data->devid = local_fb_data->devid; // Next filename is the fifo to the framebuf program. filename = ptr; for (ptr = device_data; *ptr != ';'; ptr++) ; *ptr++ = '\0'; DEBUG(1, "target: Opening fifo to framebuf %s\n", filename); shared_fb_data->fifo_to_framebuf = cyg_hal_sys_open(filename, CYG_HAL_SYS_O_WRONLY, 0); if (shared_fb_data->fifo_to_framebuf < 0) { synth_auxiliary_xchgmsg(shared_fb_data->devid, SYNTH_FB_ABORT, 0, 0, 0, 0, 0, 0, 0, 0); cyg_hal_sys_close(fd); return; } // And finally the fifo from the framebuf program. filename = ptr; for (ptr = device_data; *ptr != ';'; ptr++) ; *ptr = '\0'; DEBUG(1, "target: Opening fifo from framebuf %s\n", filename); shared_fb_data->fifo_from_framebuf = cyg_hal_sys_open(filename, CYG_HAL_SYS_O_RDONLY, 0); if (shared_fb_data->fifo_from_framebuf < 0) { synth_auxiliary_xchgmsg(shared_fb_data->devid, SYNTH_FB_ABORT, 0, 0, 0, 0, 0, 0, 0, 0); cyg_hal_sys_close(fd); cyg_hal_sys_close(shared_fb_data->fifo_to_framebuf); return; } // We have a shared memory region and the two files. Copy // all existing fb_data contents (e.g. the palettes) and // the framebuffer contents to the shared memory region. // The MUST_BE_ON flag is not set for synthetic target // framebuffers so there may already be contents. fb_base = (cyg_uint8*)fb->fb_base; fb_base -= (fb->fb_height * fb->fb_stride * shared_fb_data->page_drawable); memcpy(&(shared_fb_data->palette[0]), &(local_fb_data->palette[0]), 3 * 256); memcpy(&(shared_fb_data->framebuf[0]), fb_base, fb->fb_height * fb->fb_stride * fb->fb_driver1); shared_fb_data->connected = 1; fb->fb_driver2 = (CYG_ADDRWORD)shared_fb_data; fb_base = (cyg_uint8*)&(shared_fb_data->framebuf[0]); fb_base += (fb->fb_height * fb->fb_stride * shared_fb_data->page_drawable); fb->fb_base = fb_base; *(cyg_uint8**)fb->fb_driver3 = fb_base; DEBUG(1, "target: Fully instantiated, fb_data %p, blank_on %d, display_on %d\n", shared_fb_data, shared_fb_data->blank_on, shared_fb_data->display_on); DEBUG(1, "target: devid %d, t2h %d, h2t %d\n", shared_fb_data->devid, shared_fb_data->fifo_to_framebuf, shared_fb_data->fifo_from_framebuf); // Finally tell the framebuf program everything is ready. fb_op(fb, SYNTH_FB_OK); DEBUG(1, "target: Sent SYNTH_FB_OK\n"); } } // Switch on a framebuffer device. This may get called multiple // times, e.g. when switching between different screen modes. // It just involves sending a message to the auxiliary. static int cyg_synth_fb_on(struct cyg_fb* fb) { synth_fb_data* fb_data = (synth_fb_data*) fb->fb_driver2; if (fb_data->connected) { synth_auxiliary_xchgmsg(fb_data->devid, SYNTH_FB_ON, 0, 0, 0, 0, 0, 0, 0, 0); } return 0; } static int cyg_synth_fb_off(struct cyg_fb* fb) { synth_fb_data* fb_data = (synth_fb_data*) fb->fb_driver2; if (fb_data->connected) { synth_auxiliary_xchgmsg(fb_data->devid, SYNTH_FB_OFF, 0, 0, 0, 0, 0, 0, 0, 0); } return 0; } static int cyg_synth_fb_ioctl(struct cyg_fb* fb, cyg_ucount16 key, void* data, size_t* len) { synth_fb_data* fb_data = (synth_fb_data*) fb->fb_driver2; int result = ENOSYS; switch(key) { case CYG_FB_IOCTL_VIEWPORT_GET_POSITION: DEBUG(1, "cyg_synth_fb_ioctl: viewport_get_position\n"); if (fb->fb_flags0 & CYG_FB_FLAGS0_VIEWPORT) { cyg_fb_ioctl_viewport* viewport = (cyg_fb_ioctl_viewport*)data; CYG_ASSERT(*len == sizeof(cyg_fb_ioctl_viewport), "data argument should be a cyg_fb_ioctl_viewport structure"); viewport->fbvp_x = fb_data->viewport_x; viewport->fbvp_y = fb_data->viewport_y; result = 0; DEBUG(1, " : current viewport x %d, y %d\n", fb_data->viewport_x, fb_data->viewport_y); } else { DEBUG(1, " : framebuffer does not support a viewport\n"); } break; case CYG_FB_IOCTL_VIEWPORT_SET_POSITION: DEBUG(1, "cyg_synth_fb_ioctl: viewport_set_position\n"); if (fb->fb_flags0 & CYG_FB_FLAGS0_VIEWPORT) { cyg_fb_ioctl_viewport* viewport = (cyg_fb_ioctl_viewport*)data; CYG_ASSERT(*len == sizeof(cyg_fb_ioctl_viewport), "data argument should be a cyg_fb_ioctl_viewport structure"); CYG_ASSERT(((viewport->fbvp_x + fb->fb_viewport_width) <= fb->fb_width) && ((viewport->fbvp_y + fb->fb_viewport_height) <= fb->fb_height), "viewport should be within framebuffer dimensions"); DEBUG(1, " : setting viewport from x %d, y %d to x %d, y %d\n", fb_data->viewport_x, fb_data->viewport_y, (int) viewport->fbvp_x, (int) viewport->fbvp_y); if ((fb_data->viewport_x != (int)viewport->fbvp_x) || (fb_data->viewport_y != (int)viewport->fbvp_y)) { fb_data->viewport_x = (int)viewport->fbvp_x; fb_data->viewport_y = (int)viewport->fbvp_y; fb_op(fb, SYNTH_FB_VIEWPORT); } result = 0; } else { DEBUG(1, " : framebuffer does not support a viewport\n"); } break; case CYG_FB_IOCTL_PAGE_FLIPPING_GET_PAGES: DEBUG(1, "cyg_synth_fb_ioctl: page_flipping_get_pages\n"); if (fb->fb_flags0 & CYG_FB_FLAGS0_PAGE_FLIPPING) { cyg_fb_ioctl_page_flip* page_flip = (cyg_fb_ioctl_page_flip*)data; CYG_ASSERT(*len == sizeof(cyg_fb_ioctl_page_flip), "data argument should be a cyg_fb_ioctl_page_flip structure"); page_flip->fbpf_number_pages = fb->fb_driver1; page_flip->fbpf_visible_page = fb_data->page_visible; page_flip->fbpf_drawable_page = fb_data->page_drawable; result = 0; DEBUG(1, " : number_pages %d, visible page %d, drawable page %d\n", fb->fb_driver1, fb_data->page_visible, fb_data->page_drawable); } else { DEBUG(1, " : framebuffer does not support page flipping\n"); } break; case CYG_FB_IOCTL_PAGE_FLIPPING_SET_PAGES: DEBUG(1, "cyg_synth_fb_ioctl: page_flipping_set_pages\n"); if (fb->fb_flags0 & CYG_FB_FLAGS0_PAGE_FLIPPING) { cyg_fb_ioctl_page_flip* page_flip = (cyg_fb_ioctl_page_flip*)data; cyg_uint8* fb_base; CYG_ASSERT(*len == sizeof(cyg_fb_ioctl_page_flip), "data argument should be a cyg_fb_ioctl_page_flip structure"); CYG_ASSERT((page_flip->fbpf_visible_page < fb->driver1) && (page_flip->fbpf_drawable_page < fb->driver1), "framebuffer does not have that many pages"); DEBUG(1, " : drawable page was %d, now %d, visible page was %d, now %d\n", fb_data->page_drawable, (int)page_flip->fbpf_drawable_page, fb_data->page_visible, (int)page_flip->fbpf_visible_page); fb_base = (cyg_uint8*)fb->fb_base; fb_base -= (fb->fb_height * fb->fb_stride * fb_data->page_drawable); fb_data->page_drawable = page_flip->fbpf_drawable_page; fb_base += (fb->fb_height * fb->fb_stride * fb_data->page_drawable); fb->fb_base = fb_base; *(cyg_uint8**)fb->fb_driver3 = fb_base; if (fb_data->page_visible != (int)page_flip->fbpf_visible_page) { fb_data->page_visible = (int)page_flip->fbpf_visible_page; fb_op(fb, SYNTH_FB_PAGE_FLIP); } result = 0; } else { DEBUG(1, " : framebuffer does not support page flipping\n"); } break; case CYG_FB_IOCTL_BLANK_GET: { cyg_fb_ioctl_blank* blank = (cyg_fb_ioctl_blank*)data; DEBUG(1, "cyg_synth_fb_ioctl: blank_get, current on state %d\n", fb_data->blank_on); CYG_ASSERT(*len == sizeof(cyg_fb_ioctl_blank), "data argument should be a cyg_fb_ioctl_blank structure"); blank->fbbl_on = fb_data->blank_on; result = 0; } break; case CYG_FB_IOCTL_BLANK_SET: { cyg_fb_ioctl_blank* blank = (cyg_fb_ioctl_blank*)data; CYG_ASSERT(*len == sizeof(cyg_fb_ioctl_blank), "data argument should be a cyg_fb_ioctl_blank structure"); DEBUG(1, "cyg_synth_fb_ioctl: blank_set, on was %d, now %d\n", fb_data->blank_on, blank->fbbl_on); if (blank->fbbl_on != fb_data->blank_on) { fb_data->blank_on = blank->fbbl_on; fb_op(fb, SYNTH_FB_BLANK); } result = 0; } break; default: result = ENOSYS; break; } return result; } void cyg_synth_fb_synch(struct cyg_fb* fb, cyg_ucount16 when) { // FIXME: update synch_x0/y0/x1/y1 once the generic framebuffer // code actually maintains a bounding box. fb_op(fb, SYNTH_FB_SYNC); } #ifdef CYGHWR_DEVS_FRAMEBUF_SYNTH_FUNCTIONALITY_PALETTED // The palette is held in the synth_fb_data structure. static void cyg_synth_fb_read_palette(struct cyg_fb* fb, cyg_ucount32 first, cyg_ucount32 count, void* dest) { synth_fb_data* fb_data = (synth_fb_data*) fb->fb_driver2; CYG_ASSERT(fb->fb_flags0 & CYG_FB_FLAGS0_PALETTE, "reading palette of non-paletted display"); CYG_ASSERT((first + count) <= (0x01 << fb->fb_depth), "palette size exceeded"); memcpy(dest, &(fb_data->palette[3 * first]), 3 * count); } static void cyg_synth_fb_write_palette(struct cyg_fb* fb, cyg_ucount32 first, cyg_ucount32 count, const void* source, cyg_ucount16 when) { synth_fb_data* fb_data = (synth_fb_data*) fb->fb_driver2; CYG_ASSERT(fb->fb_flags0 & CYG_FB_FLAGS0_PALETTE, "reading palette of non-paletted display"); CYG_ASSERT((first + count) <= (0x01 << fb->fb_depth), "palette size exceeded"); DEBUG(1, "write_palette: fb %p, first %d, count %d, source %p\n", fb, first, count, source); memcpy(&(fb_data->palette[3 * first]), source, 3 * count); fb_op(fb, SYNTH_FB_WRITE_PALETTE); CYG_UNUSED_PARAM(cyg_ucount16, when); } #endif #define LINEAR1(_fn_, _suffix_) cyg_fb_linear_ ## _fn_ ## _ ## _suffix_ #define LINEAR( _fn_, _suffix_) LINEAR1(_fn_, _suffix_) #ifdef CYGPKG_DEVS_FRAMEBUF_SYNTH_FB0 # ifdef CYGNUM_DEVS_FRAMEBUF_SYNTH_FB0_PAGE_FLIPPING # define FB0_PAGES CYGNUM_DEVS_FRAMEBUF_SYNTH_FB0_PAGE_FLIPPING # else # define FB0_PAGES 1 #endif // A default area of memory for the framebuffer, if the auxiliary is not // running. static cyg_uint8 cyg_synth_fb0_default_base[CYG_FB_fb0_HEIGHT * CYG_FB_fb0_STRIDE * FB0_PAGES]; // Pointer to framebuffer memory. This defaults to a statically // allocated memory but will switch to a shared memory region if // the auxiliary is running. It may also change if page flipping // is enabled. cyg_uint8* cyg_synth_fb0_base = cyg_synth_fb0_default_base; // Driver-specific data needed for interacting with the auxiliary. static synth_fb_data cyg_synth_fb0_data; CYG_FB_FRAMEBUFFER(CYG_FB_fb0_STRUCT, CYG_FB_fb0_DEPTH, CYG_FB_fb0_FORMAT, CYG_FB_fb0_WIDTH, CYG_FB_fb0_HEIGHT, CYG_FB_fb0_VIEWPORT_WIDTH, CYG_FB_fb0_VIEWPORT_HEIGHT, cyg_synth_fb0_default_base, CYG_FB_fb0_STRIDE, CYG_FB_fb0_FLAGS0, CYG_FB_fb0_FLAGS1, CYG_FB_fb0_FLAGS2, CYG_FB_fb0_FLAGS3, (CYG_ADDRWORD) 0, // id, 0 - 3 (CYG_ADDRWORD) FB0_PAGES, (CYG_ADDRWORD) &cyg_synth_fb0_data, (CYG_ADDRWORD) &cyg_synth_fb0_base, &cyg_synth_fb_on, &cyg_synth_fb_off, &cyg_synth_fb_ioctl, &cyg_synth_fb_synch, &CYG_FB_fb0_READ_PALETTE_FN, &CYG_FB_fb0_WRITE_PALETTE_FN, &CYG_FB_fb0_MAKE_COLOUR_FN, &CYG_FB_fb0_BREAK_COLOUR_FN, LINEAR(write_pixel, CYG_FB_fb0_SUFFIX), LINEAR(read_pixel, CYG_FB_fb0_SUFFIX), LINEAR(write_hline, CYG_FB_fb0_SUFFIX), LINEAR(write_vline, CYG_FB_fb0_SUFFIX), LINEAR(fill_block, CYG_FB_fb0_SUFFIX), LINEAR(write_block, CYG_FB_fb0_SUFFIX), LINEAR(read_block, CYG_FB_fb0_SUFFIX), LINEAR(move_block, CYG_FB_fb0_SUFFIX), 0, 0, 0, 0 // Spare0 -> spare3 ); #endif #ifdef CYGPKG_DEVS_FRAMEBUF_SYNTH_FB1 # ifdef CYGNUM_DEVS_FRAMEBUF_SYNTH_FB1_PAGE_FLIPPING # define FB1_PAGES CYGNUM_DEVS_FRAMEBUF_SYNTH_FB1_PAGE_FLIPPING # else # define FB1_PAGES 1 #endif static cyg_uint8 cyg_synth_fb1_default_base[CYG_FB_fb1_HEIGHT * CYG_FB_fb1_STRIDE * FB1_PAGES]; cyg_uint8* cyg_synth_fb1_base = cyg_synth_fb1_default_base; static synth_fb_data cyg_synth_fb1_data; CYG_FB_FRAMEBUFFER(CYG_FB_fb1_STRUCT, CYG_FB_fb1_DEPTH, CYG_FB_fb1_FORMAT, CYG_FB_fb1_WIDTH, CYG_FB_fb1_HEIGHT, CYG_FB_fb1_VIEWPORT_WIDTH, CYG_FB_fb1_VIEWPORT_HEIGHT, cyg_synth_fb1_default_base, CYG_FB_fb1_STRIDE, CYG_FB_fb1_FLAGS0, CYG_FB_fb1_FLAGS1, CYG_FB_fb1_FLAGS2, CYG_FB_fb1_FLAGS3, (CYG_ADDRWORD) 1, // id, 0 - 3 (CYG_ADDRWORD) FB1_PAGES, (CYG_ADDRWORD) &cyg_synth_fb1_data, (CYG_ADDRWORD) &cyg_synth_fb1_base, &cyg_synth_fb_on, &cyg_synth_fb_off, &cyg_synth_fb_ioctl, &cyg_synth_fb_synch, &CYG_FB_fb1_READ_PALETTE_FN, &CYG_FB_fb1_WRITE_PALETTE_FN, &CYG_FB_fb1_MAKE_COLOUR_FN, &CYG_FB_fb1_BREAK_COLOUR_FN, LINEAR(write_pixel, CYG_FB_fb1_SUFFIX), LINEAR(read_pixel, CYG_FB_fb1_SUFFIX), LINEAR(write_hline, CYG_FB_fb1_SUFFIX), LINEAR(write_vline, CYG_FB_fb1_SUFFIX), LINEAR(fill_block, CYG_FB_fb1_SUFFIX), LINEAR(write_block, CYG_FB_fb1_SUFFIX), LINEAR(read_block, CYG_FB_fb1_SUFFIX), LINEAR(move_block, CYG_FB_fb1_SUFFIX), 0, 0, 0, 0 // Spare0 -> spare3 ); #endif #ifdef CYGPKG_DEVS_FRAMEBUF_SYNTH_FB2 # ifdef CYGNUM_DEVS_FRAMEBUF_SYNTH_FB2_PAGE_FLIPPING # define FB2_PAGES CYGNUM_DEVS_FRAMEBUF_SYNTH_FB2_PAGE_FLIPPING # else # define FB2_PAGES 1 #endif static cyg_uint8 cyg_synth_fb2_default_base[CYG_FB_fb2_HEIGHT * CYG_FB_fb2_STRIDE * FB2_PAGES]; cyg_uint8* cyg_synth_fb2_base = cyg_synth_fb2_default_base; static synth_fb_data cyg_synth_fb2_data; CYG_FB_FRAMEBUFFER(CYG_FB_fb2_STRUCT, CYG_FB_fb2_DEPTH, CYG_FB_fb2_FORMAT, CYG_FB_fb2_WIDTH, CYG_FB_fb2_HEIGHT, CYG_FB_fb2_VIEWPORT_WIDTH, CYG_FB_fb2_VIEWPORT_HEIGHT, cyg_synth_fb2_default_base, CYG_FB_fb2_STRIDE, CYG_FB_fb2_FLAGS0, CYG_FB_fb2_FLAGS1, CYG_FB_fb2_FLAGS2, CYG_FB_fb2_FLAGS3, (CYG_ADDRWORD) 2, // id, 0 - 3 (CYG_ADDRWORD) FB2_PAGES, (CYG_ADDRWORD) &cyg_synth_fb2_data, (CYG_ADDRWORD) &cyg_synth_fb2_base, &cyg_synth_fb_on, &cyg_synth_fb_off, &cyg_synth_fb_ioctl, &cyg_synth_fb_synch, &CYG_FB_fb2_READ_PALETTE_FN, &CYG_FB_fb2_WRITE_PALETTE_FN, &CYG_FB_fb2_MAKE_COLOUR_FN, &CYG_FB_fb2_BREAK_COLOUR_FN, LINEAR(write_pixel, CYG_FB_fb2_SUFFIX), LINEAR(read_pixel, CYG_FB_fb2_SUFFIX), LINEAR(write_hline, CYG_FB_fb2_SUFFIX), LINEAR(write_vline, CYG_FB_fb2_SUFFIX), LINEAR(fill_block, CYG_FB_fb2_SUFFIX), LINEAR(write_block, CYG_FB_fb2_SUFFIX), LINEAR(read_block, CYG_FB_fb2_SUFFIX), LINEAR(move_block, CYG_FB_fb2_SUFFIX), 0, 0, 0, 0 // Spare0 -> spare3 ); #endif #ifdef CYGPKG_DEVS_FRAMEBUF_SYNTH_FB3 # ifdef CYGNUM_DEVS_FRAMEBUF_SYNTH_FB3_PAGE_FLIPPING # define FB3_PAGES CYGNUM_DEVS_FRAMEBUF_SYNTH_FB3_PAGE_FLIPPING # else # define FB3_PAGES 1 #endif static cyg_uint8 cyg_synth_fb3_default_base[CYG_FB_fb3_HEIGHT * CYG_FB_fb3_STRIDE * FB3_PAGES]; cyg_uint8* cyg_synth_fb3_base = cyg_synth_fb3_default_base; static synth_fb_data cyg_synth_fb3_data; CYG_FB_FRAMEBUFFER(CYG_FB_fb3_STRUCT, CYG_FB_fb3_DEPTH, CYG_FB_fb3_FORMAT, CYG_FB_fb3_WIDTH, CYG_FB_fb3_HEIGHT, CYG_FB_fb3_VIEWPORT_WIDTH, CYG_FB_fb3_VIEWPORT_HEIGHT, cyg_synth_fb3_default_base, CYG_FB_fb3_STRIDE, CYG_FB_fb3_FLAGS0, CYG_FB_fb3_FLAGS1, CYG_FB_fb3_FLAGS2, CYG_FB_fb3_FLAGS3, (CYG_ADDRWORD) 3, // id, 0 - 3 (CYG_ADDRWORD) FB3_PAGES, (CYG_ADDRWORD) &cyg_synth_fb3_data, (CYG_ADDRWORD) &cyg_synth_fb3_base, &cyg_synth_fb_on, &cyg_synth_fb_off, &cyg_synth_fb_ioctl, &cyg_synth_fb_synch, &CYG_FB_fb3_READ_PALETTE_FN, &CYG_FB_fb3_WRITE_PALETTE_FN, &CYG_FB_fb3_MAKE_COLOUR_FN, &CYG_FB_fb3_BREAK_COLOUR_FN, LINEAR(write_pixel, CYG_FB_fb3_SUFFIX), LINEAR(read_pixel, CYG_FB_fb3_SUFFIX), LINEAR(write_hline, CYG_FB_fb3_SUFFIX), LINEAR(write_vline, CYG_FB_fb3_SUFFIX), LINEAR(fill_block, CYG_FB_fb3_SUFFIX), LINEAR(write_block, CYG_FB_fb3_SUFFIX), LINEAR(read_block, CYG_FB_fb3_SUFFIX), LINEAR(move_block, CYG_FB_fb3_SUFFIX), 0, 0, 0, 0 // Spare0 -> spare3 ); #endif
Go to most recent revision | Compare with Previous | Blame | View Log