}
 
 int mgag200_device_init(struct mga_device *mdev, enum mga_type type,
-                       const struct mgag200_device_info *info)
+                       const struct mgag200_device_info *info,
+                       const struct mgag200_device_funcs *funcs)
 {
        struct drm_device *dev = &mdev->base;
        u8 crtcext3, misc;
        int ret;
 
        mdev->info = info;
+       mdev->funcs = funcs;
        mdev->type = type;
 
        ret = drmm_mutex_init(dev, &mdev->rmmio_lock);
 
                .bug_no_startadd = (_bug_no_startadd), \
        }
 
+struct mgag200_device_funcs {
+};
+
 struct mga_device {
        struct drm_device base;
 
        const struct mgag200_device_info *info;
+       const struct mgag200_device_funcs *funcs;
 
        struct resource                 *rmmio_res;
        void __iomem                    *rmmio;
 resource_size_t mgag200_device_probe_vram(struct mga_device *mdev);
 int mgag200_device_preinit(struct mga_device *mdev);
 int mgag200_device_init(struct mga_device *mdev, enum mga_type type,
-                       const struct mgag200_device_info *info);
+                       const struct mgag200_device_info *info,
+                       const struct mgag200_device_funcs *funcs);
 
                                /* mgag200_<device type>.c */
 struct mga_device *mgag200_g200_device_create(struct pci_dev *pdev, const struct drm_driver *drv,
 
        pci_unmap_rom(pdev, rom);
 }
 
+static const struct mgag200_device_funcs mgag200_g200_device_funcs = {
+};
+
 struct mga_device *mgag200_g200_device_create(struct pci_dev *pdev, const struct drm_driver *drv,
                                              enum mga_type type)
 {
 
        mgag200_g200_init_refclk(g200);
 
-       ret = mgag200_device_init(mdev, type, &mgag200_g200_device_info);
+       ret = mgag200_device_init(mdev, type, &mgag200_g200_device_info,
+                                 &mgag200_g200_device_funcs);
        if (ret)
                return ERR_PTR(ret);
 
 
 static const struct mgag200_device_info mgag200_g200eh_device_info =
        MGAG200_DEVICE_INFO_INIT(2048, 2048, 37500, false, 1, 0, false);
 
+static const struct mgag200_device_funcs mgag200_g200eh_device_funcs = {
+};
+
 struct mga_device *mgag200_g200eh_device_create(struct pci_dev *pdev, const struct drm_driver *drv,
                                                enum mga_type type)
 {
        if (ret)
                return ERR_PTR(ret);
 
-       ret = mgag200_device_init(mdev, type, &mgag200_g200eh_device_info);
+       ret = mgag200_device_init(mdev, type, &mgag200_g200eh_device_info,
+                                 &mgag200_g200eh_device_funcs);
        if (ret)
                return ERR_PTR(ret);
 
 
 static const struct mgag200_device_info mgag200_g200eh3_device_info =
        MGAG200_DEVICE_INFO_INIT(2048, 2048, 0, false, 1, 0, false);
 
+static const struct mgag200_device_funcs mgag200_g200eh3_device_funcs = {
+};
+
 struct mga_device *mgag200_g200eh3_device_create(struct pci_dev *pdev,
                                                 const struct drm_driver *drv,
                                                 enum mga_type type)
        if (ret)
                return ERR_PTR(ret);
 
-       ret = mgag200_device_init(mdev, type, &mgag200_g200eh3_device_info);
+       ret = mgag200_device_init(mdev, type, &mgag200_g200eh3_device_info,
+                                 &mgag200_g200eh3_device_funcs);
        if (ret)
                return ERR_PTR(ret);
 
 
 static const struct mgag200_device_info mgag200_g200er_device_info =
        MGAG200_DEVICE_INFO_INIT(2048, 2048, 55000, false, 1, 0, false);
 
+static const struct mgag200_device_funcs mgag200_g200er_device_funcs = {
+};
+
 struct mga_device *mgag200_g200er_device_create(struct pci_dev *pdev, const struct drm_driver *drv,
                                                enum mga_type type)
 {
        if (ret)
                return ERR_PTR(ret);
 
-       ret = mgag200_device_init(mdev, type, &mgag200_g200er_device_info);
+       ret = mgag200_device_init(mdev, type, &mgag200_g200er_device_info,
+                                 &mgag200_g200er_device_funcs);
        if (ret)
                return ERR_PTR(ret);
 
 
 static const struct mgag200_device_info mgag200_g200ev_device_info =
        MGAG200_DEVICE_INFO_INIT(2048, 2048, 32700, false, 0, 1, false);
 
+static const struct mgag200_device_funcs mgag200_g200ev_device_funcs = {
+};
+
 struct mga_device *mgag200_g200ev_device_create(struct pci_dev *pdev, const struct drm_driver *drv,
                                                enum mga_type type)
 {
        if (ret)
                return ERR_PTR(ret);
 
-       ret = mgag200_device_init(mdev, type, &mgag200_g200ev_device_info);
+       ret = mgag200_device_init(mdev, type, &mgag200_g200ev_device_info,
+                                 &mgag200_g200ev_device_funcs);
        if (ret)
                return ERR_PTR(ret);
 
 
 static const struct mgag200_device_info mgag200_g200ew3_device_info =
        MGAG200_DEVICE_INFO_INIT(2048, 2048, 0, true, 0, 1, false);
 
+static const struct mgag200_device_funcs mgag200_g200ew3_device_funcs = {
+};
+
 static resource_size_t mgag200_g200ew3_device_probe_vram(struct mga_device *mdev)
 {
        resource_size_t vram_size = resource_size(mdev->vram_res);
        if (ret)
                return ERR_PTR(ret);
 
-       ret = mgag200_device_init(mdev, type, &mgag200_g200ew3_device_info);
+       ret = mgag200_device_init(mdev, type, &mgag200_g200ew3_device_info,
+                                 &mgag200_g200ew3_device_funcs);
        if (ret)
                return ERR_PTR(ret);
 
 
        return 0;
 }
 
+static const struct mgag200_device_funcs mgag200_g200se_device_funcs = {
+};
+
 struct mga_device *mgag200_g200se_device_create(struct pci_dev *pdev, const struct drm_driver *drv,
                                                enum mga_type type)
 {
                return ERR_PTR(-EINVAL);
        }
 
-       ret = mgag200_device_init(mdev, type, info);
+       ret = mgag200_device_init(mdev, type, info, &mgag200_g200se_device_funcs);
        if (ret)
                return ERR_PTR(ret);
 
 
 static const struct mgag200_device_info mgag200_g200wb_device_info =
        MGAG200_DEVICE_INFO_INIT(1280, 1024, 31877, true, 0, 1, false);
 
+static const struct mgag200_device_funcs mgag200_g200wb_device_funcs = {
+};
+
 struct mga_device *mgag200_g200wb_device_create(struct pci_dev *pdev, const struct drm_driver *drv,
                                                enum mga_type type)
 {
        if (ret)
                return ERR_PTR(ret);
 
-       ret = mgag200_device_init(mdev, type, &mgag200_g200wb_device_info);
+       ret = mgag200_device_init(mdev, type, &mgag200_g200wb_device_info,
+                                 &mgag200_g200wb_device_funcs);
        if (ret)
                return ERR_PTR(ret);