diff --git a/system/dev/display/astro-display/astro-display.c b/system/dev/display/astro-display/astro-display.c
index caf2ba2..96150b0 100644
--- a/system/dev/display/astro-display/astro-display.c
+++ b/system/dev/display/astro-display/astro-display.c
@@ -9,7 +9,7 @@
 #include <ddk/device.h>
 #include <ddk/driver.h>
 #include <ddk/io-buffer.h>
-#include <ddk/protocol/display.h>
+#include <ddk/protocol/display-controller.h>
 #include <ddk/protocol/platform-defs.h>
 #include <ddk/protocol/platform-device.h>
 #include <hw/reg.h>
@@ -22,61 +22,186 @@
 #include <zircon/device/display.h>
 #include <zircon/syscalls.h>
 
-static zx_status_t vc_set_mode(void* ctx, zx_display_info_t* info) {
+static const zx_pixel_format_t _gsupported_pixel_formats = { ZX_PIXEL_FORMAT_RGB_565 };
+
+typedef struct image_info {
+    zx_handle_t pmt;
+    uint8_t canvas_idx;
+
+    list_node_t node;
+} image_info_t;
+
+static zx_status_t config_canvas(astro_display_t* display, zx_paddr_t paddr, uint8_t* idx) {
+    uint32_t fbh = display->height * 2;
+    uint32_t fbw = display->stride * 2;
+
+    // TODO: Find index dynamically
+    *idx = OSD2_DMC_CAV_INDEX;
+
+    DISP_INFO("Canvas Diminsions: w=%d h=%d\n", fbw, fbh);
+
+    // set framebuffer address in DMC, read/modify/write
+    WRITE32_DMC_REG(DMC_CAV_LUT_DATAL,
+        (((paddr + 7) >> 3) & DMC_CAV_ADDR_LMASK) |
+             ((((fbw + 7) >> 3) & DMC_CAV_WIDTH_LMASK) << DMC_CAV_WIDTH_LBIT));
+
+    WRITE32_DMC_REG(DMC_CAV_LUT_DATAH,
+        ((((fbw + 7) >> 3) >> DMC_CAV_WIDTH_LWID) << DMC_CAV_WIDTH_HBIT) |
+             ((fbh & DMC_CAV_HEIGHT_MASK) << DMC_CAV_HEIGHT_BIT));
+
+    WRITE32_DMC_REG(DMC_CAV_LUT_ADDR, DMC_CAV_LUT_ADDR_WR_EN | OSD2_DMC_CAV_INDEX );
+    // read a cbus to make sure last write finish.
+    READ32_DMC_REG(DMC_CAV_LUT_DATAH);
+
+    return ZX_OK;
+
+}
+
+static void astro_set_display_controller_cb(void* ctx, void* cb_ctx, display_controller_cb_t* cb) {
+    astro_display_t* display = ctx;
+    mtx_lock(&display->cb_lock);
+
+    mtx_lock(&display->display_lock);
+
+    display->dc_cb = cb;
+    display->dc_cb_ctx = cb_ctx;
+
+    uint64_t display_id = display->display_id;
+    mtx_unlock(&display->display_lock);
+
+    display->dc_cb->on_displays_changed(display->dc_cb_ctx, &display_id, 1, NULL, 0);
+    mtx_unlock(&display->cb_lock);
+}
+
+static zx_status_t astro_get_display_info(void* ctx, uint64_t display_id, display_info_t* info) {
+    astro_display_t* display = ctx;
+    mtx_lock(&display->display_lock);
+    if (display_id != display->display_id) {
+        mtx_unlock(&display->display_lock);
+        return ZX_ERR_NOT_FOUND;
+    }
+
+    info->edid_present = false;
+    info->panel.params.height = display->height;
+    info->panel.params.width = display->width;
+    info->panel.params.refresh_rate_e2 = 3000; // Just guess that it's 30fps
+    info->pixel_formats = &_gsupported_pixel_formats;
+    info->pixel_format_count = sizeof(_gsupported_pixel_formats) / sizeof(zx_pixel_format_t);
+
+    mtx_unlock(&display->display_lock);
     return ZX_OK;
 }
 
-static zx_status_t vc_get_mode(void* ctx, zx_display_info_t* info) {
+static zx_status_t astro_import_vmo_image(void* ctx, image_t* image, zx_handle_t vmo, size_t offset) {
+    image_info_t* import_info = calloc(1, sizeof(image_info_t));
+    if (import_info == NULL) {
+        return ZX_ERR_NO_MEMORY;
+    }
+
+    unsigned pixel_size = ZX_PIXEL_FORMAT_BYTES(image->pixel_format);
+    unsigned size = ROUNDUP(image->width * image->height * pixel_size, PAGE_SIZE);
+    unsigned num_pages = size / PAGE_SIZE;
+    zx_paddr_t paddr[num_pages];
+
     astro_display_t* display = ctx;
-    memcpy(info, &display->disp_info, sizeof(zx_display_info_t));
+    mtx_lock(&display->image_lock);
+
+    zx_status_t status = zx_bti_pin(display->bti, ZX_BTI_PERM_READ, vmo, offset, size,
+                                    paddr, num_pages, &import_info->pmt);
+    if (status != ZX_OK) {
+        goto fail;
+    }
+
+    for (unsigned i = 0; i < num_pages - 1; i++) {
+        if (paddr[i] + PAGE_SIZE != paddr[i + 1]) {
+            status = ZX_ERR_INVALID_ARGS;
+            goto fail;
+        }
+    }
+
+    if (config_canvas(display, paddr[0], &import_info->canvas_idx) != ZX_OK) {
+        status = ZX_ERR_NO_RESOURCES;
+        goto fail;
+    }
+
+    list_add_head(&display->imported_images, &import_info->node);
+    image->handle = (void*) (uint64_t) import_info->canvas_idx;
+
+    mtx_unlock(&display->image_lock);
+
     return ZX_OK;
+fail:
+    mtx_unlock(&display->image_lock);
+
+    if (import_info->pmt != ZX_HANDLE_INVALID) {
+        zx_handle_close(import_info->pmt);
+    }
+    free(import_info);
+    return status;
 }
 
-static zx_status_t vc_get_framebuffer(void* ctx, void** framebuffer) {
-    if (!framebuffer) return ZX_ERR_INVALID_ARGS;
+static void astro_release_image(void* ctx, image_t* image) {
     astro_display_t* display = ctx;
-    *framebuffer = io_buffer_virt(&display->fbuffer);
-    return ZX_OK;
-}
+    mtx_lock(&display->image_lock);
 
-static void flush_framebuffer(astro_display_t* display) {
-    io_buffer_cache_flush(&display->fbuffer, 0,
-        (display->disp_info.stride * display->disp_info.height *
-            ZX_PIXEL_FORMAT_BYTES(display->disp_info.format)));
-}
+    image_info_t* info;
+    list_for_every_entry(&display->imported_images, info, image_info_t, node) {
+        if ((void*) (uint64_t) info->canvas_idx == image->handle) {
+            list_delete(&info->node);
+            break;
+        }
+    }
 
-static void vc_flush_framebuffer(void* ctx) {
-    flush_framebuffer(ctx);
-}
+    mtx_unlock(&display->image_lock);
 
-static void vc_display_set_ownership_change_callback(void* ctx, zx_display_cb_t callback,
-                                                     void* cookie) {
-    astro_display_t* display = ctx;
-    display->ownership_change_callback = callback;
-    display->ownership_change_cookie = cookie;
-}
-
-static void vc_display_acquire_or_release_display(void* ctx, bool acquire) {
-    astro_display_t* display = ctx;
-
-    if (acquire) {
-        display->console_visible = true;
-        if (display->ownership_change_callback)
-            display->ownership_change_callback(true, display->ownership_change_cookie);
-    } else if (!acquire) {
-        display->console_visible = false;
-        if (display->ownership_change_callback)
-            display->ownership_change_callback(false, display->ownership_change_cookie);
+    if (info) {
+        // free_canvas_entry(display, info->canvas_idx);
+        zx_handle_close(info->pmt);
+        free(info);
     }
 }
 
-static display_protocol_ops_t vc_display_proto = {
-    .set_mode = vc_set_mode,
-    .get_mode = vc_get_mode,
-    .get_framebuffer = vc_get_framebuffer,
-    .flush = vc_flush_framebuffer,
-    .set_ownership_change_callback = vc_display_set_ownership_change_callback,
-    .acquire_or_release_display = vc_display_acquire_or_release_display,
+static bool astro_check_configuration(void* ctx,
+                                    display_config_t** display_configs, uint32_t display_count) {
+    if (display_count != 1) {
+        return display_count == 0;
+    }
+    astro_display_t* display = ctx;
+    mtx_lock(&display->display_lock);
+    bool res = (display_configs[0]->display_id == display->display_id
+               && display_configs[0]->mode.h_addressable == display->width
+               && display_configs[0]->image.width == display->width
+               && display_configs[0]->mode.v_addressable == display->height
+               && display_configs[0]->image.height == display->height);
+    mtx_unlock(&display->display_lock);
+    return res;
+}
+
+static void astro_apply_configuration(void* ctx,
+                                    display_config_t** display_configs, uint32_t display_count) {
+    // TODO: Nothing to do for now
+}
+
+static uint32_t astro_compute_linear_stride(void* ctx, uint32_t width, zx_pixel_format_t format) {
+    // The astro display controller needs buffers with a stride that is an even
+    // multiple of 32.
+    return ROUNDUP(width, 32 / ZX_PIXEL_FORMAT_BYTES(format));
+}
+
+static zx_status_t allocate_vmo(void* ctx, uint64_t size, zx_handle_t* vmo_out) {
+    astro_display_t* display = ctx;
+    return zx_vmo_create_contiguous(display->bti, size, 0, vmo_out);
+}
+
+static display_controller_protocol_ops_t display_controller_ops = {
+    .set_display_controller_cb = astro_set_display_controller_cb,
+    .get_display_info = astro_get_display_info,
+    .import_vmo_image = astro_import_vmo_image,
+    .release_image = astro_release_image,
+    .check_configuration = astro_check_configuration,
+    .apply_configuration = astro_apply_configuration,
+    .compute_linear_stride = astro_compute_linear_stride,
+    .allocate_vmo = allocate_vmo,
 };
 
 static void display_release(void* ctx) {
@@ -94,81 +219,6 @@
     .release =  display_release,
 };
 
-struct display_client_device {
-    astro_display_t* display;
-    zx_device_t* device;
-};
-
-static zx_status_t display_client_ioctl(void* ctx, uint32_t op, const void* in_buf, size_t in_len,
-                                        void* out_buf, size_t out_len, size_t* out_actual) {
-    struct display_client_device* client_struct = ctx;
-    astro_display_t* display = client_struct->display;
-    switch (op) {
-    case IOCTL_DISPLAY_GET_FB: {
-        if (out_len < sizeof(ioctl_display_get_fb_t))
-            return ZX_ERR_INVALID_ARGS;
-        ioctl_display_get_fb_t* description = (ioctl_display_get_fb_t*)(out_buf);
-        zx_status_t status = zx_handle_duplicate(display->fbuffer.vmo_handle, ZX_RIGHT_SAME_RIGHTS,
-                                                    &description->vmo);
-        if (status != ZX_OK)
-            return ZX_ERR_NO_RESOURCES;
-        description->info = display->disp_info;
-        *out_actual = sizeof(ioctl_display_get_fb_t);
-        if (display->ownership_change_callback)
-            display->ownership_change_callback(false, display->ownership_change_cookie);
-        return ZX_OK;
-    }
-    case IOCTL_DISPLAY_FLUSH_FB:
-    case IOCTL_DISPLAY_FLUSH_FB_REGION:
-        flush_framebuffer(display);
-        return ZX_OK;
-    default:
-        DISP_ERROR("Invalid ioctl %d\n", op);
-        return ZX_ERR_INVALID_ARGS;
-    }
-}
-
-static zx_status_t display_client_close(void* ctx, uint32_t flags) {
-    struct display_client_device* client_struct = ctx;
-    astro_display_t* display = client_struct->display;
-    if (display->ownership_change_callback)
-        display->ownership_change_callback(true, display->ownership_change_cookie);
-    free(ctx);
-    return ZX_OK;
-}
-
-static zx_protocol_device_t client_device_proto = {
-    .version = DEVICE_OPS_VERSION,
-    .ioctl = display_client_ioctl,
-    .close = display_client_close,
-};
-
-static zx_status_t vc_open(void* ctx, zx_device_t** dev_out, uint32_t flags) {
-    struct display_client_device* s = calloc(1, sizeof(struct display_client_device));
-
-    s->display = ctx;
-
-    device_add_args_t vc_fbuff_args = {
-        .version = DEVICE_ADD_ARGS_VERSION,
-        .name = "astro-display",
-        .ctx = s,
-        .ops = &client_device_proto,
-        .flags = DEVICE_ADD_INSTANCE,
-    };
-    zx_status_t status = device_add(s->display->fbdevice, &vc_fbuff_args, &s->device);
-    if (status != ZX_OK) {
-        free(s);
-        return status;
-    }
-    *dev_out = s->device;
-    return ZX_OK;
-}
-
-static zx_protocol_device_t display_device_proto = {
-    .version = DEVICE_OPS_VERSION,
-    .open = vc_open,
-};
-
 /* Table from Linux source */
 /* TODO: Need to separate backlight driver from display driver */
 static const uint8_t backlight_init_table[] = {
@@ -198,49 +248,31 @@
     }
 }
 
-static void config_canvas(astro_display_t* display) {
-    uint32_t fbh = display->disp_info.height * 2;
-    uint32_t fbw = display->disp_info.stride * 2;
-
-    DISP_INFO("Canvas Diminsions: w=%d h=%d\n", fbw, fbh);
-
-    // set framebuffer address in DMC, read/modify/write
-    WRITE32_DMC_REG(DMC_CAV_LUT_DATAL,
-        (((io_buffer_phys(&display->fbuffer) + 7) >> 3) & DMC_CAV_ADDR_LMASK) |
-             ((((fbw + 7) >> 3) & DMC_CAV_WIDTH_LMASK) << DMC_CAV_WIDTH_LBIT));
-
-    WRITE32_DMC_REG(DMC_CAV_LUT_DATAH,
-        ((((fbw + 7) >> 3) >> DMC_CAV_WIDTH_LWID) << DMC_CAV_WIDTH_HBIT) |
-             ((fbh & DMC_CAV_HEIGHT_MASK) << DMC_CAV_HEIGHT_BIT));
-
-    WRITE32_DMC_REG(DMC_CAV_LUT_ADDR, DMC_CAV_LUT_ADDR_WR_EN | OSD2_DMC_CAV_INDEX );
-    // read a cbus to make sure last write finish.
-    READ32_DMC_REG(DMC_CAV_LUT_DATAH);
-
-}
-
 static zx_status_t setup_display_if(astro_display_t* display) {
     zx_status_t status;
 
+    mtx_lock(&display->cb_lock);
+    mtx_lock(&display->display_lock);
+
+    uint64_t display_added = INVALID_DISPLAY_ID;
+    uint64_t display_removed = INVALID_DISPLAY_ID;
+
     // allocate frame buffer
-    display->disp_info.format = ZX_PIXEL_FORMAT_RGB_565;
-    display->disp_info.width  = 608;
-    display->disp_info.height = 1024;
-    display->disp_info.pixelsize = ZX_PIXEL_FORMAT_BYTES(display->disp_info.format);
-    // The astro display controller needs buffers with a stride that is an even
-    // multiple of 32.
-    display->disp_info.stride = ROUNDUP(display->disp_info.width,
-                                        32 / display->disp_info.pixelsize);
+    display->format = ZX_PIXEL_FORMAT_RGB_565;
+    display->width  = 608;
+    display->height = 1024;
+    display->stride = astro_compute_linear_stride(
+            display, display->width, display->format);
 
     status = io_buffer_init(&display->fbuffer, display->bti,
-                            (display->disp_info.stride * display->disp_info.height *
-                             ZX_PIXEL_FORMAT_BYTES(display->disp_info.format)),
+                            (display->stride * display->height *
+                             ZX_PIXEL_FORMAT_BYTES(display->format)),
                             IO_BUFFER_RW | IO_BUFFER_CONTIG);
     if (status != ZX_OK) {
-        return status;
+        goto fail;
     }
 
-    config_canvas(display);
+    config_canvas(display, io_buffer_phys(&display->fbuffer), &display->fb_canvas_idx);
     init_backlight(display);
 
     zx_set_framebuffer(get_root_resource(), display->fbuffer.vmo_handle,
@@ -248,21 +280,25 @@
                        display->disp_info.width, display->disp_info.height,
                        display->disp_info.stride);
 
-    device_add_args_t vc_fbuff_args = {
-        .version = DEVICE_ADD_ARGS_VERSION,
-        .name = "astro-display",
-        .ctx = display,
-        .ops = &display_device_proto,
-        .proto_id = ZX_PROTOCOL_DISPLAY,
-        .proto_ops = &vc_display_proto,
-    };
+    display_added = display->display_id;
 
-    status = device_add(display->mydevice, &vc_fbuff_args, &display->fbdevice);
-    if (status != ZX_OK) {
-        free(display);
-        return status;
+    mtx_unlock(&display->display_lock);
+
+    if (display->dc_cb) {
+        display->dc_cb->on_displays_changed(display->dc_cb_ctx,
+                                                &display_added,
+                                                display_added != INVALID_DISPLAY_ID,
+                                                &display_removed,
+                                                display_removed != INVALID_DISPLAY_ID);
     }
+    mtx_unlock(&display->cb_lock);
+
     return ZX_OK;
+
+fail:
+    mtx_unlock(&display->display_lock);
+    mtx_unlock(&display->cb_lock);
+    return status;
 }
 
 static int main_astro_display_thread(void *arg) {
@@ -315,15 +351,26 @@
         goto fail;
     }
 
-    device_add_args_t vc_fbuff_args = {
+    device_add_args_t add_args = {
         .version = DEVICE_ADD_ARGS_VERSION,
         .name = "astro-display",
         .ctx = display,
         .ops = &main_device_proto,
-        .flags = (DEVICE_ADD_NON_BINDABLE | DEVICE_ADD_INVISIBLE),
+        .proto_id = ZX_PROTOCOL_DISPLAY_CONTROLLER_IMPL,
+        .proto_ops = &display_controller_ops,
     };
 
-    status = device_add(display->parent, &vc_fbuff_args, &display->mydevice);
+    status = device_add(display->parent, &add_args, &display->mydevice);
+    if (status != ZX_OK) {
+        DISP_ERROR("Could not add device\n");
+        goto fail;
+    }
+
+    display->display_id = 1;
+    list_initialize(&display->imported_images);
+    mtx_init(&display->display_lock, mtx_plain);
+    mtx_init(&display->image_lock, mtx_plain);
+    mtx_init(&display->cb_lock, mtx_plain);
 
     thrd_create_with_name(&display->main_thread, main_astro_display_thread, display,
                                                     "main_astro_display_thread");
diff --git a/system/dev/display/astro-display/astro-display.h b/system/dev/display/astro-display/astro-display.h
index 016047d..4c9ab72 100644
--- a/system/dev/display/astro-display/astro-display.h
+++ b/system/dev/display/astro-display/astro-display.h
@@ -13,7 +13,7 @@
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
-#include <zircon/device/display.h>
+#include <ddk/protocol/display-controller.h>
 #include <ddk/device.h>
 #include <ddk/io-buffer.h>
 #include <ddk/protocol/platform-device.h>
@@ -62,10 +62,29 @@
     gpio_protocol_t                     gpio;
     i2c_protocol_t                      i2c;
     thrd_t                              main_thread;
+    // Lock for general display state, in particular display_id.
+    mtx_t                               display_lock;
+    // Lock for imported images.
+    mtx_t                               image_lock;
+    // Lock for the display callback, for enforcing an ordering on
+    // hotplug callbacks. Should be acquired before display_lock.
+    mtx_t                               cb_lock;
+    // TODO(stevensd): This can race if this is changed right after
+    // vsync but before the interrupt is handled.
+    uint8_t                             current_image;
 
     io_buffer_t                         mmio_dmc;
     io_buffer_t                         fbuffer;
     zx_display_info_t                   disp_info;
+    uint8_t                             fb_canvas_idx;
+    zx_handle_t                         vsync_interrupt;
+
+    // The current display id (if display_attached), or the next display id
+    uint64_t                            display_id;
+    uint32_t                            width;
+    uint32_t                            height;
+    uint32_t                            stride;
+    zx_pixel_format_t                   format;
 
     uint8_t                             input_color_format;
     uint8_t                             output_color_format;
@@ -74,6 +93,11 @@
     bool                                console_visible;
     zx_display_cb_t                     ownership_change_callback;
     void*                               ownership_change_cookie;
+
+    display_controller_cb_t*            dc_cb;
+    void*                               dc_cb_ctx;
+    list_node_t                         imported_images;
+
 } astro_display_t;