scu_rev)) {
                /* We do, disable P2A access */
                ast->config_mode = ast_use_dt;
-               DRM_INFO("Using device-tree for configuration\n");
+               drm_info(dev, "Using device-tree for configuration\n");
                return;
        }
 
                        /* P2A works, grab silicon revision */
                        ast->config_mode = ast_use_p2a;
 
-                       DRM_INFO("Using P2A bridge for configuration\n");
+                       drm_info(dev, "Using P2A bridge for configuration\n");
 
                        /* Read SCU7c (silicon revision register) */
                        ast_write32(ast, 0xf004, 0x1e6e0000);
        }
 
        /* We have a P2A bridge but it's disabled */
-       DRM_INFO("P2A bridge disabled, using default configuration\n");
+       drm_info(dev, "P2A bridge disabled, using default configuration\n");
 }
 
 static int ast_detect_chip(struct drm_device *dev, bool *need_post)
         */
        if (!ast_is_vga_enabled(dev)) {
                ast_enable_vga(dev);
-               DRM_INFO("VGA not enabled on entry, requesting chip POST\n");
+               drm_info(dev, "VGA not enabled on entry, requesting chip POST\n");
                *need_post = true;
        } else
                *need_post = false;
        /* Identify chipset */
        if (dev->pdev->revision >= 0x40) {
                ast->chip = AST2500;
-               DRM_INFO("AST 2500 detected\n");
+               drm_info(dev, "AST 2500 detected\n");
        } else if (dev->pdev->revision >= 0x30) {
                ast->chip = AST2400;
-               DRM_INFO("AST 2400 detected\n");
+               drm_info(dev, "AST 2400 detected\n");
        } else if (dev->pdev->revision >= 0x20) {
                ast->chip = AST2300;
-               DRM_INFO("AST 2300 detected\n");
+               drm_info(dev, "AST 2300 detected\n");
        } else if (dev->pdev->revision >= 0x10) {
                switch (scu_rev & 0x0300) {
                case 0x0200:
                        ast->chip = AST1100;
-                       DRM_INFO("AST 1100 detected\n");
+                       drm_info(dev, "AST 1100 detected\n");
                        break;
                case 0x0100:
                        ast->chip = AST2200;
-                       DRM_INFO("AST 2200 detected\n");
+                       drm_info(dev, "AST 2200 detected\n");
                        break;
                case 0x0000:
                        ast->chip = AST2150;
-                       DRM_INFO("AST 2150 detected\n");
+                       drm_info(dev, "AST 2150 detected\n");
                        break;
                default:
                        ast->chip = AST2100;
-                       DRM_INFO("AST 2100 detected\n");
+                       drm_info(dev, "AST 2100 detected\n");
                        break;
                }
                ast->vga2_clone = false;
        } else {
                ast->chip = AST2000;
-               DRM_INFO("AST 2000 detected\n");
+               drm_info(dev, "AST 2000 detected\n");
        }
 
        /* Check if we support wide screen */
        /* Print stuff for diagnostic purposes */
        switch(ast->tx_chip_type) {
        case AST_TX_SIL164:
-               DRM_INFO("Using Sil164 TMDS transmitter\n");
+               drm_info(dev, "Using Sil164 TMDS transmitter\n");
                break;
        case AST_TX_DP501:
-               DRM_INFO("Using DP501 DisplayPort transmitter\n");
+               drm_info(dev, "Using DP501 DisplayPort transmitter\n");
                break;
        default:
-               DRM_INFO("Analog VGA only\n");
+               drm_info(dev, "Analog VGA only\n");
        }
        return 0;
 }
         * and higher).
         */
        if (!(pci_resource_flags(dev->pdev, 2) & IORESOURCE_IO)) {
-               DRM_INFO("platform has no IO space, trying MMIO\n");
+               drm_info(dev, "platform has no IO space, trying MMIO\n");
                ast->ioregs = ast->regs + AST_IO_MM_OFFSET;
        }
 
        if (ret)
                goto out_free;
        ast->vram_size = ast_get_vram_info(dev);
-       DRM_INFO("dram MCLK=%u Mhz type=%d bus_width=%d size=%08x\n",
+       drm_info(dev, "dram MCLK=%u Mhz type=%d bus_width=%d size=%08x\n",
                 ast->mclk, ast->dram_type,
                 ast->dram_bus_width, ast->vram_size);
 
 
 ast_primary_plane_helper_atomic_update(struct drm_plane *plane,
                                       struct drm_plane_state *old_state)
 {
-       struct ast_private *ast = to_ast_private(plane->dev);
+       struct drm_device *dev = plane->dev;
+       struct ast_private *ast = to_ast_private(dev);
        struct drm_plane_state *state = plane->state;
        struct drm_gem_vram_object *gbo;
        s64 gpu_addr;
 
        gbo = drm_gem_vram_of_gem(state->fb->obj[0]);
        gpu_addr = drm_gem_vram_offset(gbo);
-       if (WARN_ON_ONCE(gpu_addr < 0))
+       if (drm_WARN_ON_ONCE(dev, gpu_addr < 0))
                return; /* Bug: we didn't pin the BO to VRAM in prepare_fb. */
 
        ast_set_offset_reg(ast, state->fb);
 ast_cursor_plane_helper_prepare_fb(struct drm_plane *plane,
                                   struct drm_plane_state *new_state)
 {
+       struct drm_device *dev = plane->dev;
        struct drm_framebuffer *fb = new_state->fb;
        struct drm_crtc *crtc = new_state->crtc;
        struct drm_gem_vram_object *gbo;
        if (!crtc || !fb)
                return 0;
 
-       if (WARN_ON_ONCE(fb->width > AST_MAX_HWC_WIDTH) ||
-           WARN_ON_ONCE(fb->height > AST_MAX_HWC_HEIGHT))
+       if (drm_WARN_ON_ONCE(dev, fb->width > AST_MAX_HWC_WIDTH) ||
+           drm_WARN_ON_ONCE(dev, fb->height > AST_MAX_HWC_HEIGHT))
                return -EINVAL; /* BUG: didn't test in atomic_check() */
 
-       ast = to_ast_private(crtc->dev);
+       ast = to_ast_private(dev);
 
        gbo = drm_gem_vram_of_gem(fb->obj[0]);
        src = drm_gem_vram_vmap(gbo);
 ast_cursor_plane_helper_atomic_update(struct drm_plane *plane,
                                      struct drm_plane_state *old_state)
 {
+       struct drm_device *dev = plane->dev;
        struct drm_plane_state *state = plane->state;
        struct drm_crtc *crtc = state->crtc;
        struct drm_framebuffer *fb = state->fb;
                /* A new cursor image was installed. */
                gbo = ast->cursor.gbo[ast->cursor.next_index];
                off = drm_gem_vram_offset(gbo);
-               if (WARN_ON_ONCE(off < 0))
+               if (drm_WARN_ON_ONCE(dev, off < 0))
                        return; /* Bug: we didn't pin cursor HW BO to VRAM. */
                ast_cursor_set_base(ast, off);
 
 ast_crtc_atomic_duplicate_state(struct drm_crtc *crtc)
 {
        struct ast_crtc_state *new_ast_state, *ast_state;
+       struct drm_device *dev = crtc->dev;
 
-       if (WARN_ON(!crtc->state))
+       if (drm_WARN_ON(dev, !crtc->state))
                return NULL;
 
        new_ast_state = kmalloc(sizeof(*new_ast_state), GFP_KERNEL);
        connector = &ast_connector->base;
        ast_connector->i2c = ast_i2c_create(dev);
        if (!ast_connector->i2c)
-               DRM_ERROR("failed to add ddc bus for connector\n");
+               drm_err(dev, "failed to add ddc bus for connector\n");
 
        drm_connector_init_with_ddc(dev, connector,
                                    &ast_connector_funcs,
                                       ARRAY_SIZE(ast_primary_plane_formats),
                                       NULL, DRM_PLANE_TYPE_PRIMARY, NULL);
        if (ret) {
-               DRM_ERROR("ast: drm_universal_plane_init() failed: %d\n", ret);
+               drm_err(dev, "ast: drm_universal_plane_init() failed: %d\n", ret);
                return ret;
        }
        drm_plane_helper_add(&ast->primary_plane,
                                       ARRAY_SIZE(ast_cursor_plane_formats),
                                       NULL, DRM_PLANE_TYPE_CURSOR, NULL);
        if (ret) {
-               DRM_ERROR("drm_universal_plane_failed(): %d\n", ret);
+               drm_err(dev, "drm_universal_plane_failed(): %d\n", ret);
                return ret;
        }
        drm_plane_helper_add(&ast->cursor_plane,
        i2c->bit.getscl = get_clock;
        ret = i2c_bit_add_bus(&i2c->adapter);
        if (ret) {
-               DRM_ERROR("Failed to register bit i2c\n");
+               drm_err(dev, "Failed to register bit i2c\n");
                goto out_free;
        }