hw/display/ati_2d.c

   1 /*
   2  * QEMU ATI SVGA emulation
   3  * 2D engine functions
   4  *
   5  * Copyright (c) 2019 BALATON Zoltan
   6  *
   7  * This work is licensed under the GNU GPL license version 2 or later.
   8  */
   9
  10 #include "qemu/osdep.h"
  11 #include "ati_int.h"
  12 #include "ati_regs.h"
  13 #include "qemu/log.h"
  14 #include "ui/pixel_ops.h"
  15 #include "ui/console.h"
  16
  17 /*
  18  * NOTE:
  19  * This is 2D _acceleration_ and supposed to be fast. Therefore, don't try to
  20  * reinvent the wheel (unlikely to get better with a naive implementation than
  21  * existing libraries) and avoid (poorly) reimplementing gfx primitives.
  22  * That is unnecessary and would become a performance problem. Instead, try to
  23  * map to and reuse existing optimised facilities (e.g. pixman) wherever
  24  * possible.
  25  */
  26
  27 static int ati_bpp_from_datatype(ATIVGAState *s)
  28 {
  29     switch (s->regs.dp_datatype & 0xf) {
  30     case 2:
  31         return 8;
  32     case 3:
  33     case 4:
  34         return 16;
  35     case 5:
  36         return 24;
  37     case 6:
  38         return 32;
  39     default:
  40         qemu_log_mask(LOG_UNIMP, "Unknown dst datatype %d\n",
  41                       s->regs.dp_datatype & 0xf);
  42         return 0;
  43     }
  44 }
  45
  46 #define DEFAULT_CNTL (s->regs.dp_gui_master_cntl & GMC_DST_PITCH_OFFSET_CNTL)
  47
  48 void ati_2d_blt(ATIVGAState *s)
  49 {
  50     /* FIXME it is probably more complex than this and may need to be */
  51     /* rewritten but for now as a start just to get some output: */
  52     DisplaySurface *ds = qemu_console_surface(s->vga.con);
  53     DPRINTF("%p %u ds: %p %d %d rop: %x\n", s->vga.vram_ptr,
  54             s->vga.vbe_start_addr, surface_data(ds), surface_stride(ds),
  55             surface_bits_per_pixel(ds),
  56             (s->regs.dp_mix & GMC_ROP3_MASK) >> 16);
  57     unsigned dst_x = (s->regs.dp_cntl & DST_X_LEFT_TO_RIGHT ?
  58                       s->regs.dst_x : s->regs.dst_x + 1 - s->regs.dst_width);
  59     unsigned dst_y = (s->regs.dp_cntl & DST_Y_TOP_TO_BOTTOM ?
  60                       s->regs.dst_y : s->regs.dst_y + 1 - s->regs.dst_height);
  61     int bpp = ati_bpp_from_datatype(s);
  62     if (!bpp) {
  63         qemu_log_mask(LOG_GUEST_ERROR, "Invalid bpp\n");
  64         return;
  65     }
  66     int dst_stride = DEFAULT_CNTL ? s->regs.dst_pitch : s->regs.default_pitch;
  67     if (!dst_stride) {
  68         qemu_log_mask(LOG_GUEST_ERROR, "Zero dest pitch\n");
  69         return;
  70     }
  71     uint8_t *dst_bits = s->vga.vram_ptr + (DEFAULT_CNTL ?
  72                         s->regs.dst_offset : s->regs.default_offset);
  73
  74     if (s->dev_id == PCI_DEVICE_ID_ATI_RAGE128_PF) {
  75         dst_bits += s->regs.crtc_offset & 0x07ffffff;
  76         dst_stride *= bpp;
  77     }
  78     uint8_t *end = s->vga.vram_ptr + s->vga.vram_size;
  79     if (dst_x > 0x3fff || dst_y > 0x3fff || dst_bits >= end
  80         || dst_bits + dst_x
  81          + (dst_y + s->regs.dst_height) * dst_stride >= end) {
  82         qemu_log_mask(LOG_UNIMP, "blt outside vram not implemented\n");
  83         return;
  84     }
  85     DPRINTF("%d %d %d, %d %d %d, (%d,%d) -> (%d,%d) %dx%d %c %c\n",
  86             s->regs.src_offset, s->regs.dst_offset, s->regs.default_offset,
  87             s->regs.src_pitch, s->regs.dst_pitch, s->regs.default_pitch,
  88             s->regs.src_x, s->regs.src_y, dst_x, dst_y,
  89             s->regs.dst_width, s->regs.dst_height,
  90             (s->regs.dp_cntl & DST_X_LEFT_TO_RIGHT ? '>' : '<'),
  91             (s->regs.dp_cntl & DST_Y_TOP_TO_BOTTOM ? 'v' : '^'));
  92     switch (s->regs.dp_mix & GMC_ROP3_MASK) {
  93     case ROP3_SRCCOPY:
  94     {
  95         bool fallback = false;
  96         unsigned src_x = (s->regs.dp_cntl & DST_X_LEFT_TO_RIGHT ?
  97                        s->regs.src_x : s->regs.src_x + 1 - s->regs.dst_width);
  98         unsigned src_y = (s->regs.dp_cntl & DST_Y_TOP_TO_BOTTOM ?
  99                        s->regs.src_y : s->regs.src_y + 1 - s->regs.dst_height);
 100         int src_stride = DEFAULT_CNTL ?
 101                          s->regs.src_pitch : s->regs.default_pitch;
 102         if (!src_stride) {
 103             qemu_log_mask(LOG_GUEST_ERROR, "Zero source pitch\n");
 104             return;
 105         }
 106         uint8_t *src_bits = s->vga.vram_ptr + (DEFAULT_CNTL ?
 107                             s->regs.src_offset : s->regs.default_offset);
 108
 109         if (s->dev_id == PCI_DEVICE_ID_ATI_RAGE128_PF) {
 110             src_bits += s->regs.crtc_offset & 0x07ffffff;
 111             src_stride *= bpp;
 112         }
 113         if (src_x > 0x3fff || src_y > 0x3fff || src_bits >= end
 114             || src_bits + src_x
 115              + (src_y + s->regs.dst_height) * src_stride >= end) {
 116             qemu_log_mask(LOG_UNIMP, "blt outside vram not implemented\n");
 117             return;
 118         }
 119
 120         src_stride /= sizeof(uint32_t);
 121         dst_stride /= sizeof(uint32_t);
 122         DPRINTF("pixman_blt(%p, %p, %d, %d, %d, %d, %d, %d, %d, %d, %d, %d)\n",
 123                 src_bits, dst_bits, src_stride, dst_stride, bpp, bpp,
 124                 src_x, src_y, dst_x, dst_y,
 125                 s->regs.dst_width, s->regs.dst_height);
 126 #ifdef CONFIG_PIXMAN
 127         if ((s->use_pixman & BIT(1)) &&
 128             s->regs.dp_cntl & DST_X_LEFT_TO_RIGHT &&
 129             s->regs.dp_cntl & DST_Y_TOP_TO_BOTTOM) {
 130             fallback = !pixman_blt((uint32_t *)src_bits, (uint32_t *)dst_bits,
 131                                    src_stride, dst_stride, bpp, bpp,
 132                                    src_x, src_y, dst_x, dst_y,
 133                                    s->regs.dst_width, s->regs.dst_height);
 134         } else if (s->use_pixman & BIT(1)) {
 135             /* FIXME: We only really need a temporary if src and dst overlap */
 136             int llb = s->regs.dst_width * (bpp / 8);
 137             int tmp_stride = DIV_ROUND_UP(llb, sizeof(uint32_t));
 138             uint32_t *tmp = g_malloc(tmp_stride * sizeof(uint32_t) *
 139                                      s->regs.dst_height);
 140             fallback = !pixman_blt((uint32_t *)src_bits, tmp,
 141                                    src_stride, tmp_stride, bpp, bpp,
 142                                    src_x, src_y, 0, 0,
 143                                    s->regs.dst_width, s->regs.dst_height);
 144             if (!fallback) {
 145                 fallback = !pixman_blt(tmp, (uint32_t *)dst_bits,
 146                                        tmp_stride, dst_stride, bpp, bpp,
 147                                        0, 0, dst_x, dst_y,
 148                                        s->regs.dst_width, s->regs.dst_height);
 149             }
 150             g_free(tmp);
 151         } else
 152 #endif
 153         {
 154             fallback = true;
 155         }
 156         if (fallback) {
 157             unsigned int y, i, j, bypp = bpp / 8;
 158             unsigned int src_pitch = src_stride * sizeof(uint32_t);
 159             unsigned int dst_pitch = dst_stride * sizeof(uint32_t);
 160
 161             for (y = 0; y < s->regs.dst_height; y++) {
 162                 i = dst_x * bypp;
 163                 j = src_x * bypp;
 164                 if (s->regs.dp_cntl & DST_Y_TOP_TO_BOTTOM) {
 165                     i += (dst_y + y) * dst_pitch;
 166                     j += (src_y + y) * src_pitch;
 167                 } else {
 168                     i += (dst_y + s->regs.dst_height - 1 - y) * dst_pitch;
 169                     j += (src_y + s->regs.dst_height - 1 - y) * src_pitch;
 170                 }
 171                 memmove(&dst_bits[i], &src_bits[j], s->regs.dst_width * bypp);
 172             }
 173         }
 174         if (dst_bits >= s->vga.vram_ptr + s->vga.vbe_start_addr &&
 175             dst_bits < s->vga.vram_ptr + s->vga.vbe_start_addr +
 176             s->vga.vbe_regs[VBE_DISPI_INDEX_YRES] * s->vga.vbe_line_offset) {
 177             memory_region_set_dirty(&s->vga.vram, s->vga.vbe_start_addr +
 178                                     s->regs.dst_offset +
 179                                     dst_y * surface_stride(ds),
 180                                     s->regs.dst_height * surface_stride(ds));
 181         }
 182         s->regs.dst_x = (s->regs.dp_cntl & DST_X_LEFT_TO_RIGHT ?
 183                          dst_x + s->regs.dst_width : dst_x);
 184         s->regs.dst_y = (s->regs.dp_cntl & DST_Y_TOP_TO_BOTTOM ?
 185                          dst_y + s->regs.dst_height : dst_y);
 186         break;
 187     }
 188     case ROP3_PATCOPY:
 189     case ROP3_BLACKNESS:
 190     case ROP3_WHITENESS:
 191     {
 192         uint32_t filler = 0;
 193
 194         switch (s->regs.dp_mix & GMC_ROP3_MASK) {
 195         case ROP3_PATCOPY:
 196             filler = s->regs.dp_brush_frgd_clr;
 197             break;
 198         case ROP3_BLACKNESS:
 199             filler = 0xffUL << 24 | rgb_to_pixel32(s->vga.palette[0],
 200                      s->vga.palette[1], s->vga.palette[2]);
 201             break;
 202         case ROP3_WHITENESS:
 203             filler = 0xffUL << 24 | rgb_to_pixel32(s->vga.palette[3],
 204                      s->vga.palette[4], s->vga.palette[5]);
 205             break;
 206         }
 207
 208         dst_stride /= sizeof(uint32_t);
 209         DPRINTF("pixman_fill(%p, %d, %d, %d, %d, %d, %d, %x)\n",
 210                 dst_bits, dst_stride, bpp, dst_x, dst_y,
 211                 s->regs.dst_width, s->regs.dst_height, filler);
 212 #ifdef CONFIG_PIXMAN
 213         if (!(s->use_pixman & BIT(0)) ||
 214             !pixman_fill((uint32_t *)dst_bits, dst_stride, bpp, dst_x, dst_y,
 215                     s->regs.dst_width, s->regs.dst_height, filler))
 216 #endif
 217         {
 218             /* fallback when pixman failed or we don't want to call it */
 219             unsigned int x, y, i, bypp = bpp / 8;
 220             unsigned int dst_pitch = dst_stride * sizeof(uint32_t);
 221             for (y = 0; y < s->regs.dst_height; y++) {
 222                 i = dst_x * bypp + (dst_y + y) * dst_pitch;
 223                 for (x = 0; x < s->regs.dst_width; x++, i += bypp) {
 224                     stn_he_p(&dst_bits[i], bypp, filler);
 225                 }
 226             }
 227         }
 228         if (dst_bits >= s->vga.vram_ptr + s->vga.vbe_start_addr &&
 229             dst_bits < s->vga.vram_ptr + s->vga.vbe_start_addr +
 230             s->vga.vbe_regs[VBE_DISPI_INDEX_YRES] * s->vga.vbe_line_offset) {
 231             memory_region_set_dirty(&s->vga.vram, s->vga.vbe_start_addr +
 232                                     s->regs.dst_offset +
 233                                     dst_y * surface_stride(ds),
 234                                     s->regs.dst_height * surface_stride(ds));
 235         }
 236         s->regs.dst_y = (s->regs.dp_cntl & DST_Y_TOP_TO_BOTTOM ?
 237                          dst_y + s->regs.dst_height : dst_y);
 238         break;
 239     }
 240     default:
 241         qemu_log_mask(LOG_UNIMP, "Unimplemented ati_2d blt op %x\n",
 242                       (s->regs.dp_mix & GMC_ROP3_MASK) >> 16);
 243     }
 244 }