1 /* 2 * Virtio GPU Device 3 * 4 * Copyright Red Hat, Inc. 2013-2014 5 * 6 * Authors: 7 * Dave Airlie <airlied@redhat.com> 8 * Gerd Hoffmann <kraxel@redhat.com> 9 * 10 * This work is licensed under the terms of the GNU GPL, version 2 or later. 11 * See the COPYING file in the top-level directory. 12 */ 13 14 #include "qemu/osdep.h" 15 16 #include "hw/virtio/virtio-gpu.h" 17 #include "migration/blocker.h" 18 #include "qapi/error.h" 19 #include "qemu/error-report.h" 20 #include "trace.h" 21 22 void 23 virtio_gpu_base_reset(VirtIOGPUBase *g) 24 { 25 int i; 26 27 g->enable = 0; 28 g->use_virgl_renderer = false; 29 30 for (i = 0; i < g->conf.max_outputs; i++) { 31 g->scanout[i].resource_id = 0; 32 g->scanout[i].width = 0; 33 g->scanout[i].height = 0; 34 g->scanout[i].x = 0; 35 g->scanout[i].y = 0; 36 g->scanout[i].ds = NULL; 37 } 38 } 39 40 void 41 virtio_gpu_base_fill_display_info(VirtIOGPUBase *g, 42 struct virtio_gpu_resp_display_info *dpy_info) 43 { 44 int i; 45 46 for (i = 0; i < g->conf.max_outputs; i++) { 47 if (g->enabled_output_bitmask & (1 << i)) { 48 dpy_info->pmodes[i].enabled = 1; 49 dpy_info->pmodes[i].r.width = cpu_to_le32(g->req_state[i].width); 50 dpy_info->pmodes[i].r.height = cpu_to_le32(g->req_state[i].height); 51 } 52 } 53 } 54 55 static void virtio_gpu_invalidate_display(void *opaque) 56 { 57 } 58 59 static void virtio_gpu_update_display(void *opaque) 60 { 61 } 62 63 static void virtio_gpu_text_update(void *opaque, console_ch_t *chardata) 64 { 65 } 66 67 static void virtio_gpu_notify_event(VirtIOGPUBase *g, uint32_t event_type) 68 { 69 g->virtio_config.events_read |= event_type; 70 virtio_notify_config(&g->parent_obj); 71 } 72 73 static int virtio_gpu_ui_info(void *opaque, uint32_t idx, QemuUIInfo *info) 74 { 75 VirtIOGPUBase *g = opaque; 76 77 if (idx >= g->conf.max_outputs) { 78 return -1; 79 } 80 81 g->req_state[idx].x = info->xoff; 82 g->req_state[idx].y = info->yoff; 83 g->req_state[idx].width = info->width; 84 g->req_state[idx].height = info->height; 85 86 if (info->width && info->height) { 87 g->enabled_output_bitmask |= (1 << idx); 88 } else { 89 g->enabled_output_bitmask &= ~(1 << idx); 90 } 91 92 /* send event to guest */ 93 virtio_gpu_notify_event(g, VIRTIO_GPU_EVENT_DISPLAY); 94 return 0; 95 } 96 97 static void 98 virtio_gpu_gl_block(void *opaque, bool block) 99 { 100 VirtIOGPUBase *g = opaque; 101 VirtIOGPUBaseClass *vgc = VIRTIO_GPU_BASE_GET_CLASS(g); 102 103 if (block) { 104 g->renderer_blocked++; 105 } else { 106 g->renderer_blocked--; 107 } 108 assert(g->renderer_blocked >= 0); 109 110 if (g->renderer_blocked == 0) { 111 vgc->gl_unblock(g); 112 } 113 } 114 115 static const GraphicHwOps virtio_gpu_ops = { 116 .invalidate = virtio_gpu_invalidate_display, 117 .gfx_update = virtio_gpu_update_display, 118 .text_update = virtio_gpu_text_update, 119 .ui_info = virtio_gpu_ui_info, 120 .gl_block = virtio_gpu_gl_block, 121 }; 122 123 bool 124 virtio_gpu_base_device_realize(DeviceState *qdev, 125 VirtIOHandleOutput ctrl_cb, 126 VirtIOHandleOutput cursor_cb, 127 Error **errp) 128 { 129 VirtIODevice *vdev = VIRTIO_DEVICE(qdev); 130 VirtIOGPUBase *g = VIRTIO_GPU_BASE(qdev); 131 int i; 132 133 if (g->conf.max_outputs > VIRTIO_GPU_MAX_SCANOUTS) { 134 error_setg(errp, "invalid max_outputs > %d", VIRTIO_GPU_MAX_SCANOUTS); 135 return false; 136 } 137 138 g->use_virgl_renderer = false; 139 if (virtio_gpu_virgl_enabled(g->conf)) { 140 error_setg(&g->migration_blocker, "virgl is not yet migratable"); 141 if (migrate_add_blocker(g->migration_blocker, errp) < 0) { 142 error_free(g->migration_blocker); 143 return false; 144 } 145 } 146 147 g->virtio_config.num_scanouts = cpu_to_le32(g->conf.max_outputs); 148 virtio_init(VIRTIO_DEVICE(g), "virtio-gpu", VIRTIO_ID_GPU, 149 sizeof(struct virtio_gpu_config)); 150 151 if (virtio_gpu_virgl_enabled(g->conf)) { 152 /* use larger control queue in 3d mode */ 153 virtio_add_queue(vdev, 256, ctrl_cb); 154 virtio_add_queue(vdev, 16, cursor_cb); 155 } else { 156 virtio_add_queue(vdev, 64, ctrl_cb); 157 virtio_add_queue(vdev, 16, cursor_cb); 158 } 159 160 g->enabled_output_bitmask = 1; 161 162 g->req_state[0].width = g->conf.xres; 163 g->req_state[0].height = g->conf.yres; 164 165 g->hw_ops = &virtio_gpu_ops; 166 for (i = 0; i < g->conf.max_outputs; i++) { 167 g->scanout[i].con = 168 graphic_console_init(DEVICE(g), i, &virtio_gpu_ops, g); 169 if (i > 0) { 170 dpy_gfx_replace_surface(g->scanout[i].con, NULL); 171 } 172 } 173 174 return true; 175 } 176 177 static uint64_t 178 virtio_gpu_base_get_features(VirtIODevice *vdev, uint64_t features, 179 Error **errp) 180 { 181 VirtIOGPUBase *g = VIRTIO_GPU_BASE(vdev); 182 183 if (virtio_gpu_virgl_enabled(g->conf)) { 184 features |= (1 << VIRTIO_GPU_F_VIRGL); 185 } 186 if (virtio_gpu_edid_enabled(g->conf)) { 187 features |= (1 << VIRTIO_GPU_F_EDID); 188 } 189 190 return features; 191 } 192 193 static void 194 virtio_gpu_base_set_features(VirtIODevice *vdev, uint64_t features) 195 { 196 static const uint32_t virgl = (1 << VIRTIO_GPU_F_VIRGL); 197 VirtIOGPUBase *g = VIRTIO_GPU_BASE(vdev); 198 199 g->use_virgl_renderer = ((features & virgl) == virgl); 200 trace_virtio_gpu_features(g->use_virgl_renderer); 201 } 202 203 static void 204 virtio_gpu_base_device_unrealize(DeviceState *qdev) 205 { 206 VirtIOGPUBase *g = VIRTIO_GPU_BASE(qdev); 207 208 if (g->migration_blocker) { 209 migrate_del_blocker(g->migration_blocker); 210 error_free(g->migration_blocker); 211 } 212 } 213 214 static void 215 virtio_gpu_base_class_init(ObjectClass *klass, void *data) 216 { 217 DeviceClass *dc = DEVICE_CLASS(klass); 218 VirtioDeviceClass *vdc = VIRTIO_DEVICE_CLASS(klass); 219 220 vdc->unrealize = virtio_gpu_base_device_unrealize; 221 vdc->get_features = virtio_gpu_base_get_features; 222 vdc->set_features = virtio_gpu_base_set_features; 223 224 set_bit(DEVICE_CATEGORY_DISPLAY, dc->categories); 225 dc->hotpluggable = false; 226 } 227 228 static const TypeInfo virtio_gpu_base_info = { 229 .name = TYPE_VIRTIO_GPU_BASE, 230 .parent = TYPE_VIRTIO_DEVICE, 231 .instance_size = sizeof(VirtIOGPUBase), 232 .class_size = sizeof(VirtIOGPUBaseClass), 233 .class_init = virtio_gpu_base_class_init, 234 .abstract = true 235 }; 236 237 static void 238 virtio_register_types(void) 239 { 240 type_register_static(&virtio_gpu_base_info); 241 } 242 243 type_init(virtio_register_types) 244 245 QEMU_BUILD_BUG_ON(sizeof(struct virtio_gpu_ctrl_hdr) != 24); 246 QEMU_BUILD_BUG_ON(sizeof(struct virtio_gpu_update_cursor) != 56); 247 QEMU_BUILD_BUG_ON(sizeof(struct virtio_gpu_resource_unref) != 32); 248 QEMU_BUILD_BUG_ON(sizeof(struct virtio_gpu_resource_create_2d) != 40); 249 QEMU_BUILD_BUG_ON(sizeof(struct virtio_gpu_set_scanout) != 48); 250 QEMU_BUILD_BUG_ON(sizeof(struct virtio_gpu_resource_flush) != 48); 251 QEMU_BUILD_BUG_ON(sizeof(struct virtio_gpu_transfer_to_host_2d) != 56); 252 QEMU_BUILD_BUG_ON(sizeof(struct virtio_gpu_mem_entry) != 16); 253 QEMU_BUILD_BUG_ON(sizeof(struct virtio_gpu_resource_attach_backing) != 32); 254 QEMU_BUILD_BUG_ON(sizeof(struct virtio_gpu_resource_detach_backing) != 32); 255 QEMU_BUILD_BUG_ON(sizeof(struct virtio_gpu_resp_display_info) != 408); 256 257 QEMU_BUILD_BUG_ON(sizeof(struct virtio_gpu_transfer_host_3d) != 72); 258 QEMU_BUILD_BUG_ON(sizeof(struct virtio_gpu_resource_create_3d) != 72); 259 QEMU_BUILD_BUG_ON(sizeof(struct virtio_gpu_ctx_create) != 96); 260 QEMU_BUILD_BUG_ON(sizeof(struct virtio_gpu_ctx_destroy) != 24); 261 QEMU_BUILD_BUG_ON(sizeof(struct virtio_gpu_ctx_resource) != 32); 262 QEMU_BUILD_BUG_ON(sizeof(struct virtio_gpu_cmd_submit) != 32); 263 QEMU_BUILD_BUG_ON(sizeof(struct virtio_gpu_get_capset_info) != 32); 264 QEMU_BUILD_BUG_ON(sizeof(struct virtio_gpu_resp_capset_info) != 40); 265 QEMU_BUILD_BUG_ON(sizeof(struct virtio_gpu_get_capset) != 32); 266 QEMU_BUILD_BUG_ON(sizeof(struct virtio_gpu_resp_capset) != 24); 267