[Spice-devel] [PATCH xf86-qxl 21/27] Coding style improvement
Marc-André Lureau
marcandre.lureau at gmail.com
Mon Jul 16 08:38:45 PDT 2012
---
src/qxl_driver.c | 1296 ++++++++++++++++++++++++++----------------------------
1 file changed, 628 insertions(+), 668 deletions(-)
diff --git a/src/qxl_driver.c b/src/qxl_driver.c
index 025f8ed..e621501 100644
--- a/src/qxl_driver.c
+++ b/src/qxl_driver.c
@@ -59,72 +59,72 @@
extern void compat_init_scrn(ScrnInfoPtr);
#if 0
-#define CHECK_POINT() ErrorF ("%s: %d (%s)\n", __FILE__, __LINE__, __FUNCTION__);
+#define CHECK_POINT() ErrorF("%s: %d (%s)\n", __FILE__, __LINE__, __FUNCTION__);
#endif
#define CHECK_POINT()
const OptionInfoRec DefaultOptions[] = {
{ OPTION_ENABLE_IMAGE_CACHE,
- "EnableImageCache", OPTV_BOOLEAN, { 0 }, TRUE },
+ "EnableImageCache", OPTV_BOOLEAN, { 0 }, TRUE },
{ OPTION_ENABLE_FALLBACK_CACHE,
- "EnableFallbackCache", OPTV_BOOLEAN, { 0 }, TRUE },
+ "EnableFallbackCache", OPTV_BOOLEAN, { 0 }, TRUE },
{ OPTION_ENABLE_SURFACES,
- "EnableSurfaces", OPTV_BOOLEAN, { 0 }, TRUE },
+ "EnableSurfaces", OPTV_BOOLEAN, { 0 }, TRUE },
{ OPTION_NUM_HEADS,
- "NumHeads", OPTV_INTEGER, { 4 }, FALSE },
+ "NumHeads", OPTV_INTEGER, { 4 }, FALSE },
#ifdef XSPICE
{ OPTION_SPICE_PORT,
- "SpicePort", OPTV_INTEGER, {5900}, FALSE },
+ "SpicePort", OPTV_INTEGER, {5900}, FALSE },
{ OPTION_SPICE_TLS_PORT,
- "SpiceTlsPort", OPTV_INTEGER, {0}, FALSE},
+ "SpiceTlsPort", OPTV_INTEGER, {0}, FALSE},
{ OPTION_SPICE_ADDR,
- "SpiceAddr", OPTV_STRING, {0}, FALSE},
+ "SpiceAddr", OPTV_STRING, {0}, FALSE},
{ OPTION_SPICE_X509_DIR,
- "SpiceX509Dir", OPTV_STRING, {0}, FALSE},
+ "SpiceX509Dir", OPTV_STRING, {0}, FALSE},
{ OPTION_SPICE_SASL,
- "SpiceSasl", OPTV_BOOLEAN, {0}, FALSE},
+ "SpiceSasl", OPTV_BOOLEAN, {0}, FALSE},
/* VVV qemu defaults to 1 - not implemented in xspice yet */
{ OPTION_SPICE_AGENT_MOUSE,
- "SpiceAgentMouse", OPTV_BOOLEAN, {0}, FALSE},
+ "SpiceAgentMouse", OPTV_BOOLEAN, {0}, FALSE},
{ OPTION_SPICE_DISABLE_TICKETING,
- "SpiceDisableTicketing", OPTV_BOOLEAN, {0}, FALSE},
+ "SpiceDisableTicketing", OPTV_BOOLEAN, {0}, FALSE},
{ OPTION_SPICE_PASSWORD,
- "SpicePassword", OPTV_STRING, {0}, FALSE},
+ "SpicePassword", OPTV_STRING, {0}, FALSE},
{ OPTION_SPICE_X509_KEY_FILE,
- "SpiceX509KeyFile", OPTV_STRING, {0}, FALSE},
+ "SpiceX509KeyFile", OPTV_STRING, {0}, FALSE},
{ OPTION_SPICE_STREAMING_VIDEO,
- "SpiceStreamingVideo", OPTV_STRING, {.str="filter"}, FALSE},
+ "SpiceStreamingVideo", OPTV_STRING, {.str="filter"}, FALSE},
{ OPTION_SPICE_PLAYBACK_COMPRESSION,
- "SpicePlaybackCompression", OPTV_BOOLEAN, {1}, FALSE},
+ "SpicePlaybackCompression", OPTV_BOOLEAN, {1}, FALSE},
{ OPTION_SPICE_ZLIB_GLZ_WAN_COMPRESSION,
- "SpiceZlibGlzWanCompression", OPTV_STRING, {.str="auto"}, FALSE},
+ "SpiceZlibGlzWanCompression", OPTV_STRING, {.str="auto"}, FALSE},
{ OPTION_SPICE_JPEG_WAN_COMPRESSION,
- "SpiceJpegWanCompression", OPTV_STRING, {.str="auto"}, FALSE},
+ "SpiceJpegWanCompression", OPTV_STRING, {.str="auto"}, FALSE},
{ OPTION_SPICE_IMAGE_COMPRESSION,
- "SpiceImageCompression", OPTV_STRING, {.str="auto_glz"}, FALSE},
+ "SpiceImageCompression", OPTV_STRING, {.str="auto_glz"}, FALSE},
{ OPTION_SPICE_DISABLE_COPY_PASTE,
- "SpiceDisableCopyPaste", OPTV_BOOLEAN, {0}, FALSE},
+ "SpiceDisableCopyPaste", OPTV_BOOLEAN, {0}, FALSE},
{ OPTION_SPICE_IPV4_ONLY,
- "SpiceIPV4Only", OPTV_BOOLEAN, {0}, FALSE},
+ "SpiceIPV4Only", OPTV_BOOLEAN, {0}, FALSE},
{ OPTION_SPICE_IPV6_ONLY,
- "SpiceIPV6Only", OPTV_BOOLEAN, {0}, FALSE},
+ "SpiceIPV6Only", OPTV_BOOLEAN, {0}, FALSE},
{ OPTION_SPICE_X509_CERT_FILE,
- "SpiceX509CertFile", OPTV_STRING, {0}, FALSE},
+ "SpiceX509CertFile", OPTV_STRING, {0}, FALSE},
{ OPTION_SPICE_X509_KEY_PASSWORD,
- "SpiceX509KeyPassword", OPTV_STRING, {0}, FALSE},
+ "SpiceX509KeyPassword", OPTV_STRING, {0}, FALSE},
{ OPTION_SPICE_TLS_CIPHERS,
- "SpiceTlsCiphers", OPTV_STRING, {0}, FALSE},
+ "SpiceTlsCiphers", OPTV_STRING, {0}, FALSE},
{ OPTION_SPICE_CACERT_FILE,
- "SpiceCacertFile", OPTV_STRING, {0}, FALSE},
+ "SpiceCacertFile", OPTV_STRING, {0}, FALSE},
{ OPTION_SPICE_DH_FILE,
- "SpiceDhFile", OPTV_STRING, {0}, FALSE},
+ "SpiceDhFile", OPTV_STRING, {0}, FALSE},
#endif
{ -1, NULL, OPTV_NONE, {0}, FALSE }
};
static const OptionInfoRec *
-qxl_available_options (int chipid, int busid)
+qxl_available_options(int chipid, int busid)
{
return DefaultOptions;
}
@@ -132,24 +132,26 @@ qxl_available_options (int chipid, int busid)
#ifndef XSPICE
static void qxl_wait_for_io_command(qxl_screen_t *qxl)
{
- struct QXLRam *ram_header = (void *)(
- (unsigned long)qxl->ram + qxl->rom->ram_header_offset);
+ struct QXLRam *ram_header;
+
+ ram_header = (void *)((unsigned long)qxl->ram + qxl->rom->ram_header_offset);
- while (!(ram_header->int_pending & QXL_INTERRUPT_IO_CMD)) {
+ while (!(ram_header->int_pending & QXL_INTERRUPT_IO_CMD))
usleep(1);
- }
+
ram_header->int_pending &= ~QXL_INTERRUPT_IO_CMD;
}
#if 0
static void qxl_wait_for_display_interrupt(qxl_screen_t *qxl)
{
- struct QXLRam *ram_header = (void *)(
- (unsigned long)qxl->ram + qxl->rom->ram_header_offset);
+ struct QXLRam *ram_header;
+
+ ram_header = (void *)((unsigned long)qxl->ram + qxl->rom->ram_header_offset);
- while (!(ram_header->int_pending & QXL_INTERRUPT_DISPLAY)) {
+ while (!(ram_header->int_pending & QXL_INTERRUPT_DISPLAY))
usleep(1);
- }
+
ram_header->int_pending &= ~QXL_INTERRUPT_DISPLAY;
}
#endif
@@ -201,12 +203,10 @@ void qxl_io_create_primary(qxl_screen_t *qxl)
void qxl_io_destroy_primary(qxl_screen_t *qxl)
{
#ifndef XSPICE
- if (qxl->pci->revision >= 3)
- {
+ if (qxl->pci->revision >= 3) {
ioport_write(qxl, QXL_IO_DESTROY_PRIMARY_ASYNC, 0);
qxl_wait_for_io_command(qxl);
- } else
- {
+ } else {
ioport_write(qxl, QXL_IO_DESTROY_PRIMARY, 0);
}
#else
@@ -232,7 +232,7 @@ void qxl_io_flush_surfaces(qxl_screen_t *qxl)
}
static void
-qxl_usleep (int useconds)
+qxl_usleep(int useconds)
{
struct timespec t;
@@ -241,7 +241,7 @@ qxl_usleep (int useconds)
errno = 0;
while (nanosleep (&t, &t) == -1 && errno == EINTR)
- ;
+ ;
}
#ifdef QXLDRV_RESIZABLE_SURFACE0
@@ -250,9 +250,9 @@ static void qxl_io_flush_release(qxl_screen_t *qxl)
#ifndef XSPICE
int sum = 0;
- sum += qxl_garbage_collect (qxl);
+ sum += qxl_garbage_collect(qxl);
ioport_write(qxl, QXL_IO_FLUSH_RELEASE, 0);
- sum += qxl_garbage_collect (qxl);
+ sum += qxl_garbage_collect(qxl);
ErrorF("%s: collected %d\n", __func__, sum);
#else
#endif
@@ -265,6 +265,7 @@ static void qxl_io_monitors_config_async(qxl_screen_t *qxl)
if (qxl->pci->revision < 4) {
return;
}
+
ioport_write(qxl, QXL_IO_MONITORS_CONFIG_ASYNC, 0);
qxl_wait_for_io_command(qxl);
#else
@@ -284,88 +285,85 @@ qxl_allocate_monitors_config(qxl_screen_t *qxl)
{
int size = sizeof(QXLMonitorsConfig) + sizeof(QXLHead) * MAX_MONITORS_NUM;
- if (qxl->monitors_config) {
+ if (qxl->monitors_config)
return;
- }
- qxl->monitors_config = (QXLMonitorsConfig *)(void *)(
- (unsigned long)qxl->ram + qxl->rom->ram_header_offset
- - qxl->monitors_config_size);
+
+ qxl->monitors_config = (QXLMonitorsConfig *)(void *)
+ ((unsigned long)qxl->ram + qxl->rom->ram_header_offset - qxl->monitors_config_size);
+
memset(qxl->monitors_config, 0, size);
}
+static uint64_t
+qxl_garbage_collect_internal(qxl_screen_t *qxl, uint64_t id)
+{
+ /* We assume that there the two low bits of a pointer are
+ * available. If the low one is set, then the command in
+ * question is a cursor command
+ */
+#define POINTER_MASK ((1 << 2) - 1)
+
+ union QXLReleaseInfo *info = u64_to_pointer (id & ~POINTER_MASK);
+ struct QXLCursorCmd *cmd = (struct QXLCursorCmd *)info;
+ struct QXLDrawable *drawable = (struct QXLDrawable *)info;
+ struct QXLSurfaceCmd *surface_cmd = (struct QXLSurfaceCmd *)info;
+ int is_cursor = FALSE;
+ int is_surface = FALSE;
+ int is_drawable = FALSE;
+
+ if ((id & POINTER_MASK) == 1)
+ is_cursor = TRUE;
+ else if ((id & POINTER_MASK) == 2)
+ is_surface = TRUE;
+ else
+ is_drawable = TRUE;
+
+ if (is_cursor && cmd->type == QXL_CURSOR_SET) {
+ struct QXLCursor *cursor;
+
+ cursor = (void *)virtual_address(qxl, u64_to_pointer (cmd->u.set.shape),
+ qxl->main_mem_slot);
+ qxl_free(qxl->mem, cursor);
+ } else if (is_drawable && drawable->type == QXL_DRAW_COPY) {
+ struct QXLImage *image;
+
+ image = virtual_address(qxl, u64_to_pointer (drawable->u.copy.src_bitmap),
+ qxl->main_mem_slot);
+ if (image->descriptor.type == SPICE_IMAGE_TYPE_SURFACE){
+ qxl_surface_unref(qxl->surface_cache, image->surface_image.surface_id);
+ qxl_surface_cache_sanity_check(qxl->surface_cache);
+ qxl_free(qxl->mem, image);
+ } else {
+ qxl_image_destroy(qxl, image);
+ }
+ } else if (is_surface && surface_cmd->type == QXL_SURFACE_CMD_DESTROY) {
+ qxl_surface_recycle(qxl->surface_cache, surface_cmd->surface_id);
+ qxl_surface_cache_sanity_check(qxl->surface_cache);
+ }
+
+ id = info->next;
+ qxl_free(qxl->mem, info);
+
+ return id;
+}
+
int
-qxl_garbage_collect (qxl_screen_t *qxl)
+qxl_garbage_collect(qxl_screen_t *qxl)
{
uint64_t id;
int i = 0;
while (qxl_ring_pop (qxl->release_ring, &id))
- {
- while (id)
- {
- /* We assume that there the two low bits of a pointer are
- * available. If the low one is set, then the command in
- * question is a cursor command
- */
-#define POINTER_MASK ((1 << 2) - 1)
-
- union QXLReleaseInfo *info = u64_to_pointer (id & ~POINTER_MASK);
- struct QXLCursorCmd *cmd = (struct QXLCursorCmd *)info;
- struct QXLDrawable *drawable = (struct QXLDrawable *)info;
- struct QXLSurfaceCmd *surface_cmd = (struct QXLSurfaceCmd *)info;
- int is_cursor = FALSE;
- int is_surface = FALSE;
- int is_drawable = FALSE;
-
- if ((id & POINTER_MASK) == 1)
- is_cursor = TRUE;
- else if ((id & POINTER_MASK) == 2)
- is_surface = TRUE;
- else
- is_drawable = TRUE;
-
- if (is_cursor && cmd->type == QXL_CURSOR_SET)
- {
- struct QXLCursor *cursor = (void *)virtual_address (
- qxl, u64_to_pointer (cmd->u.set.shape), qxl->main_mem_slot);
-
- qxl_free (qxl->mem, cursor);
- }
- else if (is_drawable && drawable->type == QXL_DRAW_COPY)
- {
- struct QXLImage *image = virtual_address (
- qxl, u64_to_pointer (drawable->u.copy.src_bitmap), qxl->main_mem_slot);
-
- if (image->descriptor.type == SPICE_IMAGE_TYPE_SURFACE)
- {
- qxl_surface_unref (qxl->surface_cache, image->surface_image.surface_id);
- qxl_surface_cache_sanity_check (qxl->surface_cache);
- qxl_free (qxl->mem, image);
- }
- else
- {
- qxl_image_destroy (qxl, image);
- }
- }
- else if (is_surface && surface_cmd->type == QXL_SURFACE_CMD_DESTROY)
- {
- qxl_surface_recycle (qxl->surface_cache, surface_cmd->surface_id);
- qxl_surface_cache_sanity_check (qxl->surface_cache);
- }
-
- id = info->next;
-
- qxl_free (qxl->mem, info);
-
- ++i;
- }
- }
-
+ while (id) {
+ id = qxl_garbage_collect_internal(qxl, id);
+ i++;
+ }
+
return i;
}
int
-qxl_handle_oom (qxl_screen_t *qxl)
+qxl_handle_oom(qxl_screen_t *qxl)
{
qxl_io_notify_oom(qxl);
@@ -374,14 +372,14 @@ qxl_handle_oom (qxl_screen_t *qxl)
qxl_usleep (10000);
#endif
- if (!(qxl_garbage_collect (qxl)))
- qxl_usleep (10000);
+ if (!(qxl_garbage_collect(qxl)))
+ qxl_usleep(10000);
- return qxl_garbage_collect (qxl);
+ return qxl_garbage_collect(qxl);
}
void *
-qxl_allocnf (qxl_screen_t *qxl, unsigned long size)
+qxl_allocnf(qxl_screen_t *qxl, unsigned long size)
{
void *result;
int n_attempts = 0;
@@ -389,31 +387,25 @@ qxl_allocnf (qxl_screen_t *qxl, unsigned long size)
static int nth_oom = 1;
#endif
- qxl_garbage_collect (qxl);
-
- while (!(result = qxl_alloc (qxl->mem, size)))
- {
+ qxl_garbage_collect(qxl);
+
+ while (!(result = qxl_alloc(qxl->mem, size))) {
#if 0
- ErrorF ("eliminated memory (%d)\n", nth_oom++);
+ ErrorF("eliminated memory (%d)\n", nth_oom++);
#endif
- if (!qxl_garbage_collect (qxl))
- {
- if (qxl_handle_oom (qxl))
- {
- n_attempts = 0;
- }
- else if (++n_attempts == 1000)
- {
- ErrorF ("Out of memory allocating %ld bytes\n", size);
- qxl_mem_dump_stats (qxl->mem, "Out of mem - stats\n");
-
- fprintf (stderr, "Out of memory\n");
- exit (1);
- }
- }
+ if (!qxl_garbage_collect(qxl)) {
+ if (qxl_handle_oom(qxl)) {
+ n_attempts = 0;
+ } else if (++n_attempts == 1000) {
+ ErrorF("Out of memory allocating %ld bytes\n", size);
+ qxl_mem_dump_stats(qxl->mem, "Out of mem - stats\n");
+ fprintf(stderr, "Out of memory\n");
+ exit(1);
+ }
+ }
}
-
+
return result;
}
@@ -451,18 +443,18 @@ unmap_memory_helper(qxl_screen_t *qxl)
{
#ifdef XSERVER_LIBPCIACCESS
if (qxl->ram)
- pci_device_unmap_range(qxl->pci, qxl->ram, qxl->pci->regions[0].size);
+ pci_device_unmap_range(qxl->pci, qxl->ram, qxl->pci->regions[0].size);
if (qxl->vram)
- pci_device_unmap_range(qxl->pci, qxl->vram, qxl->pci->regions[1].size);
+ pci_device_unmap_range(qxl->pci, qxl->vram, qxl->pci->regions[1].size);
if (qxl->rom)
- pci_device_unmap_range(qxl->pci, qxl->rom, qxl->pci->regions[2].size);
+ pci_device_unmap_range(qxl->pci, qxl->rom, qxl->pci->regions[2].size);
#else
if (qxl->ram)
- xf86UnMapVidMem(scrnIndex, qxl->ram, (1 << qxl->pci->size[0]));
+ xf86UnMapVidMem(scrnIndex, qxl->ram, (1 << qxl->pci->size[0]));
if (qxl->vram)
- xf86UnMapVidMem(scrnIndex, qxl->vram, (1 << qxl->pci->size[1]));
+ xf86UnMapVidMem(scrnIndex, qxl->vram, (1 << qxl->pci->size[1]));
if (qxl->rom)
- xf86UnMapVidMem(scrnIndex, qxl->rom, (1 << qxl->pci->size[2]));
+ xf86UnMapVidMem(scrnIndex, qxl->rom, (1 << qxl->pci->size[2]));
#endif
}
@@ -471,39 +463,39 @@ map_memory_helper(qxl_screen_t *qxl)
{
#ifdef XSERVER_LIBPCIACCESS
pci_device_map_range(qxl->pci, qxl->pci->regions[0].base_addr,
- qxl->pci->regions[0].size,
- PCI_DEV_MAP_FLAG_WRITABLE | PCI_DEV_MAP_FLAG_WRITE_COMBINE,
- &qxl->ram);
+ qxl->pci->regions[0].size,
+ PCI_DEV_MAP_FLAG_WRITABLE | PCI_DEV_MAP_FLAG_WRITE_COMBINE,
+ &qxl->ram);
qxl->ram_physical = u64_to_pointer (qxl->pci->regions[0].base_addr);
qxl->ram_size = qxl->pci->regions[0].size;
pci_device_map_range(qxl->pci, qxl->pci->regions[1].base_addr,
- qxl->pci->regions[1].size,
- PCI_DEV_MAP_FLAG_WRITABLE,
- &qxl->vram);
+ qxl->pci->regions[1].size,
+ PCI_DEV_MAP_FLAG_WRITABLE,
+ &qxl->vram);
qxl->vram_physical = u64_to_pointer (qxl->pci->regions[1].base_addr);
qxl->vram_size = qxl->pci->regions[1].size;
pci_device_map_range(qxl->pci, qxl->pci->regions[2].base_addr,
- qxl->pci->regions[2].size, 0,
- (void **)&qxl->rom);
+ qxl->pci->regions[2].size, 0,
+ (void **)&qxl->rom);
qxl->io_base = qxl->pci->regions[3].base_addr;
#else
qxl->ram = xf86MapPciMem(scrnIndex, VIDMEM_FRAMEBUFFER,
- qxl->pci_tag, qxl->pci->memBase[0],
- (1 << qxl->pci->size[0]));
+ qxl->pci_tag, qxl->pci->memBase[0],
+ (1 << qxl->pci->size[0]));
qxl->ram_physical = (void *)qxl->pci->memBase[0];
qxl->vram = xf86MapPciMem(scrnIndex, VIDMEM_MMIO | VIDMEM_MMIO_32BIT,
- qxl->pci_tag, qxl->pci->memBase[1],
- (1 << qxl->pci->size[1]));
+ qxl->pci_tag, qxl->pci->memBase[1],
+ (1 << qxl->pci->size[1]));
qxl->vram_physical = (void *)qxl->pci->memBase[1];
qxl->vram_size = (1 << qxl->pci->size[1]);
qxl->rom = xf86MapPciMem(scrnIndex, VIDMEM_MMIO | VIDMEM_MMIO_32BIT,
- qxl->pci_tag, qxl->pci->memBase[2],
- (1 << qxl->pci->size[2]));
+ qxl->pci_tag, qxl->pci->memBase[2],
+ (1 << qxl->pci->size[2]));
qxl->io_base = qxl->pci->ioBase[3];
#endif
@@ -519,13 +511,13 @@ qxl_unmap_memory(qxl_screen_t *qxl)
qxl->worker_running = FALSE;
}
#endif
- if (qxl->mem)
- {
- qxl_mem_free_all (qxl->mem);
- qxl_drop_image_cache (qxl);
+ if (qxl->mem) {
+ qxl_mem_free_all(qxl->mem);
+ qxl_drop_image_cache (qxl);
}
if (qxl->surf_mem)
- qxl_mem_free_all (qxl->surf_mem);
+ qxl_mem_free_all(qxl->surf_mem);
+
unmap_memory_helper(qxl);
qxl->ram = qxl->ram_physical = qxl->vram = qxl->rom = NULL;
@@ -533,7 +525,8 @@ qxl_unmap_memory(qxl_screen_t *qxl)
qxl->modes = NULL;
}
-static void __attribute__ ((__noreturn__)) qxl_mspace_abort_func(void *user_data)
+static void __attribute__ ((__noreturn__))
+qxl_mspace_abort_func(void *user_data)
{
abort();
}
@@ -579,30 +572,30 @@ static int
qxl_resize_surface0(qxl_screen_t *qxl, long surface0_size)
{
long ram_header_size = qxl->ram_size - qxl->rom->ram_header_offset;
- long new_mem_size = qxl->ram_size - surface0_size - ram_header_size
- - qxl->monitors_config_size;
+ long new_mem_size = qxl->ram_size -
+ (surface0_size + ram_header_size + qxl->monitors_config_size);
if (new_mem_size < 0) {
- ErrorF ("cannot resize surface0 to %ld, does not fit in BAR 0\n",
+ ErrorF("cannot resize surface0 to %ld, does not fit in BAR 0\n",
surface0_size);
return 0;
}
- ErrorF ("resizing surface0 to %ld\n", surface0_size);
- if (qxl->mem)
- {
+ ErrorF("resizing surface0 to %ld\n", surface0_size);
+
+ if (qxl->mem) {
#ifdef QXLDRV_RESIZABLE_SURFACE0
void *surfaces;
qxl_dump_ring_stat(qxl);
qxl_io_flush_surfaces(qxl);
- surfaces = qxl_surface_cache_evacuate_all (qxl->surface_cache);
+ surfaces = qxl_surface_cache_evacuate_all(qxl->surface_cache);
qxl_io_destroy_all_surfaces(qxl); // redundant?
qxl_io_flush_release(qxl);
- qxl_drop_image_cache (qxl);
+ qxl_drop_image_cache(qxl);
qxl_dump_ring_stat(qxl);
- qxl_surface_cache_replace_all (qxl->surface_cache, surfaces);
+ qxl_surface_cache_replace_all(qxl->surface_cache, surfaces);
#else
- ErrorF ("resizing surface0 compiled out\n");
+ ErrorF("resizing surface0 compiled out\n");
return 0;
#endif
}
@@ -611,9 +604,8 @@ qxl_resize_surface0(qxl_screen_t *qxl, long surface0_size)
qxl->surface0_size = surface0_size;
qxl->mem_size = new_mem_size;
- qxl->mem = qxl_mem_create ((void *)((unsigned long)qxl->surface0_area
- + qxl->surface0_size),
- qxl->mem_size);
+ qxl->mem = qxl_mem_create((void *)((unsigned long)qxl->surface0_area + qxl->surface0_size),
+ qxl->mem_size);
return 1;
}
@@ -623,17 +615,17 @@ qxl_map_memory(qxl_screen_t *qxl, int scrnIndex)
map_memory_helper(qxl);
if (!qxl->ram || !qxl->vram || !qxl->rom)
- return FALSE;
+ return FALSE;
xf86DrvMsg(scrnIndex, X_INFO, "framebuffer at %p (%d KB)\n",
- qxl->ram, qxl->rom->surface0_area_size / 1024);
+ qxl->ram, qxl->rom->surface0_area_size / 1024);
xf86DrvMsg(scrnIndex, X_INFO, "command ram at %p (%d KB)\n",
- (void *)((unsigned long)qxl->ram + qxl->rom->surface0_area_size),
- (qxl->rom->num_pages * getpagesize() - qxl->rom->surface0_area_size)/1024);
+ (void *)((unsigned long)qxl->ram + qxl->rom->surface0_area_size),
+ (qxl->rom->num_pages * getpagesize() - qxl->rom->surface0_area_size)/1024);
xf86DrvMsg(scrnIndex, X_INFO, "vram at %p (%ld KB)\n",
- qxl->vram, qxl->vram_size / 1024);
+ qxl->vram, qxl->vram_size / 1024);
xf86DrvMsg(scrnIndex, X_INFO, "rom at %p\n", qxl->rom);
@@ -642,17 +634,16 @@ qxl_map_memory(qxl_screen_t *qxl, int scrnIndex)
* the driver can change it without affecting the driver/device ABI.
*/
qxl->monitors_config_size = (sizeof(QXLMonitorsConfig) +
- sizeof(QXLHead) * MAX_MONITORS_NUM + getpagesize() - 1)
- & ~(getpagesize() - 1);
+ sizeof(QXLHead) * MAX_MONITORS_NUM + getpagesize() - 1)
+ & ~(getpagesize() - 1);
qxl->num_modes = *(uint32_t *)((uint8_t *)qxl->rom + qxl->rom->modes_offset);
qxl->modes = (struct QXLMode *)(((uint8_t *)qxl->rom) + qxl->rom->modes_offset + 4);
qxl->surface0_area = qxl->ram;
qxl->surface0_size = 0;
qxl->mem = NULL;
- if (!qxl_resize_surface0(qxl, qxl->rom->surface0_area_size)) {
+ if (!qxl_resize_surface0(qxl, qxl->rom->surface0_area_size))
return FALSE;
- }
- qxl->surf_mem = qxl_mem_create ((void *)((unsigned long)qxl->vram), qxl->vram_size);
+ qxl->surf_mem = qxl_mem_create((void *)((unsigned long)qxl->vram), qxl->vram_size);
qxl_allocate_monitors_config(qxl);
return TRUE;
@@ -683,15 +674,15 @@ qxl_restore_state(ScrnInfoPtr pScrn)
{
qxl_screen_t *qxl = pScrn->driverPrivate;
- if (xf86IsPrimaryPci (qxl->pci))
+ if (xf86IsPrimaryPci(qxl->pci))
vgaHWRestoreFonts(pScrn, &qxl->vgaRegs);
}
#endif /* XSPICE */
static uint8_t
setup_slot(qxl_screen_t *qxl, uint8_t slot_index_offset,
- unsigned long start_phys_addr, unsigned long end_phys_addr,
- uint64_t start_virt_addr, uint64_t end_virt_addr)
+ unsigned long start_phys_addr, unsigned long end_phys_addr,
+ uint64_t start_virt_addr, uint64_t end_virt_addr)
{
uint64_t high_bits;
qxl_memslot_t *slot;
@@ -712,11 +703,12 @@ setup_slot(qxl_screen_t *qxl, uint8_t slot_index_offset,
qxl_io_memslot_add(qxl, slot_index);
slot->generation = qxl->rom->slot_generation;
-
+
high_bits = slot_index << qxl->slot_gen_bits;
high_bits |= slot->generation;
high_bits <<= (64 - (qxl->slot_gen_bits + qxl->slot_id_bits));
slot->high_bits = high_bits;
+
return slot_index;
}
@@ -726,9 +718,9 @@ qxl_reset_and_create_mem_slots (qxl_screen_t *qxl)
ioport_write(qxl, QXL_IO_RESET, 0);
qxl->device_primary = QXL_DEVICE_PRIMARY_NONE;
/* Mem slots */
- ErrorF ("slots start: %d, slots end: %d\n",
- qxl->rom->slots_start,
- qxl->rom->slots_end);
+ ErrorF("slots start: %d, slots end: %d\n",
+ qxl->rom->slots_start,
+ qxl->rom->slots_end);
/* Main slot */
qxl->n_mem_slots = qxl->rom->slots_end;
@@ -736,24 +728,24 @@ qxl_reset_and_create_mem_slots (qxl_screen_t *qxl)
qxl->slot_id_bits = qxl->rom->slot_id_bits;
qxl->va_slot_mask = (~(uint64_t)0) >> (qxl->slot_id_bits + qxl->slot_gen_bits);
- qxl->mem_slots = xnfalloc (qxl->n_mem_slots * sizeof (qxl_memslot_t));
+ qxl->mem_slots = xnfalloc(qxl->n_mem_slots * sizeof (qxl_memslot_t));
#ifdef XSPICE
qxl->main_mem_slot = qxl->vram_mem_slot = setup_slot(qxl, 0, 0, ~0, 0, ~0);
#else /* QXL */
qxl->main_mem_slot = setup_slot(qxl, 0,
- (unsigned long)qxl->ram_physical,
- (unsigned long)qxl->ram_physical + qxl->surface0_size +
- (unsigned long)qxl->rom->num_pages * getpagesize(),
- (uint64_t)(uintptr_t)qxl->ram,
- (uint64_t)(uintptr_t)qxl->ram + qxl->surface0_size +
- (unsigned long)qxl->rom->num_pages * getpagesize()
- );
+ (unsigned long)qxl->ram_physical,
+ (unsigned long)qxl->ram_physical + qxl->surface0_size +
+ (unsigned long)qxl->rom->num_pages * getpagesize(),
+ (uint64_t)(uintptr_t)qxl->ram,
+ (uint64_t)(uintptr_t)qxl->ram + qxl->surface0_size +
+ (unsigned long)qxl->rom->num_pages * getpagesize()
+ );
qxl->vram_mem_slot = setup_slot(qxl, 1,
- (unsigned long)qxl->vram_physical,
- (unsigned long)qxl->vram_physical + (unsigned long)qxl->vram_size,
- (uint64_t)(uintptr_t)qxl->vram,
- (uint64_t)(uintptr_t)qxl->vram + (uint64_t)qxl->vram_size);
+ (unsigned long)qxl->vram_physical,
+ (unsigned long)qxl->vram_physical + (unsigned long)qxl->vram_size,
+ (uint64_t)(uintptr_t)qxl->vram,
+ (uint64_t)(uintptr_t)qxl->vram + (uint64_t)qxl->vram_size);
#endif
}
@@ -765,16 +757,13 @@ qxl_mark_mem_unverifiable(qxl_screen_t *qxl)
}
void
-qxl_io_destroy_all_surfaces (qxl_screen_t *qxl)
+qxl_io_destroy_all_surfaces(qxl_screen_t *qxl)
{
#ifndef XSPICE
- if (qxl->pci->revision >= 3)
- {
+ if (qxl->pci->revision >= 3) {
ioport_write(qxl, QXL_IO_DESTROY_ALL_SURFACES_ASYNC, 0);
qxl_wait_for_io_command(qxl);
- }
- else
- {
+ } else {
ioport_write(qxl, QXL_IO_DESTROY_ALL_SURFACES, 0);
}
#else
@@ -789,32 +778,31 @@ qxl_close_screen(CLOSE_SCREEN_ARGS_DECL)
ScrnInfoPtr pScrn = xf86ScreenToScrn(pScreen);
qxl_screen_t *qxl = pScrn->driverPrivate;
Bool result;
-
- ErrorF ("Disabling FB access for %d\n", pScrn->scrnIndex);
+
+ ErrorF("Disabling FB access for %d\n", pScrn->scrnIndex);
#ifndef XF86_SCRN_INTERFACE
- pScrn->EnableDisableFBAccess (scrnIndex, FALSE);
+ pScrn->EnableDisableFBAccess(scrnIndex, FALSE);
#else
- pScrn->EnableDisableFBAccess (pScrn, FALSE);
+ pScrn->EnableDisableFBAccess(pScrn, FALSE);
#endif
- ErrorF ("Freeing %p\n", qxl->fb);
+ ErrorF("Freeing %p\n", qxl->fb);
free(qxl->fb);
qxl->fb = NULL;
-
+
pScreen->CreateScreenResources = qxl->create_screen_resources;
pScreen->CloseScreen = qxl->close_screen;
-
+
result = pScreen->CloseScreen(CLOSE_SCREEN_ARGS);
#ifndef XSPICE
- if (!xf86IsPrimaryPci (qxl->pci) && qxl->primary)
- qxl_reset_and_create_mem_slots (qxl);
+ if (!xf86IsPrimaryPci(qxl->pci) && qxl->primary)
+ qxl_reset_and_create_mem_slots(qxl);
#endif
-
- if (pScrn->vtSema)
- {
+
+ if (pScrn->vtSema) {
qxl_restore_state(pScrn);
qxl_mark_mem_unverifiable(qxl);
- qxl_unmap_memory(qxl);
+ qxl_unmap_memory(qxl);
}
pScrn->vtSema = FALSE;
@@ -822,29 +810,26 @@ qxl_close_screen(CLOSE_SCREEN_ARGS_DECL)
}
static void
-set_screen_pixmap_header (ScreenPtr pScreen)
+set_screen_pixmap_header(ScreenPtr pScreen)
{
ScrnInfoPtr pScrn = xf86ScreenToScrn(pScreen);
qxl_screen_t *qxl = pScrn->driverPrivate;
PixmapPtr pPixmap = pScreen->GetScreenPixmap(pScreen);
-
+
// TODO: don't ModifyPixmapHeader too early?
- if (pPixmap)
- {
- ErrorF ("new stride: %d (display width: %d, bpp: %d)\n",
- qxl->pScrn->displayWidth * qxl->bytes_per_pixel,
- qxl->pScrn->displayWidth, qxl->bytes_per_pixel);
-
- pScreen->ModifyPixmapHeader(
- pPixmap,
- qxl->primary_mode.x_res, qxl->primary_mode.y_res,
- -1, -1,
- qxl->pScrn->displayWidth * qxl->bytes_per_pixel,
- NULL);
- }
- else
- ErrorF ("pix: %p;\n", pPixmap);
+ if (pPixmap) {
+ ErrorF("new stride: %d (display width: %d, bpp: %d)\n",
+ qxl->pScrn->displayWidth * qxl->bytes_per_pixel,
+ qxl->pScrn->displayWidth, qxl->bytes_per_pixel);
+
+ pScreen->ModifyPixmapHeader(pPixmap,
+ qxl->primary_mode.x_res, qxl->primary_mode.y_res,
+ -1, -1,
+ qxl->pScrn->displayWidth * qxl->bytes_per_pixel,
+ NULL);
+ } else
+ ErrorF("pix: %p;\n", pPixmap);
}
static Bool
@@ -854,26 +839,26 @@ qxl_resize_primary_to_virtual(qxl_screen_t *qxl)
long new_surface0_size;
if ((qxl->primary_mode.x_res == qxl->virtual_x &&
- qxl->primary_mode.y_res == qxl->virtual_y) &&
+ qxl->primary_mode.y_res == qxl->virtual_y) &&
qxl->device_primary == QXL_DEVICE_PRIMARY_CREATED) {
return TRUE; /* empty Success */
}
- ErrorF ("resizing primary to %dx%d\n", qxl->virtual_x, qxl->virtual_y);
+ ErrorF("resizing primary to %dx%d\n", qxl->virtual_x, qxl->virtual_y);
- new_surface0_size = qxl->virtual_x * qxl->pScrn->bitsPerPixel / 8
- * qxl->virtual_y;
- if (new_surface0_size > qxl->surface0_size)
- {
+ new_surface0_size =
+ qxl->virtual_x * qxl->pScrn->bitsPerPixel / 8 * qxl->virtual_y;
+
+ if (new_surface0_size > qxl->surface0_size) {
if (!qxl_resize_surface0(qxl, new_surface0_size)) {
ErrorF("not resizing primary to virtual, leaving old virtual\n");
return FALSE;
}
}
- if (qxl->primary)
- {
- qxl_surface_kill (qxl->primary);
- qxl_surface_cache_sanity_check (qxl->surface_cache);
+
+ if (qxl->primary) {
+ qxl_surface_kill(qxl->primary);
+ qxl_surface_cache_sanity_check(qxl->surface_cache);
qxl_io_destroy_primary(qxl);
}
@@ -888,22 +873,21 @@ qxl_resize_primary_to_virtual(qxl_screen_t *qxl)
pm->y_mili = 0; // TODO
pm->orientation = 0; // ? supported by us for single head usage? more TODO
}
- qxl->primary = qxl_surface_cache_create_primary (qxl->surface_cache, &qxl->primary_mode);
+ qxl->primary = qxl_surface_cache_create_primary(qxl->surface_cache, &qxl->primary_mode);
qxl->bytes_per_pixel = (qxl->pScrn->bitsPerPixel + 7) / 8;
pScreen = qxl->pScrn->pScreen;
- if (pScreen)
- {
- PixmapPtr root = pScreen->GetScreenPixmap (pScreen);
- qxl_surface_t *surf;
+ if (pScreen) {
+ PixmapPtr root = pScreen->GetScreenPixmap(pScreen);
+ qxl_surface_t *surf;
+
+ if ((surf = get_surface(root)))
+ qxl_surface_kill(surf);
- if ((surf = get_surface (root)))
- qxl_surface_kill (surf);
-
- set_surface (root, qxl->primary);
+ set_surface(root, qxl->primary);
}
- ErrorF ("primary is %p\n", qxl->primary);
+ ErrorF("primary is %p\n", qxl->primary);
return TRUE;
}
@@ -927,13 +911,12 @@ qxl_switch_mode(SWITCH_MODE_ARGS_DECL)
SCRN_INFO_PTR(arg);
qxl_screen_t *qxl = pScrn->driverPrivate;
- ErrorF ("Ignoring display mode, ensuring recreation of primary\n");
+ ErrorF("Ignoring display mode, ensuring recreation of primary\n");
return qxl_resize_primary_to_virtual(qxl);
}
-enum ROPDescriptor
-{
+enum ROPDescriptor {
ROPD_INVERS_SRC = (1 << 0),
ROPD_INVERS_BRUSH = (1 << 1),
ROPD_INVERS_DEST = (1 << 2),
@@ -962,11 +945,10 @@ qxl_update_monitors_config(qxl_screen_t *qxl)
crtc = qxl->crtcs[i];
head->id = i;
head->surface_id = 0;
- head->flags = 0;
+ head->flags = 0;
if (!crtc->enabled || crtc->mode.CrtcHDisplay == 0 ||
crtc->mode.CrtcVDisplay == 0) {
head->width = head->height = head->x = head->y = 0;
- head->height = 0;
} else {
head->width = crtc->mode.CrtcHDisplay;
head->height = crtc->mode.CrtcVDisplay;
@@ -976,10 +958,10 @@ qxl_update_monitors_config(qxl_screen_t *qxl)
}
}
/* initialize when actually used, memslots should be initialized by now */
- if (ram->monitors_config == 0) {
- ram->monitors_config = physical_address (qxl, qxl->monitors_config,
- qxl->main_mem_slot);
- }
+ if (ram->monitors_config == 0)
+ ram->monitors_config = physical_address(qxl, qxl->monitors_config,
+ qxl->main_mem_slot);
+
qxl_io_monitors_config_async(qxl);
}
@@ -991,13 +973,14 @@ qxl_create_desired_modes(qxl_screen_t *qxl)
for (i = 0 ; i < config->num_crtc; ++i) {
xf86CrtcPtr crtc = config->crtc[i];
- if (!crtc->enabled) {
+ if (!crtc->enabled)
continue;
- }
+
if (!crtc->funcs->set_mode_major(crtc, &crtc->desiredMode, crtc->desiredRotation,
crtc->desiredX, crtc->desiredY))
return FALSE;
}
+
qxl_update_monitors_config(qxl);
return TRUE;
}
@@ -1010,9 +993,9 @@ qxl_update_edid(qxl_screen_t *qxl)
for (i = 0 ; i < config->num_crtc; ++i) {
xf86CrtcPtr crtc = config->crtc[i];
- if (!crtc->enabled) {
+ if (!crtc->enabled)
continue;
- }
+
qxl_output_edid_set(qxl->outputs[i], i, &crtc->desiredMode);
}
}
@@ -1026,22 +1009,22 @@ qxl_create_screen_resources(ScreenPtr pScreen)
PixmapPtr pPixmap;
qxl_surface_t *surf;
int i;
-
+
pScreen->CreateScreenResources = qxl->create_screen_resources;
ret = pScreen->CreateScreenResources (pScreen);
pScreen->CreateScreenResources = qxl_create_screen_resources;
if (!ret)
- return FALSE;
+ return FALSE;
pPixmap = pScreen->GetScreenPixmap (pScreen);
-
+
set_screen_pixmap_header (pScreen);
if ((surf = get_surface (pPixmap)))
- qxl_surface_kill (surf);
-
- set_surface (pPixmap, qxl->primary);
+ qxl_surface_kill (surf);
+
+ set_surface(pPixmap, qxl->primary);
/* HACK - I don't want to enable any crtcs other then the first at the beginning */
for (i = 1; i < qxl->num_heads; ++i) {
@@ -1061,40 +1044,40 @@ int uxa_pixmap_index;
#endif
static Bool
-unaccel (void)
+unaccel(void)
{
return FALSE;
}
static Bool
-qxl_prepare_access (PixmapPtr pixmap, RegionPtr region, uxa_access_t access)
+qxl_prepare_access(PixmapPtr pixmap, RegionPtr region, uxa_access_t access)
{
- return qxl_surface_prepare_access (get_surface (pixmap),
- pixmap, region, access);
+ return qxl_surface_prepare_access(get_surface(pixmap),
+ pixmap, region, access);
}
static void
-qxl_finish_access (PixmapPtr pixmap)
+qxl_finish_access(PixmapPtr pixmap)
{
- qxl_surface_finish_access (get_surface (pixmap), pixmap);
+ qxl_surface_finish_access(get_surface(pixmap), pixmap);
}
static Bool
-qxl_pixmap_is_offscreen (PixmapPtr pixmap)
+qxl_pixmap_is_offscreen(PixmapPtr pixmap)
{
- return !!get_surface (pixmap);
+ return !!get_surface(pixmap);
}
static Bool
-good_alu_and_pm (DrawablePtr drawable, int alu, Pixel planemask)
+good_alu_and_pm(DrawablePtr drawable, int alu, Pixel planemask)
{
- if (!UXA_PM_IS_SOLID (drawable, planemask))
- return FALSE;
-
+ if (!UXA_PM_IS_SOLID(drawable, planemask))
+ return FALSE;
+
if (alu != GXcopy)
- return FALSE;
-
+ return FALSE;
+
return TRUE;
}
@@ -1102,33 +1085,33 @@ good_alu_and_pm (DrawablePtr drawable, int alu, Pixel planemask)
* Solid fill
*/
static Bool
-qxl_check_solid (DrawablePtr drawable, int alu, Pixel planemask)
+qxl_check_solid(DrawablePtr drawable, int alu, Pixel planemask)
{
- if (!good_alu_and_pm (drawable, alu, planemask))
- return FALSE;
-
+ if (!good_alu_and_pm(drawable, alu, planemask))
+ return FALSE;
+
return TRUE;
}
static Bool
-qxl_prepare_solid (PixmapPtr pixmap, int alu, Pixel planemask, Pixel fg)
+qxl_prepare_solid(PixmapPtr pixmap, int alu, Pixel planemask, Pixel fg)
{
qxl_surface_t *surface;
-
- if (!(surface = get_surface (pixmap)))
- return FALSE;
-
- return qxl_surface_prepare_solid (surface, fg);
+
+ if (!(surface = get_surface(pixmap)))
+ return FALSE;
+
+ return qxl_surface_prepare_solid(surface, fg);
}
static void
-qxl_solid (PixmapPtr pixmap, int x1, int y1, int x2, int y2)
+qxl_solid(PixmapPtr pixmap, int x1, int y1, int x2, int y2)
{
- qxl_surface_solid (get_surface (pixmap), x1, y1, x2, y2);
+ qxl_surface_solid(get_surface(pixmap), x1, y1, x2, y2);
}
static void
-qxl_done_solid (PixmapPtr pixmap)
+qxl_done_solid(PixmapPtr pixmap)
{
}
@@ -1136,185 +1119,180 @@ qxl_done_solid (PixmapPtr pixmap)
* Copy
*/
static Bool
-qxl_check_copy (PixmapPtr source, PixmapPtr dest,
- int alu, Pixel planemask)
+qxl_check_copy(PixmapPtr source, PixmapPtr dest,
+ int alu, Pixel planemask)
{
- if (!good_alu_and_pm ((DrawablePtr)source, alu, planemask))
- return FALSE;
-
+ if (!good_alu_and_pm((DrawablePtr)source, alu, planemask))
+ return FALSE;
+
if (source->drawable.bitsPerPixel != dest->drawable.bitsPerPixel)
- {
- ErrorF ("differing bitsperpixel - this shouldn't happen\n");
- return FALSE;
- }
-
+ {
+ ErrorF("differing bitsperpixel - this shouldn't happen\n");
+ return FALSE;
+ }
+
return TRUE;
}
static Bool
-qxl_prepare_copy (PixmapPtr source, PixmapPtr dest,
- int xdir, int ydir, int alu,
- Pixel planemask)
+qxl_prepare_copy(PixmapPtr source, PixmapPtr dest,
+ int xdir, int ydir, int alu,
+ Pixel planemask)
{
- return qxl_surface_prepare_copy (get_surface (dest), get_surface (source));
+ return qxl_surface_prepare_copy(get_surface(dest), get_surface(source));
}
static void
-qxl_copy (PixmapPtr dest,
- int src_x1, int src_y1,
- int dest_x1, int dest_y1,
- int width, int height)
+qxl_copy(PixmapPtr dest,
+ int src_x1, int src_y1,
+ int dest_x1, int dest_y1,
+ int width, int height)
{
- qxl_surface_copy (get_surface (dest),
- src_x1, src_y1,
- dest_x1, dest_y1,
- width, height);
+ qxl_surface_copy(get_surface(dest),
+ src_x1, src_y1,
+ dest_x1, dest_y1,
+ width, height);
}
static void
-qxl_done_copy (PixmapPtr dest)
+qxl_done_copy(PixmapPtr dest)
{
}
static Bool
-qxl_put_image (PixmapPtr pDst, int x, int y, int w, int h,
- char *src, int src_pitch)
+qxl_put_image(PixmapPtr pDst, int x, int y, int w, int h,
+ char *src, int src_pitch)
{
- qxl_surface_t *surface = get_surface (pDst);
+ qxl_surface_t *surface = get_surface(pDst);
if (surface)
- return qxl_surface_put_image (surface, x, y, w, h, src, src_pitch);
+ return qxl_surface_put_image(surface, x, y, w, h, src, src_pitch);
return FALSE;
}
static void
-qxl_set_screen_pixmap (PixmapPtr pixmap)
+qxl_set_screen_pixmap(PixmapPtr pixmap)
{
pixmap->drawable.pScreen->devPrivate = pixmap;
}
static PixmapPtr
-qxl_create_pixmap (ScreenPtr screen, int w, int h, int depth, unsigned usage)
+qxl_create_pixmap(ScreenPtr screen, int w, int h, int depth, unsigned usage)
{
ScrnInfoPtr scrn = xf86ScreenToScrn(screen);
PixmapPtr pixmap;
qxl_screen_t *qxl = scrn->driverPrivate;
qxl_surface_t *surface;
-
+
if (w > 32767 || h > 32767)
- return NULL;
+ return NULL;
- qxl_surface_cache_sanity_check (qxl->surface_cache);
+ qxl_surface_cache_sanity_check(qxl->surface_cache);
#if 0
- ErrorF ("Create pixmap: %d %d @ %d (usage: %d)\n", w, h, depth, usage);
+ ErrorF("Create pixmap: %d %d @ %d (usage: %d)\n", w, h, depth, usage);
#endif
- if (uxa_swapped_out (screen))
- goto fallback;
-
- surface = qxl_surface_create (qxl->surface_cache, w, h, depth);
-
- if (surface)
- {
- /* ErrorF (" Successfully created surface in video memory\n"); */
-
- pixmap = fbCreatePixmap (screen, 0, 0, depth, usage);
-
- screen->ModifyPixmapHeader(pixmap, w, h,
- -1, -1, -1,
- NULL);
-
+ if (uxa_swapped_out(screen))
+ goto fallback;
+
+ surface = qxl_surface_create(qxl->surface_cache, w, h, depth);
+
+ if (surface) {
+ /* ErrorF(" Successfully created surface in video memory\n"); */
+
+ pixmap = fbCreatePixmap(screen, 0, 0, depth, usage);
+
+ screen->ModifyPixmapHeader(pixmap, w, h,
+ -1, -1, -1,
+ NULL);
+
#if 0
- ErrorF ("Create pixmap %p with surface %p\n", pixmap, surface);
+ ErrorF("Create pixmap %p with surface %p\n", pixmap, surface);
#endif
- set_surface (pixmap, surface);
- qxl_surface_set_pixmap (surface, pixmap);
+ set_surface(pixmap, surface);
+ qxl_surface_set_pixmap(surface, pixmap);
- qxl_surface_cache_sanity_check (qxl->surface_cache);
- }
- else
- {
+ qxl_surface_cache_sanity_check(qxl->surface_cache);
+ } else {
#if 0
- ErrorF (" Couldn't allocate %d x %d @ %d surface in video memory\n",
- w, h, depth);
+ ErrorF(" Couldn't allocate %d x %d @ %d surface in video memory\n",
+ w, h, depth);
#endif
- fallback:
- pixmap = fbCreatePixmap (screen, w, h, depth, usage);
+fallback:
+ pixmap = fbCreatePixmap(screen, w, h, depth, usage);
#if 0
- ErrorF ("Create pixmap %p without surface\n", pixmap);
+ ErrorF("Create pixmap %p without surface\n", pixmap);
#endif
}
-
+
return pixmap;
}
static Bool
-qxl_destroy_pixmap (PixmapPtr pixmap)
+qxl_destroy_pixmap(PixmapPtr pixmap)
{
ScreenPtr screen = pixmap->drawable.pScreen;
ScrnInfoPtr scrn = xf86ScreenToScrn(screen);
qxl_screen_t *qxl = scrn->driverPrivate;
qxl_surface_t *surface = NULL;
- qxl_surface_cache_sanity_check (qxl->surface_cache);
-
- if (pixmap->refcnt == 1)
- {
- surface = get_surface (pixmap);
+ qxl_surface_cache_sanity_check(qxl->surface_cache);
+
+ if (pixmap->refcnt == 1) {
+ surface = get_surface(pixmap);
#if 0
- ErrorF ("- Destroy %p (had surface %p)\n", pixmap, surface);
+ ErrorF("- Destroy %p (had surface %p)\n", pixmap, surface);
#endif
-
- if (surface)
- {
- qxl_surface_kill (surface);
- set_surface (pixmap, NULL);
-
- qxl_surface_cache_sanity_check (qxl->surface_cache);
- }
+
+ if (surface) {
+ qxl_surface_kill(surface);
+ set_surface(pixmap, NULL);
+
+ qxl_surface_cache_sanity_check(qxl->surface_cache);
+ }
}
-
- fbDestroyPixmap (pixmap);
+
+ fbDestroyPixmap(pixmap);
return TRUE;
}
static Bool
-setup_uxa (qxl_screen_t *qxl, ScreenPtr screen)
+setup_uxa(qxl_screen_t *qxl, ScreenPtr screen)
{
ScrnInfoPtr scrn = xf86ScreenToScrn(screen);
#if HAS_DIXREGISTERPRIVATEKEY
if (!dixRegisterPrivateKey(&uxa_pixmap_index, PRIVATE_PIXMAP, 0))
- return FALSE;
+ return FALSE;
#else
if (!dixRequestPrivate(&uxa_pixmap_index, 0))
- return FALSE;
+ return FALSE;
#endif
-
+
qxl->uxa = uxa_driver_alloc();
if (qxl->uxa == NULL)
- return FALSE;
+ return FALSE;
memset(qxl->uxa, 0, sizeof(*qxl->uxa));
-
+
qxl->uxa->uxa_major = 1;
qxl->uxa->uxa_minor = 0;
-
+
/* Solid fill */
qxl->uxa->check_solid = qxl_check_solid;
qxl->uxa->prepare_solid = qxl_prepare_solid;
qxl->uxa->solid = qxl_solid;
qxl->uxa->done_solid = qxl_done_solid;
-
+
/* Copy */
qxl->uxa->check_copy = qxl_check_copy;
qxl->uxa->prepare_copy = qxl_prepare_copy;
qxl->uxa->copy = qxl_copy;
qxl->uxa->done_copy = qxl_done_copy;
-
+
/* Composite */
qxl->uxa->check_composite = (typeof(qxl->uxa->check_composite))unaccel;
qxl->uxa->check_composite_target = (typeof(qxl->uxa->check_composite_target))unaccel;
@@ -1322,37 +1300,36 @@ setup_uxa (qxl_screen_t *qxl, ScreenPtr screen)
qxl->uxa->prepare_composite = (typeof(qxl->uxa->prepare_composite))unaccel;
qxl->uxa->composite = (typeof(qxl->uxa->composite))unaccel;
qxl->uxa->done_composite = (typeof(qxl->uxa->done_composite))unaccel;
-
+
/* PutImage */
qxl->uxa->put_image = qxl_put_image;
-
+
/* Prepare access */
qxl->uxa->prepare_access = qxl_prepare_access;
qxl->uxa->finish_access = qxl_finish_access;
-
+
qxl->uxa->pixmap_is_offscreen = qxl_pixmap_is_offscreen;
screen->SetScreenPixmap = qxl_set_screen_pixmap;
screen->CreatePixmap = qxl_create_pixmap;
screen->DestroyPixmap = qxl_destroy_pixmap;
-
- if (!uxa_driver_init(screen, qxl->uxa))
- {
- xf86DrvMsg(scrn->scrnIndex, X_ERROR,
- "UXA initialization failed\n");
- free(qxl->uxa);
- return FALSE;
+
+ if (!uxa_driver_init(screen, qxl->uxa)) {
+ xf86DrvMsg(scrn->scrnIndex, X_ERROR,
+ "UXA initialization failed\n");
+ free(qxl->uxa);
+ return FALSE;
}
-
+
#if 0
uxa_set_fallback_debug(screen, FALSE);
#endif
-
+
#if 0
- if (!uxa_driver_init (screen, qxl->uxa))
- return FALSE;
+ if (!uxa_driver_init(screen, qxl->uxa))
+ return FALSE;
#endif
-
+
return TRUE;
}
@@ -1384,16 +1361,14 @@ qxl_fb_init(qxl_screen_t *qxl, ScreenPtr pScreen)
ScrnInfoPtr pScrn = qxl->pScrn;
#if 0
- ErrorF ("allocated %d x %d %p\n", pScrn->virtualX, pScrn->virtualY, qxl->fb);
+ ErrorF("allocated %d x %d %p\n", pScrn->virtualX, pScrn->virtualY, qxl->fb);
#endif
if (!fbScreenInit(pScreen, NULL,
- pScrn->virtualX, pScrn->virtualY,
- pScrn->xDpi, pScrn->yDpi, pScrn->displayWidth,
- pScrn->bitsPerPixel))
- {
- return FALSE;
- }
+ pScrn->virtualX, pScrn->virtualY,
+ pScrn->xDpi, pScrn->yDpi, pScrn->displayWidth,
+ pScrn->bitsPerPixel))
+ return FALSE;
fbPictureInit(pScreen, NULL, 0);
return TRUE;
@@ -1412,126 +1387,122 @@ qxl_screen_init(SCREEN_INIT_ARGS_DECL)
assert(qxl->pScrn == pScrn);
if (!qxl_map_memory(qxl, pScrn->scrnIndex))
- return FALSE;
+ return FALSE;
#ifdef XSPICE
spiceqxl_screen_init(pScrn, qxl);
#endif
ram_header = (void *)((unsigned long)qxl->ram + (unsigned long)qxl->rom->ram_header_offset);
-
- printf ("ram_header at %d\n", qxl->rom->ram_header_offset);
- printf ("surf0 size: %d\n", qxl->rom->surface0_area_size);
-
+
+ printf("ram_header at %d\n", qxl->rom->ram_header_offset);
+ printf("surf0 size: %d\n", qxl->rom->surface0_area_size);
+
qxl_save_state(pScrn);
qxl_blank_screen(pScreen, SCREEN_SAVER_ON);
-
+
miClearVisualTypes();
if (!miSetVisualTypes(pScrn->depth, miGetDefaultVisualMask(pScrn->depth),
- pScrn->rgbBits, pScrn->defaultVisual))
- goto out;
+ pScrn->rgbBits, pScrn->defaultVisual))
+ goto out;
if (!miSetPixmapDepths())
- goto out;
+ goto out;
pScrn->displayWidth = pScrn->virtualX;
-
- qxl->fb = calloc (pScrn->virtualY * pScrn->displayWidth, 4);
+
+ qxl->fb = calloc(pScrn->virtualY * pScrn->displayWidth, 4);
if (!qxl->fb)
- goto out;
-
+ goto out;
+
#if 0
- ErrorF ("allocated %d x %d %p\n", pScrn->virtualX, pScrn->virtualY, qxl->fb);
+ ErrorF("allocated %d x %d %p\n", pScrn->virtualX, pScrn->virtualY, qxl->fb);
#endif
-
+
pScrn->virtualX = pScrn->currentMode->HDisplay;
pScrn->virtualY = pScrn->currentMode->VDisplay;
if (!qxl_fb_init(qxl, pScreen))
goto out;
-
+
visual = pScreen->visuals + pScreen->numVisuals;
- while (--visual >= pScreen->visuals)
- {
- if ((visual->class | DynamicClass) == DirectColor)
- {
- visual->offsetRed = pScrn->offset.red;
- visual->offsetGreen = pScrn->offset.green;
- visual->offsetBlue = pScrn->offset.blue;
- visual->redMask = pScrn->mask.red;
- visual->greenMask = pScrn->mask.green;
- visual->blueMask = pScrn->mask.blue;
- }
+ while (--visual >= pScreen->visuals) {
+ if ((visual->class | DynamicClass) == DirectColor) {
+ visual->offsetRed = pScrn->offset.red;
+ visual->offsetGreen = pScrn->offset.green;
+ visual->offsetBlue = pScrn->offset.blue;
+ visual->redMask = pScrn->mask.red;
+ visual->greenMask = pScrn->mask.green;
+ visual->blueMask = pScrn->mask.blue;
+ }
}
-
- qxl->uxa = uxa_driver_alloc ();
-
+
+ qxl->uxa = uxa_driver_alloc();
+
/* Set up resources */
- qxl_reset_and_create_mem_slots (qxl);
- ErrorF ("done reset\n");
+ qxl_reset_and_create_mem_slots(qxl);
+ ErrorF("done reset\n");
#ifndef XSPICE
qxl->io_pages = (void *)((unsigned long)qxl->ram);
qxl->io_pages_physical = (void *)((unsigned long)qxl->ram_physical);
#endif
- qxl->command_ring = qxl_ring_create ((struct qxl_ring_header *)&(ram_header->cmd_ring),
- sizeof (struct QXLCommand),
- QXL_COMMAND_RING_SIZE, QXL_IO_NOTIFY_CMD, qxl);
- qxl->cursor_ring = qxl_ring_create ((struct qxl_ring_header *)&(ram_header->cursor_ring),
- sizeof (struct QXLCommand),
- QXL_CURSOR_RING_SIZE, QXL_IO_NOTIFY_CURSOR, qxl);
- qxl->release_ring = qxl_ring_create ((struct qxl_ring_header *)&(ram_header->release_ring),
- sizeof (uint64_t),
- QXL_RELEASE_RING_SIZE, 0, qxl);
-
- qxl->surface_cache = qxl_surface_cache_create (qxl);
-
+ qxl->command_ring = qxl_ring_create((struct qxl_ring_header *)&(ram_header->cmd_ring),
+ sizeof (struct QXLCommand),
+ QXL_COMMAND_RING_SIZE, QXL_IO_NOTIFY_CMD, qxl);
+ qxl->cursor_ring = qxl_ring_create((struct qxl_ring_header *)&(ram_header->cursor_ring),
+ sizeof (struct QXLCommand),
+ QXL_CURSOR_RING_SIZE, QXL_IO_NOTIFY_CURSOR, qxl);
+ qxl->release_ring = qxl_ring_create((struct qxl_ring_header *)&(ram_header->release_ring),
+ sizeof (uint64_t),
+ QXL_RELEASE_RING_SIZE, 0, qxl);
+
+ qxl->surface_cache = qxl_surface_cache_create(qxl);
+
/* xf86DPMSInit(pScreen, xf86DPMSSet, 0); */
-
+
pScreen->SaveScreen = qxl_blank_screen;
- setup_uxa (qxl, pScreen);
+ setup_uxa(qxl, pScreen);
DamageSetup(pScreen);
-
+
/* We need to set totalPixmapSize after setup_uxa and Damage,
- as the privatessize is not computed correctly until then */
+ as the privatessize is not computed correctly until then */
pScreen->totalPixmapSize = BitmapBytePad((sizeof(PixmapRec) + dixPrivatesSize(PRIVATE_PIXMAP) ) * 8);
miDCInitialize(pScreen, xf86GetPointerScreenFuncs());
if (!miCreateDefColormap(pScreen))
- goto out;
+ goto out;
qxl->create_screen_resources = pScreen->CreateScreenResources;
pScreen->CreateScreenResources = qxl_create_screen_resources;
-
+
qxl->close_screen = pScreen->CloseScreen;
pScreen->CloseScreen = qxl_close_screen;
-
- qxl_cursor_init (pScreen);
+
+ qxl_cursor_init(pScreen);
CHECK_POINT();
pScreen->width = pScrn->currentMode->HDisplay;
pScreen->height = pScrn->currentMode->VDisplay;
-
- if (!xf86CrtcScreenInit(pScreen)) {
+
+ if (!xf86CrtcScreenInit(pScreen))
return FALSE;
- }
- if (!qxl_resize_primary_to_virtual(qxl)) {
+ if (!qxl_resize_primary_to_virtual(qxl))
return FALSE;
- }
-
+
/* Note: this must be done after DamageSetup() because it calls
* _dixInitPrivates. And if that has been called, DamageSetup()
* will assert.
*/
- if (!uxa_resources_init (pScreen))
- return FALSE;
+ if (!uxa_resources_init(pScreen))
+ return FALSE;
CHECK_POINT();
return TRUE;
-
-out:
+
+ out:
return FALSE;
}
@@ -1543,32 +1514,29 @@ qxl_enter_vt(VT_FUNC_ARGS_DECL)
qxl_save_state(pScrn);
- qxl_reset_and_create_mem_slots (qxl);
+ qxl_reset_and_create_mem_slots(qxl);
- if (!qxl_resize_primary_to_virtual(qxl)) {
+ if (!qxl_resize_primary_to_virtual(qxl))
return FALSE;
- }
- if (qxl->mem)
- {
- qxl_mem_free_all (qxl->mem);
- qxl_drop_image_cache (qxl);
+ if (qxl->mem) {
+ qxl_mem_free_all(qxl->mem);
+ qxl_drop_image_cache(qxl);
}
if (qxl->surf_mem)
- qxl_mem_free_all (qxl->surf_mem);
+ qxl_mem_free_all(qxl->surf_mem);
- if (qxl->vt_surfaces)
- {
- qxl_surface_cache_replace_all (qxl->surface_cache, qxl->vt_surfaces);
+ if (qxl->vt_surfaces) {
+ qxl_surface_cache_replace_all(qxl->surface_cache, qxl->vt_surfaces);
- qxl->vt_surfaces = NULL;
+ qxl->vt_surfaces = NULL;
}
qxl_create_desired_modes(qxl);
- pScrn->EnableDisableFBAccess (XF86_SCRN_ARG(pScrn), TRUE);
-
+ pScrn->EnableDisableFBAccess(XF86_SCRN_ARG(pScrn), TRUE);
+
return TRUE;
}
@@ -1577,12 +1545,12 @@ qxl_leave_vt(VT_FUNC_ARGS_DECL)
{
SCRN_INFO_PTR(arg);
qxl_screen_t *qxl = pScrn->driverPrivate;
-
- xf86_hide_cursors (pScrn);
- pScrn->EnableDisableFBAccess (XF86_SCRN_ARG(pScrn), FALSE);
+ xf86_hide_cursors(pScrn);
- qxl->vt_surfaces = qxl_surface_cache_evacuate_all (qxl->surface_cache);
+ pScrn->EnableDisableFBAccess(XF86_SCRN_ARG(pScrn), FALSE);
+
+ qxl->vt_surfaces = qxl_surface_cache_evacuate_all(qxl->surface_cache);
ioport_write(qxl, QXL_IO_RESET, 0);
@@ -1596,43 +1564,41 @@ qxl_color_setup(ScrnInfoPtr pScrn)
int scrnIndex = pScrn->scrnIndex;
Gamma gzeros = { 0.0, 0.0, 0.0 };
rgb rzeros = { 0, 0, 0 };
-
+
if (!xf86SetDepthBpp(pScrn, 0, 0, 0, Support32bppFb))
- return FALSE;
-
- if (pScrn->depth != 15 && pScrn->depth != 24)
- {
- xf86DrvMsg(scrnIndex, X_ERROR, "Depth %d is not supported\n",
- pScrn->depth);
- return FALSE;
+ return FALSE;
+
+ if (pScrn->depth != 15 && pScrn->depth != 24) {
+ xf86DrvMsg(scrnIndex, X_ERROR, "Depth %d is not supported\n",
+ pScrn->depth);
+ return FALSE;
}
xf86PrintDepthBpp(pScrn);
-
+
if (!xf86SetWeight(pScrn, rzeros, rzeros))
- return FALSE;
-
+ return FALSE;
+
if (!xf86SetDefaultVisual(pScrn, -1))
- return FALSE;
-
+ return FALSE;
+
if (!xf86SetGamma(pScrn, gzeros))
- return FALSE;
-
+ return FALSE;
+
return TRUE;
}
static void
-print_modes (qxl_screen_t *qxl, int scrnIndex)
+print_modes(qxl_screen_t *qxl, int scrnIndex)
{
int i;
-
- for (i = 0; i < qxl->num_modes; ++i)
- {
- struct QXLMode *m = qxl->modes + i;
-
- xf86DrvMsg (scrnIndex, X_INFO,
- "%d: %dx%d, %d bits, stride %d, %dmm x %dmm, orientation %d\n",
- m->id, m->x_res, m->y_res, m->bits, m->stride, m->x_mili,
- m->y_mili, m->orientation);
+
+ for (i = 0; i < qxl->num_modes; ++i) {
+ struct QXLMode *m = qxl->modes + i;
+
+ xf86DrvMsg(scrnIndex, X_INFO,
+ "%d: %dx%d, %d bits, stride %d, %dmm x %dmm, orientation %d\n",
+ m->id, m->x_res, m->y_res, m->bits, m->stride, m->x_mili,
+ m->y_mili, m->orientation);
}
}
@@ -1643,35 +1609,35 @@ qxl_check_device(ScrnInfoPtr pScrn, qxl_screen_t *qxl)
int scrnIndex = pScrn->scrnIndex;
struct QXLRom *rom = qxl->rom;
struct QXLRam *ram_header = (void *)((unsigned long)qxl->ram + rom->ram_header_offset);
-
+
CHECK_POINT();
-
+
if (rom->magic != 0x4f525851) { /* "QXRO" little-endian */
- xf86DrvMsg(scrnIndex, X_ERROR, "Bad ROM signature %x\n", rom->magic);
- return FALSE;
+ xf86DrvMsg(scrnIndex, X_ERROR, "Bad ROM signature %x\n", rom->magic);
+ return FALSE;
}
-
+
xf86DrvMsg(scrnIndex, X_INFO, "Device version %d.%d\n",
- rom->id, rom->update_id);
-
+ rom->id, rom->update_id);
+
xf86DrvMsg(scrnIndex, X_INFO, "Compression level %d, log level %d\n",
- rom->compression_level,
- rom->log_level);
-
+ rom->compression_level,
+ rom->log_level);
+
xf86DrvMsg(scrnIndex, X_INFO, "%d io pages at 0x%lx\n",
- rom->num_pages, (unsigned long)qxl->ram);
-
+ rom->num_pages, (unsigned long)qxl->ram);
+
xf86DrvMsg(scrnIndex, X_INFO, "RAM header offset: 0x%x\n", rom->ram_header_offset);
if (ram_header->magic != 0x41525851) { /* "QXRA" little-endian */
- xf86DrvMsg(scrnIndex, X_ERROR, "Bad RAM signature %x at %p\n",
- ram_header->magic,
- &ram_header->magic);
- return FALSE;
+ xf86DrvMsg(scrnIndex, X_ERROR, "Bad RAM signature %x at %p\n",
+ ram_header->magic,
+ &ram_header->magic);
+ return FALSE;
}
xf86DrvMsg(scrnIndex, X_INFO, "Correct RAM signature %x\n",
- ram_header->magic);
+ ram_header->magic);
return TRUE;
}
#endif /* !XSPICE */
@@ -1732,7 +1698,7 @@ qxl_output_create_resources(xf86OutputPtr output)
static Bool
qxl_output_set_property(xf86OutputPtr output, Atom property,
- RRPropertyValuePtr value)
+ RRPropertyValuePtr value)
{
/* EDID data is stored in the "EDID" atom property, we must return
* TRUE here for that. No penalty to say ok to everything else. */
@@ -1788,7 +1754,7 @@ qxl_crtc_set_mode_major(xf86CrtcPtr crtc, DisplayModePtr mode,
if (crtc == qxl->crtcs[0] && mode == NULL) {
/* disallow disabling of monitor 0 mode */
- ErrorF ("%s: not allowing crtc 0 disablement\n", __func__);
+ ErrorF("%s: not allowing crtc 0 disablement\n", __func__);
return FALSE;
}
@@ -1805,38 +1771,38 @@ qxl_crtc_set_mode_major(xf86CrtcPtr crtc, DisplayModePtr mode,
}
static void
-qxl_crtc_set_cursor_colors (xf86CrtcPtr crtc, int bg, int fg)
+qxl_crtc_set_cursor_colors(xf86CrtcPtr crtc, int bg, int fg)
{
}
static void
-qxl_crtc_set_cursor_position (xf86CrtcPtr crtc, int x, int y)
+qxl_crtc_set_cursor_position(xf86CrtcPtr crtc, int x, int y)
{
}
static void
-qxl_crtc_load_cursor_argb (xf86CrtcPtr crtc, CARD32 *image)
+qxl_crtc_load_cursor_argb(xf86CrtcPtr crtc, CARD32 *image)
{
}
static void
-qxl_crtc_hide_cursor (xf86CrtcPtr crtc)
+qxl_crtc_hide_cursor(xf86CrtcPtr crtc)
{
}
static void
-qxl_crtc_show_cursor (xf86CrtcPtr crtc)
+qxl_crtc_show_cursor(xf86CrtcPtr crtc)
{
}
static void
qxl_crtc_gamma_set(xf86CrtcPtr crtc, uint16_t *red, uint16_t *green,
- uint16_t *blue, int size)
+ uint16_t *blue, int size)
{
}
static void
-qxl_crtc_destroy (xf86CrtcPtr crtc)
+qxl_crtc_destroy(xf86CrtcPtr crtc)
{
qxl_crtc_private *crtc_private = crtc->driver_private;
qxl_screen_t *qxl = crtc_private->qxl;
@@ -1845,7 +1811,7 @@ qxl_crtc_destroy (xf86CrtcPtr crtc)
}
static Bool
-qxl_crtc_lock (xf86CrtcPtr crtc)
+qxl_crtc_lock(xf86CrtcPtr crtc)
{
qxl_crtc_private *crtc_private = crtc->driver_private;
qxl_screen_t *qxl = crtc_private->qxl;
@@ -1855,7 +1821,7 @@ qxl_crtc_lock (xf86CrtcPtr crtc)
}
static void
-qxl_crtc_unlock (xf86CrtcPtr crtc)
+qxl_crtc_unlock(xf86CrtcPtr crtc)
{
qxl_crtc_private *crtc_private = crtc->driver_private;
qxl_screen_t *qxl = crtc_private->qxl;
@@ -1880,18 +1846,19 @@ static const xf86CrtcFuncsRec qxl_crtc_funcs = {
};
static Bool
-qxl_xf86crtc_resize (ScrnInfoPtr scrn, int width, int height)
+qxl_xf86crtc_resize(ScrnInfoPtr scrn, int width, int height)
{
qxl_screen_t *qxl = scrn->driverPrivate;
xf86DrvMsg(scrn->scrnIndex, X_INFO, "%s: Placeholder resize %dx%d\n",
__func__, width, height);
- if (!qxl_resize_primary(qxl, width, height)) {
+ if (!qxl_resize_primary(qxl, width, height))
return FALSE;
- }
+
scrn->virtualX = width;
scrn->virtualY = height;
qxl_update_monitors_config(qxl);
+
return TRUE;
}
@@ -1916,22 +1883,21 @@ qxl_init_randr(ScrnInfoPtr pScrn, qxl_screen_t *qxl)
qxl->crtcs = xnfcalloc(sizeof(xf86CrtcPtr), qxl->num_heads);
qxl->outputs = xnfcalloc(sizeof(xf86OutputPtr), qxl->num_heads);
+
for (i = 0 ; i < qxl->num_heads; ++i) {
qxl->crtcs[i] = xf86CrtcCreate(pScrn, &qxl_crtc_funcs);
- if (!qxl->crtcs[i]) {
- xf86DrvMsg(pScrn->scrnIndex, X_ERROR, "failed to create Crtc %d",
- i);
- }
+ if (!qxl->crtcs[i])
+ xf86DrvMsg(pScrn->scrnIndex, X_ERROR, "failed to create Crtc %d", i);
+
qxl_crtc = xnfcalloc(sizeof(qxl_crtc_private), 1);
qxl->crtcs[i]->driver_private = qxl_crtc;
qxl_crtc->head = i;
qxl_crtc->qxl = qxl;
snprintf(name, sizeof(name), "qxl-%d", i);
qxl->outputs[i] = output = xf86OutputCreate(pScrn, &qxl_output_funcs, name);
- if (!output) {
- xf86DrvMsg(pScrn->scrnIndex, X_ERROR, "failed to create Output %d",
- i);
- }
+ if (!output)
+ xf86DrvMsg(pScrn->scrnIndex, X_ERROR, "failed to create Output %d", i);
+
output->possible_crtcs = (1 << i); /* bitrange of allowed outputs - do a 1:1 */
output->possible_clones = 0; /* TODO: not? */
qxl_output = xnfcalloc(sizeof(qxl_output_private), 1);
@@ -1959,14 +1925,12 @@ qxl_initialize_x_modes(qxl_screen_t *qxl, ScrnInfoPtr pScrn,
*max_x = *max_y = 0;
/* Create a list of modes used by the qxl_output_get_modes */
- for (i = 0; i < qxl->num_modes; i++)
- {
- if (qxl->modes[i].orientation == 0)
- {
+ for (i = 0; i < qxl->num_modes; i++) {
+ if (qxl->modes[i].orientation == 0) {
size = qxl->modes[i].x_res * qxl->modes[i].y_res * 4;
if (size > qxl->surface0_size) {
- ErrorF ("skipping mode %dx%d not fitting in surface0",
- qxl->modes[i].x_res, qxl->modes[i].y_res);
+ ErrorF("skipping mode %dx%d not fitting in surface0",
+ qxl->modes[i].x_res, qxl->modes[i].y_res);
continue;
}
@@ -1994,8 +1958,8 @@ qxl_pre_init(ScrnInfoPtr pScrn, int flags)
* function to get called without a confScreen.
*/
if (!pScrn->confScreen)
- return FALSE;
-
+ return FALSE;
+
CHECK_POINT();
mspace_set_abort_func(qxl_mspace_abort_func);
@@ -2003,20 +1967,20 @@ qxl_pre_init(ScrnInfoPtr pScrn, int flags)
/* zaphod mode is for suckers and i choose not to implement it */
if (xf86IsEntityShared(pScrn->entityList[0])) {
- xf86DrvMsg(scrnIndex, X_ERROR, "No Zaphod mode for you\n");
- return FALSE;
+ xf86DrvMsg(scrnIndex, X_ERROR, "No Zaphod mode for you\n");
+ return FALSE;
}
-
+
if (!pScrn->driverPrivate)
- pScrn->driverPrivate = xnfcalloc(sizeof(qxl_screen_t), 1);
+ pScrn->driverPrivate = xnfcalloc(sizeof(qxl_screen_t), 1);
+
qxl = pScrn->driverPrivate;
memset(qxl, 0, sizeof(qxl));
qxl->device_primary = QXL_DEVICE_PRIMARY_UNDEFINED;
qxl->pScrn = pScrn;
qxl->x_modes = NULL;
-
qxl->entity = xf86GetEntityInfo(pScrn->entityList[0]);
-
+
#ifndef XSPICE
qxl->pci = xf86GetPciInfoForEntity(qxl->entity->index);
#ifndef XSERVER_LIBPCIACCESS
@@ -2027,37 +1991,37 @@ qxl_pre_init(ScrnInfoPtr pScrn, int flags)
ErrorF ("Ignoring monitor config, device revision < 4\n");
}
pScrn->monitor = pScrn->confScreen->monitor;
-
+
if (!qxl_color_setup(pScrn))
- goto out;
-
+ goto out;
+
/* option parsing and card differentiation */
xf86CollectOptions(pScrn, NULL);
memcpy(qxl->options, DefaultOptions, sizeof(DefaultOptions));
xf86ProcessOptions(scrnIndex, pScrn->options, qxl->options);
qxl->enable_image_cache =
- xf86ReturnOptValBool (qxl->options, OPTION_ENABLE_IMAGE_CACHE, TRUE);
+ xf86ReturnOptValBool(qxl->options, OPTION_ENABLE_IMAGE_CACHE, TRUE);
qxl->enable_fallback_cache =
- xf86ReturnOptValBool (qxl->options, OPTION_ENABLE_FALLBACK_CACHE, TRUE);
+ xf86ReturnOptValBool(qxl->options, OPTION_ENABLE_FALLBACK_CACHE, TRUE);
qxl->enable_surfaces =
- xf86ReturnOptValBool (qxl->options, OPTION_ENABLE_SURFACES, TRUE);
+ xf86ReturnOptValBool(qxl->options, OPTION_ENABLE_SURFACES, TRUE);
qxl->num_heads =
- get_int_option (qxl->options, OPTION_NUM_HEADS, "QXL_NUM_HEADS");
+ get_int_option(qxl->options, OPTION_NUM_HEADS, "QXL_NUM_HEADS");
xf86DrvMsg(scrnIndex, X_INFO, "Offscreen Surfaces: %s\n",
- qxl->enable_surfaces? "Enabled" : "Disabled");
+ qxl->enable_surfaces? "Enabled" : "Disabled");
xf86DrvMsg(scrnIndex, X_INFO, "Image Cache: %s\n",
- qxl->enable_image_cache? "Enabled" : "Disabled");
+ qxl->enable_image_cache? "Enabled" : "Disabled");
xf86DrvMsg(scrnIndex, X_INFO, "Fallback Cache: %s\n",
- qxl->enable_fallback_cache? "Enabled" : "Disabled");
-
+ qxl->enable_fallback_cache? "Enabled" : "Disabled");
+
if (!qxl_map_memory(qxl, scrnIndex))
- goto out;
-
+ goto out;
+
#ifndef XSPICE
if (!qxl_check_device(pScrn, qxl))
- goto out;
+ goto out;
#else
xspice_init_qxl_ram(qxl); /* initialize the rings */
#endif
@@ -2066,7 +2030,7 @@ qxl_pre_init(ScrnInfoPtr pScrn, int flags)
xf86DrvMsg(scrnIndex, X_INFO, "%d surfaces\n", qxl->rom->n_surfaces);
/* ddc stuff here */
-
+
clockRanges = xnfcalloc(sizeof(ClockRange), 1);
clockRanges->next = NULL;
clockRanges->minClock = 10000;
@@ -2075,19 +2039,19 @@ qxl_pre_init(ScrnInfoPtr pScrn, int flags)
clockRanges->interlaceAllowed = clockRanges->doubleScanAllowed = 0;
clockRanges->ClockMulFactor = clockRanges->ClockDivFactor = 1;
pScrn->progClock = TRUE;
-
+
/* override QXL monitor stuff */
if (pScrn->monitor->nHsync <= 0) {
- pScrn->monitor->hsync[0].lo = 29.0;
- pScrn->monitor->hsync[0].hi = 160.0;
- pScrn->monitor->nHsync = 1;
+ pScrn->monitor->hsync[0].lo = 29.0;
+ pScrn->monitor->hsync[0].hi = 160.0;
+ pScrn->monitor->nHsync = 1;
}
if (pScrn->monitor->nVrefresh <= 0) {
- pScrn->monitor->vrefresh[0].lo = 50;
- pScrn->monitor->vrefresh[0].hi = 75;
- pScrn->monitor->nVrefresh = 1;
+ pScrn->monitor->vrefresh[0].lo = 50;
+ pScrn->monitor->vrefresh[0].hi = 75;
+ pScrn->monitor->nVrefresh = 1;
}
-
+
qxl_initialize_x_modes(qxl, pScrn, &max_x, &max_y);
#if 0
@@ -2096,26 +2060,26 @@ qxl_pre_init(ScrnInfoPtr pScrn, int flags)
to a virtual size which will not fit into the framebuffer when this
happens we prefer max width and make height as large as possible */
if (max_x * max_y * (pScrn->bitsPerPixel / 8) >
- qxl->rom->surface0_area_size)
+ qxl->rom->surface0_area_size)
pScrn->display->virtualY = qxl->rom->surface0_area_size /
- (max_x * (pScrn->bitsPerPixel / 8));
+ (max_x * (pScrn->bitsPerPixel / 8));
else
pScrn->display->virtualY = max_y;
- pScrn->display->virtualX = max_x;
+ pScrn->display->virtualX = max_x;
}
if (0 >= xf86ValidateModes(pScrn, pScrn->monitor->Modes,
- pScrn->display->modes, clockRanges, linePitches,
- 128, max_x, 128 * 4, 128, max_y,
- pScrn->display->virtualX,
- pScrn->display->virtualY,
- 128 * 1024 * 1024, LOOKUP_BEST_REFRESH))
- goto out;
+ pScrn->display->modes, clockRanges, linePitches,
+ 128, max_x, 128 * 4, 128, max_y,
+ pScrn->display->virtualX,
+ pScrn->display->virtualY,
+ 128 * 1024 * 1024, LOOKUP_BEST_REFRESH))
+ goto out;
#endif
-
+
CHECK_POINT();
-
+
xf86PruneDriverModes(pScrn);
qxl_init_randr(pScrn, qxl);
@@ -2131,18 +2095,17 @@ qxl_pre_init(ScrnInfoPtr pScrn, int flags)
//xf86PrintModes(pScrn);
xf86SetDpi(pScrn, 0, 0);
-
+
if (!xf86LoadSubModule(pScrn, "fb")
#ifndef XSPICE
- || !xf86LoadSubModule(pScrn, "ramdac")
- || !xf86LoadSubModule(pScrn, "vgahw")
+ || !xf86LoadSubModule(pScrn, "ramdac")
+ || !xf86LoadSubModule(pScrn, "vgahw")
#endif
- )
- {
- goto out;
+ ) {
+ goto out;
}
-
- print_modes (qxl, scrnIndex);
+
+ print_modes(qxl, scrnIndex);
#ifndef XSPICE
/* VGA hardware initialisation */
@@ -2153,55 +2116,52 @@ qxl_pre_init(ScrnInfoPtr pScrn, int flags)
/* hate */
qxl_unmap_memory(qxl);
-
+
CHECK_POINT();
-
+
xf86DrvMsg(scrnIndex, X_INFO, "PreInit complete\n");
#ifdef GIT_VERSION
xf86DrvMsg(scrnIndex, X_INFO, "git commit %s\n", GIT_VERSION);
#endif
return TRUE;
-
-out:
+
+ out:
if (clockRanges)
- free(clockRanges);
+ free(clockRanges);
if (qxl)
- free(qxl);
-
+ free(qxl);
+
return FALSE;
}
#ifndef XSPICE
#ifdef XSERVER_LIBPCIACCESS
-enum qxl_class
-{
+enum qxl_class {
CHIP_QXL_1,
};
static const struct pci_id_match qxl_device_match[] = {
{
- PCI_VENDOR_RED_HAT, PCI_CHIP_QXL_0100, PCI_MATCH_ANY, PCI_MATCH_ANY,
- 0x00000000, 0x00000000, CHIP_QXL_1
+ PCI_VENDOR_RED_HAT, PCI_CHIP_QXL_0100, PCI_MATCH_ANY, PCI_MATCH_ANY,
+ 0x00000000, 0x00000000, CHIP_QXL_1
},
{
- PCI_VENDOR_RED_HAT, PCI_CHIP_QXL_01FF, PCI_MATCH_ANY, PCI_MATCH_ANY,
- 0x00000000, 0x00000000, CHIP_QXL_1
+ PCI_VENDOR_RED_HAT, PCI_CHIP_QXL_01FF, PCI_MATCH_ANY, PCI_MATCH_ANY,
+ 0x00000000, 0x00000000, CHIP_QXL_1
},
{ 0 },
};
#endif
-static SymTabRec qxlChips[] =
-{
- { PCI_CHIP_QXL_0100, "QXL 1", },
+static SymTabRec qxlChips[] = {
+ { PCI_CHIP_QXL_0100, "QXL 1", },
{ -1, NULL }
};
#ifndef XSERVER_LIBPCIACCESS
-static PciChipsets qxlPciChips[] =
-{
- { PCI_CHIP_QXL_0100, PCI_CHIP_QXL_0100, RES_SHARED_VGA },
+static PciChipsets qxlPciChips[] = {
+ { PCI_CHIP_QXL_0100, PCI_CHIP_QXL_0100, RES_SHARED_VGA },
{ -1, -1, RES_UNDEFINED }
};
#endif
@@ -2219,13 +2179,14 @@ static void
qxl_init_scrn(ScrnInfoPtr pScrn)
{
pScrn->driverVersion = 0;
- pScrn->driverName = pScrn->name = QXL_DRIVER_NAME;
- pScrn->PreInit = qxl_pre_init;
- pScrn->ScreenInit = qxl_screen_init;
- pScrn->SwitchMode = qxl_switch_mode;
- pScrn->ValidMode = NULL,
- pScrn->EnterVT = qxl_enter_vt;
- pScrn->LeaveVT = qxl_leave_vt;
+ pScrn->driverName = QXL_DRIVER_NAME;
+ pScrn->name = QXL_DRIVER_NAME;
+ pScrn->PreInit = qxl_pre_init;
+ pScrn->ScreenInit = qxl_screen_init;
+ pScrn->SwitchMode = qxl_switch_mode;
+ pScrn->ValidMode = NULL,
+ pScrn->EnterVT = qxl_enter_vt;
+ pScrn->LeaveVT = qxl_leave_vt;
}
#ifdef XSPICE
@@ -2237,9 +2198,8 @@ qxl_probe(struct _DriverRec *drv, int flags)
EntityInfoPtr pEnt;
GDevPtr* device;
- if (flags & PROBE_DETECT) {
+ if (flags & PROBE_DETECT)
return TRUE;
- }
pScrn = xf86AllocateScreen(drv, flags);
qxl_init_scrn(pScrn);
@@ -2269,33 +2229,33 @@ qxl_probe(DriverPtr drv, int flags)
GDevPtr *devSections;
if ((numDevSections = xf86MatchDevice(QXL_NAME, &devSections)) <= 0)
- return FALSE;
+ return FALSE;
if (!xf86GetPciVideoInfo())
- return FALSE;
+ return FALSE;
numUsed = xf86MatchPciInstances(QXL_NAME, PCI_VENDOR_RED_HAT,
- qxlChips, qxlPciChips,
- devSections, numDevSections,
- drv, &usedChips);
+ qxlChips, qxlPciChips,
+ devSections, numDevSections,
+ drv, &usedChips);
xfree(devSections);
if (numUsed < 0) {
- xfree(usedChips);
- return FALSE;
+ xfree(usedChips);
+ return FALSE;
}
if (flags & PROBE_DETECT) {
- xfree(usedChips);
- return TRUE;
+ xfree(usedChips);
+ return TRUE;
}
for (i = 0; i < numUsed; i++) {
- ScrnInfoPtr pScrn = NULL;
- if ((pScrn = xf86ConfigPciEntity(pScrn, 0, usedChips[i], qxlPciChips,
- 0, 0, 0, 0, 0)))
- qxl_init_scrn(pScrn);
+ ScrnInfoPtr pScrn = NULL;
+ if ((pScrn = xf86ConfigPciEntity(pScrn, 0, usedChips[i], qxlPciChips,
+ 0, 0, 0, 0, 0)))
+ qxl_init_scrn(pScrn);
}
xfree(usedChips);
@@ -2309,13 +2269,13 @@ qxl_pci_probe(DriverPtr drv, int entity, struct pci_device *dev, intptr_t match)
{
qxl_screen_t *qxl;
ScrnInfoPtr pScrn = xf86ConfigPciEntity(NULL, 0, entity, NULL, NULL,
- NULL, NULL, NULL, NULL);
+ NULL, NULL, NULL, NULL);
if (!pScrn)
- return FALSE;
+ return FALSE;
if (!pScrn->driverPrivate)
- pScrn->driverPrivate = xnfcalloc(sizeof(qxl_screen_t), 1);
+ pScrn->driverPrivate = xnfcalloc(sizeof(qxl_screen_t), 1);
qxl = pScrn->driverPrivate;
qxl->pci = dev;
@@ -2354,18 +2314,18 @@ static pointer
qxl_setup(pointer module, pointer opts, int *errmaj, int *errmin)
{
static Bool loaded = FALSE;
-
+
if (!loaded) {
- loaded = TRUE;
- xf86AddDriver(&qxl_driver, module, HaveDriverFuncs);
+ loaded = TRUE;
+ xf86AddDriver(&qxl_driver, module, HaveDriverFuncs);
#ifdef XSPICE
- xspice_add_input_drivers(module);
+ xspice_add_input_drivers(module);
#endif
- return (void *)1;
+ return (void *)1;
} else {
- if (errmaj)
- *errmaj = LDR_ONCEONLY;
- return NULL;
+ if (errmaj)
+ *errmaj = LDR_ONCEONLY;
+ return NULL;
}
}
--
1.7.10.4
More information about the Spice-devel
mailing list