*/
 int drm_panel_attach(struct drm_panel *panel, struct drm_connector *connector)
 {
-       if (panel->drm)
-               return -EBUSY;
-
-       panel->drm = connector->dev;
-
        return 0;
 }
 EXPORT_SYMBOL(drm_panel_attach);
  */
 void drm_panel_detach(struct drm_panel *panel)
 {
-       panel->drm = NULL;
 }
 EXPORT_SYMBOL(drm_panel_detach);
 
 
        connector->display_info.height_mm = vpanel->panel_type->height_mm;
        connector->display_info.bus_flags = vpanel->panel_type->bus_flags;
 
-       mode = drm_mode_duplicate(panel->drm, &vpanel->panel_type->mode);
+       mode = drm_mode_duplicate(connector->dev, &vpanel->panel_type->mode);
        drm_mode_set_name(mode);
        mode->type = DRM_MODE_TYPE_DRIVER | DRM_MODE_TYPE_PREFERRED;
 
 
        struct feiyang *ctx = panel_to_feiyang(panel);
        struct drm_display_mode *mode;
 
-       mode = drm_mode_duplicate(panel->drm, &feiyang_default_mode);
+       mode = drm_mode_duplicate(connector->dev, &feiyang_default_mode);
        if (!mode) {
                DRM_DEV_ERROR(&ctx->dsi->dev, "failed to add mode %ux%ux@%u\n",
                              feiyang_default_mode.hdisplay,
 
                             struct drm_connector *connector)
 {
        struct ili9322 *ili = panel_to_ili9322(panel);
+       struct drm_device *drm = connector->dev;
        struct drm_display_mode *mode;
        struct drm_display_info *info;
 
 
        switch (ili->input) {
        case ILI9322_INPUT_SRGB_DUMMY_320X240:
-               mode = drm_mode_duplicate(panel->drm, &srgb_320x240_mode);
+               mode = drm_mode_duplicate(drm, &srgb_320x240_mode);
                break;
        case ILI9322_INPUT_SRGB_DUMMY_360X240:
-               mode = drm_mode_duplicate(panel->drm, &srgb_360x240_mode);
+               mode = drm_mode_duplicate(drm, &srgb_360x240_mode);
                break;
        case ILI9322_INPUT_PRGB_THROUGH:
        case ILI9322_INPUT_PRGB_ALIGNED:
-               mode = drm_mode_duplicate(panel->drm, &prgb_320x240_mode);
+               mode = drm_mode_duplicate(drm, &prgb_320x240_mode);
                break;
        case ILI9322_INPUT_YUV_640X320_YCBCR:
-               mode = drm_mode_duplicate(panel->drm, &yuv_640x320_mode);
+               mode = drm_mode_duplicate(drm, &yuv_640x320_mode);
                break;
        case ILI9322_INPUT_YUV_720X360_YCBCR:
-               mode = drm_mode_duplicate(panel->drm, &yuv_720x360_mode);
+               mode = drm_mode_duplicate(drm, &yuv_720x360_mode);
                break;
        case ILI9322_INPUT_ITU_R_BT656_720X360_YCBCR:
-               mode = drm_mode_duplicate(panel->drm, &itu_r_bt_656_720_mode);
+               mode = drm_mode_duplicate(drm, &itu_r_bt_656_720_mode);
                break;
        case ILI9322_INPUT_ITU_R_BT656_640X320_YCBCR:
-               mode = drm_mode_duplicate(panel->drm, &itu_r_bt_656_640_mode);
+               mode = drm_mode_duplicate(drm, &itu_r_bt_656_640_mode);
                break;
        default:
                mode = NULL;
 
        struct ili9881c *ctx = panel_to_ili9881c(panel);
        struct drm_display_mode *mode;
 
-       mode = drm_mode_duplicate(panel->drm, &bananapi_default_mode);
+       mode = drm_mode_duplicate(connector->dev, &bananapi_default_mode);
        if (!mode) {
                dev_err(&ctx->dsi->dev, "failed to add mode %ux%ux@%u\n",
                        bananapi_default_mode.hdisplay,
 
 
        ret = backlight_enable(innolux->backlight);
        if (ret) {
-               DRM_DEV_ERROR(panel->drm->dev,
+               DRM_DEV_ERROR(panel->dev,
                              "Failed to enable backlight %d\n", ret);
                return ret;
        }
        const struct drm_display_mode *m = innolux->desc->mode;
        struct drm_display_mode *mode;
 
-       mode = drm_mode_duplicate(panel->drm, m);
+       mode = drm_mode_duplicate(connector->dev, m);
        if (!mode) {
-               DRM_DEV_ERROR(panel->drm->dev, "failed to add mode %ux%ux@%u\n",
+               DRM_DEV_ERROR(panel->dev, "failed to add mode %ux%ux@%u\n",
                              m->hdisplay, m->vdisplay, m->vrefresh);
                return -ENOMEM;
        }
 
        struct jdi_panel *jdi = to_jdi_panel(panel);
        struct device *dev = &jdi->dsi->dev;
 
-       mode = drm_mode_duplicate(panel->drm, &default_mode);
+       mode = drm_mode_duplicate(connector->dev, &default_mode);
        if (!mode) {
                dev_err(dev, "failed to add mode %ux%ux@%u\n",
                        default_mode.hdisplay, default_mode.vdisplay,
 
 
        ret = backlight_enable(kingdisplay->backlight);
        if (ret) {
-               DRM_DEV_ERROR(panel->drm->dev,
+               DRM_DEV_ERROR(panel->dev,
                              "Failed to enable backlight %d\n", ret);
                return ret;
        }
 {
        struct drm_display_mode *mode;
 
-       mode = drm_mode_duplicate(panel->drm, &default_mode);
+       mode = drm_mode_duplicate(connector->dev, &default_mode);
        if (!mode) {
-               DRM_DEV_ERROR(panel->drm->dev, "failed to add mode %ux%ux@%u\n",
+               DRM_DEV_ERROR(panel->dev, "failed to add mode %ux%ux@%u\n",
                              default_mode.hdisplay, default_mode.vdisplay,
                              default_mode.vrefresh);
                return -ENOMEM;
 
 {
        struct drm_display_mode *mode;
 
-       mode = drm_mode_duplicate(panel->drm, &lb035q02_mode);
+       mode = drm_mode_duplicate(connector->dev, &lb035q02_mode);
        if (!mode)
                return -ENOMEM;
 
 
 {
        struct drm_display_mode *mode;
 
-       mode = drm_mode_duplicate(panel->drm, &default_mode);
+       mode = drm_mode_duplicate(connector->dev, &default_mode);
        if (!mode) {
-               dev_err(panel->drm->dev, "failed to add mode %ux%ux@%u\n",
+               dev_err(panel->dev, "failed to add mode %ux%ux@%u\n",
                        default_mode.hdisplay, default_mode.vdisplay,
                        default_mode.vrefresh);
                return -ENOMEM;
 
        struct panel_lvds *lvds = to_panel_lvds(panel);
        struct drm_display_mode *mode;
 
-       mode = drm_mode_create(lvds->panel.drm);
+       mode = drm_mode_create(connector->dev);
        if (!mode)
                return 0;
 
 
 {
        struct drm_display_mode *mode;
 
-       mode = drm_mode_duplicate(panel->drm, &nl8048_mode);
+       mode = drm_mode_duplicate(connector->dev, &nl8048_mode);
        if (!mode)
                return -ENOMEM;
 
 
        const struct nt39016_panel_info *panel_info = panel->panel_info;
        struct drm_display_mode *mode;
 
-       mode = drm_mode_duplicate(drm_panel->drm, &panel_info->display_mode);
+       mode = drm_mode_duplicate(connector->dev, &panel_info->display_mode);
        if (!mode)
                return -ENOMEM;
 
 
 {
        struct lcd_olinuxino *lcd = to_lcd_olinuxino(panel);
        struct lcd_olinuxino_info *lcd_info = &lcd->eeprom.info;
-       struct drm_device *drm = lcd->panel.drm;
        struct lcd_olinuxino_mode *lcd_mode;
        struct drm_display_mode *mode;
        u32 i, num = 0;
                lcd_mode = (struct lcd_olinuxino_mode *)
                           &lcd->eeprom.reserved[i * sizeof(*lcd_mode)];
 
-               mode = drm_mode_create(drm);
+               mode = drm_mode_create(connector->dev);
                if (!mode) {
-                       dev_err(drm->dev, "failed to add mode %ux%u@%u\n",
+                       dev_err(panel->dev, "failed to add mode %ux%u@%u\n",
                                lcd_mode->hactive,
                                lcd_mode->vactive,
                                lcd_mode->refresh);
 
 {
        struct drm_display_mode *mode;
 
-       mode = drm_mode_duplicate(panel->drm, &default_mode);
+       mode = drm_mode_duplicate(connector->dev, &default_mode);
        if (!mode) {
                DRM_ERROR("failed to add mode %ux%ux@%u\n",
                          default_mode.hdisplay, default_mode.vdisplay,
 
        struct osd101t2587_panel *osd101t2587 = ti_osd_panel(panel);
        struct drm_display_mode *mode;
 
-       mode = drm_mode_duplicate(panel->drm, osd101t2587->default_mode);
+       mode = drm_mode_duplicate(connector->dev, osd101t2587->default_mode);
        if (!mode) {
-               dev_err(panel->drm->dev, "failed to add mode %ux%ux@%u\n",
+               dev_err(panel->dev, "failed to add mode %ux%ux@%u\n",
                        osd101t2587->default_mode->hdisplay,
                        osd101t2587->default_mode->vdisplay,
                        osd101t2587->default_mode->vrefresh);
 
 {
        struct drm_display_mode *mode;
 
-       mode = drm_mode_duplicate(panel->drm, &default_mode);
+       mode = drm_mode_duplicate(connector->dev, &default_mode);
        if (!mode) {
-               dev_err(panel->drm->dev, "failed to add mode %ux%ux@%u\n",
-                               default_mode.hdisplay, default_mode.vdisplay,
-                               default_mode.vrefresh);
+               dev_err(panel->dev, "failed to add mode %ux%u@%u\n",
+                       default_mode.hdisplay, default_mode.vdisplay,
+                       default_mode.vrefresh);
                return -ENOMEM;
        }
 
 
 static int rpi_touchscreen_get_modes(struct drm_panel *panel,
                                     struct drm_connector *connector)
 {
-       struct drm_device *drm = panel->drm;
        unsigned int i, num = 0;
        static const u32 bus_format = MEDIA_BUS_FMT_RGB888_1X24;
 
                const struct drm_display_mode *m = &rpi_touchscreen_modes[i];
                struct drm_display_mode *mode;
 
-               mode = drm_mode_duplicate(drm, m);
+               mode = drm_mode_duplicate(connector->dev, m);
                if (!mode) {
-                       dev_err(drm->dev, "failed to add mode %ux%u@%u\n",
+                       dev_err(panel->dev, "failed to add mode %ux%u@%u\n",
                                m->hdisplay, m->vdisplay, m->vrefresh);
                        continue;
                }
 
 {
        struct drm_display_mode *mode;
 
-       mode = drm_mode_duplicate(panel->drm, &default_mode);
+       mode = drm_mode_duplicate(connector->dev, &default_mode);
        if (!mode) {
                DRM_DEV_ERROR(panel->dev, "failed to add mode %ux%ux@%u\n",
                              default_mode.hdisplay, default_mode.vdisplay,
 
 {
        struct drm_display_mode *mode;
 
-       mode = drm_mode_duplicate(panel->drm, &default_mode);
+       mode = drm_mode_duplicate(connector->dev, &default_mode);
        if (!mode) {
                DRM_ERROR("failed to add mode %ux%ux@%u\n",
                          default_mode.hdisplay, default_mode.vdisplay,
 
        struct jh057n *ctx = panel_to_jh057n(panel);
        struct drm_display_mode *mode;
 
-       mode = drm_mode_duplicate(panel->drm, &default_mode);
+       mode = drm_mode_duplicate(connector->dev, &default_mode);
        if (!mode) {
                DRM_DEV_ERROR(ctx->dev, "Failed to add mode %ux%u@%u\n",
                              default_mode.hdisplay, default_mode.vdisplay,
 
        struct drm_display_mode *mode;
        static const u32 bus_format = MEDIA_BUS_FMT_RGB888_1X24;
 
-       mode = drm_mode_duplicate(panel->drm, &default_mode);
+       mode = drm_mode_duplicate(connector->dev, &default_mode);
        if (!mode) {
                DRM_DEV_ERROR(&ctx->dsi->dev,
                              "Failed to add mode " DRM_MODE_FMT "\n",
 
 {
        struct drm_display_mode *mode;
 
-       mode = drm_mode_duplicate(panel->drm, &samsung_s6d16d0_mode);
+       mode = drm_mode_duplicate(connector->dev, &samsung_s6d16d0_mode);
        if (!mode) {
                DRM_ERROR("bad mode or failed to add mode\n");
                return -EINVAL;
 
        struct s6e3ha2 *ctx = container_of(panel, struct s6e3ha2, panel);
        struct drm_display_mode *mode;
 
-       mode = drm_mode_duplicate(panel->drm, ctx->desc->mode);
+       mode = drm_mode_duplicate(connector->dev, ctx->desc->mode);
        if (!mode) {
                DRM_ERROR("failed to add mode %ux%ux@%u\n",
                        ctx->desc->mode->hdisplay, ctx->desc->mode->vdisplay,
 
 {
        struct drm_display_mode *mode;
 
-       mode = drm_mode_duplicate(panel->drm, &default_mode);
+       mode = drm_mode_duplicate(connector->dev, &default_mode);
        if (!mode) {
                DRM_ERROR("failed to add mode %ux%ux@%u\n",
                        default_mode.hdisplay, default_mode.vdisplay,
 
 {
        struct drm_display_mode *mode;
 
-       mode = drm_mode_duplicate(panel->drm, &default_mode);
+       mode = drm_mode_duplicate(connector->dev, &default_mode);
        if (!mode) {
                DRM_ERROR("failed to add mode %ux%ux@%u\n",
                          default_mode.hdisplay, default_mode.vdisplay,
 
 static int seiko_panel_get_fixed_modes(struct seiko_panel *panel,
                                       struct drm_connector *connector)
 {
-       struct drm_device *drm = panel->base.drm;
        struct drm_display_mode *mode;
        unsigned int i, num = 0;
 
                struct videomode vm;
 
                videomode_from_timing(dt, &vm);
-               mode = drm_mode_create(drm);
+               mode = drm_mode_create(connector->dev);
                if (!mode) {
-                       dev_err(drm->dev, "failed to add mode %ux%u\n",
+                       dev_err(panel->base.dev, "failed to add mode %ux%u\n",
                                dt->hactive.typ, dt->vactive.typ);
                        continue;
                }
        for (i = 0; i < panel->desc->num_modes; i++) {
                const struct drm_display_mode *m = &panel->desc->modes[i];
 
-               mode = drm_mode_duplicate(drm, m);
+               mode = drm_mode_duplicate(connector->dev, m);
                if (!mode) {
-                       dev_err(drm->dev, "failed to add mode %ux%u@%u\n",
+                       dev_err(panel->base.dev, "failed to add mode %ux%u@%u\n",
                                m->hdisplay, m->vdisplay, m->vrefresh);
                        continue;
                }
 
 {
        struct drm_display_mode *mode;
 
-       mode = drm_mode_duplicate(panel->drm, &default_mode);
+       mode = drm_mode_duplicate(connector->dev, &default_mode);
        if (!mode) {
-               dev_err(panel->drm->dev, "failed to add mode %ux%ux@%u\n",
+               dev_err(panel->dev, "failed to add mode %ux%ux@%u\n",
                        default_mode.hdisplay, default_mode.vdisplay,
                        default_mode.vrefresh);
                return -ENOMEM;
 
 {
        struct drm_display_mode *mode;
 
-       mode = drm_mode_duplicate(panel->drm, &ls037v7dw01_mode);
+       mode = drm_mode_duplicate(connector->dev, &ls037v7dw01_mode);
        if (!mode)
                return -ENOMEM;
 
 
 {
        struct drm_display_mode *mode;
 
-       mode = drm_mode_duplicate(panel->drm, &default_mode);
+       mode = drm_mode_duplicate(connector->dev, &default_mode);
        if (!mode) {
-               dev_err(panel->drm->dev, "failed to add mode %ux%ux@%u\n",
-                               default_mode.hdisplay, default_mode.vdisplay,
-                               default_mode.vrefresh);
+               dev_err(panel->dev, "failed to add mode %ux%u@%u\n",
+                       default_mode.hdisplay, default_mode.vdisplay,
+                       default_mode.vrefresh);
                return -ENOMEM;
        }
 
 
 static unsigned int panel_simple_get_timings_modes(struct panel_simple *panel,
                                                   struct drm_connector *connector)
 {
-       struct drm_device *drm = panel->base.drm;
        struct drm_display_mode *mode;
        unsigned int i, num = 0;
 
                struct videomode vm;
 
                videomode_from_timing(dt, &vm);
-               mode = drm_mode_create(drm);
+               mode = drm_mode_create(connector->dev);
                if (!mode) {
-                       dev_err(drm->dev, "failed to add mode %ux%u\n",
+                       dev_err(panel->base.dev, "failed to add mode %ux%u\n",
                                dt->hactive.typ, dt->vactive.typ);
                        continue;
                }
 static unsigned int panel_simple_get_display_modes(struct panel_simple *panel,
                                                   struct drm_connector *connector)
 {
-       struct drm_device *drm = panel->base.drm;
        struct drm_display_mode *mode;
        unsigned int i, num = 0;
 
        for (i = 0; i < panel->desc->num_modes; i++) {
                const struct drm_display_mode *m = &panel->desc->modes[i];
 
-               mode = drm_mode_duplicate(drm, m);
+               mode = drm_mode_duplicate(connector->dev, m);
                if (!mode) {
-                       dev_err(drm->dev, "failed to add mode %ux%u@%u\n",
+                       dev_err(panel->base.dev, "failed to add mode %ux%u@%u\n",
                                m->hdisplay, m->vdisplay, m->vrefresh);
                        continue;
                }
 static int panel_simple_get_non_edid_modes(struct panel_simple *panel,
                                           struct drm_connector *connector)
 {
-       struct drm_device *drm = panel->base.drm;
        struct drm_display_mode *mode;
        bool has_override = panel->override_mode.type;
        unsigned int num = 0;
                return 0;
 
        if (has_override) {
-               mode = drm_mode_duplicate(drm, &panel->override_mode);
+               mode = drm_mode_duplicate(connector->dev,
+                                         &panel->override_mode);
                if (mode) {
                        drm_mode_probed_add(connector, mode);
                        num = 1;
                } else {
-                       dev_err(drm->dev, "failed to add override mode\n");
+                       dev_err(panel->base.dev, "failed to add override mode\n");
                }
        }
 
 
        const struct drm_display_mode *desc_mode = st7701->desc->mode;
        struct drm_display_mode *mode;
 
-       mode = drm_mode_duplicate(panel->drm, desc_mode);
+       mode = drm_mode_duplicate(connector->dev, desc_mode);
        if (!mode) {
                DRM_DEV_ERROR(&st7701->dsi->dev,
                              "failed to add mode %ux%ux@%u\n",
 
 {
        struct drm_display_mode *mode;
 
-       mode = drm_mode_duplicate(panel->drm, &default_mode);
+       mode = drm_mode_duplicate(connector->dev, &default_mode);
        if (!mode) {
-               dev_err(panel->drm->dev, "failed to add mode %ux%ux@%u\n",
+               dev_err(panel->dev, "failed to add mode %ux%ux@%u\n",
                        default_mode.hdisplay, default_mode.vdisplay,
                        default_mode.vrefresh);
                return -ENOMEM;
 
 {
        struct drm_display_mode *mode;
 
-       mode = drm_mode_duplicate(panel->drm, &acx565akm_mode);
+       mode = drm_mode_duplicate(connector->dev, &acx565akm_mode);
        if (!mode)
                return -ENOMEM;
 
 
 {
        struct drm_display_mode *mode;
 
-       mode = drm_mode_duplicate(panel->drm, &td028ttec1_mode);
+       mode = drm_mode_duplicate(connector->dev, &td028ttec1_mode);
        if (!mode)
                return -ENOMEM;
 
 
 {
        struct drm_display_mode *mode;
 
-       mode = drm_mode_duplicate(panel->drm, &td043mtea1_mode);
+       mode = drm_mode_duplicate(connector->dev, &td043mtea1_mode);
        if (!mode)
                return -ENOMEM;
 
 
        connector->display_info.height_mm = tpg->height;
        connector->display_info.bus_flags = tpg->panel_mode->bus_flags;
 
-       mode = drm_mode_duplicate(panel->drm, &tpg->panel_mode->mode);
+       mode = drm_mode_duplicate(connector->dev, &tpg->panel_mode->mode);
        drm_mode_set_name(mode);
        mode->type = DRM_MODE_TYPE_DRIVER | DRM_MODE_TYPE_PREFERRED;
 
 
  * struct drm_panel - DRM panel object
  */
 struct drm_panel {
-       /**
-        * @drm:
-        *
-        * DRM device owning the panel.
-        */
-       struct drm_device *drm;
-
        /**
         * @dev:
         *