tjh.dev / kernel
Linux kernel mirror (for testing) git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel os linux
fork atom

drm/mgag200: Consolidate VGA output

The various models have common code for the VGA output's encoder and
connector. Move everything into a single shared source file. Remove some
obsolete initializer macros. No functional changes.

Signed-off-by: Thomas Zimmermann <tzimmermann@suse.de>
Reviewed-by: Jocelyn Falempe <jfalempe@redhat.com>
Link: https://patchwork.freedesktop.org/patch/msgid/20240610141141.29527-2-tzimmermann@suse.de

Thomas Zimmermann 579d4783 a13aaf15

+95 -368
+2 -1
drivers/gpu/drm/mgag200/Makefile
··· 11 11 mgag200_g200ew3.o \ 12 12 mgag200_g200se.o \ 13 13 mgag200_g200wb.o \ 14 - mgag200_mode.o 14 + mgag200_mode.o \ 15 + mgag200_vga.o 15 16 16 17 obj-$(CONFIG_DRM_MGAG200) += mgag200.o
+9 -15
drivers/gpu/drm/mgag200/mgag200_drv.h
··· 283 283 284 284 struct drm_plane primary_plane; 285 285 struct drm_crtc crtc; 286 - struct drm_encoder encoder; 287 - struct drm_connector connector; 286 + struct { 287 + struct { 288 + struct drm_encoder encoder; 289 + struct drm_connector connector; 290 + } vga; 291 + } output; 288 292 }; 289 293 290 294 static inline struct mga_device *to_mga_device(struct drm_device *dev) ··· 421 417 .atomic_duplicate_state = mgag200_crtc_atomic_duplicate_state, \ 422 418 .atomic_destroy_state = mgag200_crtc_atomic_destroy_state 423 419 424 - #define MGAG200_DAC_ENCODER_FUNCS \ 425 - .destroy = drm_encoder_cleanup 426 - 427 - #define MGAG200_VGA_CONNECTOR_HELPER_FUNCS \ 428 - .get_modes = drm_connector_helper_get_modes 429 - 430 - #define MGAG200_VGA_CONNECTOR_FUNCS \ 431 - .reset = drm_atomic_helper_connector_reset, \ 432 - .fill_modes = drm_helper_probe_single_connector_modes, \ 433 - .destroy = drm_connector_cleanup, \ 434 - .atomic_duplicate_state = drm_atomic_helper_connector_duplicate_state, \ 435 - .atomic_destroy_state = drm_atomic_helper_connector_destroy_state 436 - 437 420 void mgag200_set_mode_regs(struct mga_device *mdev, const struct drm_display_mode *mode); 438 421 void mgag200_set_format_regs(struct mga_device *mdev, const struct drm_format_info *format); 439 422 void mgag200_enable_display(struct mga_device *mdev); 440 423 void mgag200_init_registers(struct mga_device *mdev); 441 424 int mgag200_mode_config_init(struct mga_device *mdev, resource_size_t vram_available); 425 + 426 + /* mgag200_vga.c */ 427 + int mgag200_vga_output_init(struct mga_device *mdev); 442 428 443 429 /* mgag200_bmc.c */ 444 430 void mgag200_bmc_disable_vidrst(struct mga_device *mdev);
+2 -44
drivers/gpu/drm/mgag200/mgag200_g200.c
··· 9 9 #include <drm/drm_gem_atomic_helper.h> 10 10 #include <drm/drm_probe_helper.h> 11 11 12 - #include "mgag200_ddc.h" 13 12 #include "mgag200_drv.h" 14 13 15 14 static int mgag200_g200_init_pci_options(struct pci_dev *pdev) ··· 183 184 MGAG200_CRTC_FUNCS, 184 185 }; 185 186 186 - static const struct drm_encoder_funcs mgag200_g200_dac_encoder_funcs = { 187 - MGAG200_DAC_ENCODER_FUNCS, 188 - }; 189 - 190 - static const struct drm_connector_helper_funcs mgag200_g200_vga_connector_helper_funcs = { 191 - MGAG200_VGA_CONNECTOR_HELPER_FUNCS, 192 - }; 193 - 194 - static const struct drm_connector_funcs mgag200_g200_vga_connector_funcs = { 195 - MGAG200_VGA_CONNECTOR_FUNCS, 196 - }; 197 - 198 187 static int mgag200_g200_pipeline_init(struct mga_device *mdev) 199 188 { 200 189 struct drm_device *dev = &mdev->base; 201 190 struct drm_plane *primary_plane = &mdev->primary_plane; 202 191 struct drm_crtc *crtc = &mdev->crtc; 203 - struct drm_encoder *encoder = &mdev->encoder; 204 - struct drm_connector *connector = &mdev->connector; 205 - struct i2c_adapter *ddc; 206 192 int ret; 207 193 208 194 ret = drm_universal_plane_init(dev, primary_plane, 0, ··· 215 231 drm_mode_crtc_set_gamma_size(crtc, MGAG200_LUT_SIZE); 216 232 drm_crtc_enable_color_mgmt(crtc, 0, false, MGAG200_LUT_SIZE); 217 233 218 - encoder->possible_crtcs = drm_crtc_mask(crtc); 219 - ret = drm_encoder_init(dev, encoder, &mgag200_g200_dac_encoder_funcs, 220 - DRM_MODE_ENCODER_DAC, NULL); 221 - if (ret) { 222 - drm_err(dev, "drm_encoder_init() failed: %d\n", ret); 234 + ret = mgag200_vga_output_init(mdev); 235 + if (ret) 223 236 return ret; 224 - } 225 - 226 - ddc = mgag200_ddc_create(mdev); 227 - if (IS_ERR(ddc)) { 228 - ret = PTR_ERR(ddc); 229 - drm_err(dev, "failed to add DDC bus: %d\n", ret); 230 - return ret; 231 - } 232 - 233 - ret = drm_connector_init_with_ddc(dev, connector, 234 - &mgag200_g200_vga_connector_funcs, 235 - DRM_MODE_CONNECTOR_VGA, ddc); 236 - if (ret) { 237 - drm_err(dev, "drm_connector_init_with_ddc() failed: %d\n", ret); 238 - return ret; 239 - } 240 - drm_connector_helper_add(connector, &mgag200_g200_vga_connector_helper_funcs); 241 - 242 - ret = drm_connector_attach_encoder(connector, encoder); 243 - if (ret) { 244 - drm_err(dev, "drm_connector_attach_encoder() failed: %d\n", ret); 245 - return ret; 246 - } 247 237 248 238 return 0; 249 239 }
+2 -44
drivers/gpu/drm/mgag200/mgag200_g200eh.c
··· 9 9 #include <drm/drm_gem_atomic_helper.h> 10 10 #include <drm/drm_probe_helper.h> 11 11 12 - #include "mgag200_ddc.h" 13 12 #include "mgag200_drv.h" 14 13 15 14 void mgag200_g200eh_init_registers(struct mga_device *mdev) ··· 182 183 MGAG200_CRTC_FUNCS, 183 184 }; 184 185 185 - static const struct drm_encoder_funcs mgag200_g200eh_dac_encoder_funcs = { 186 - MGAG200_DAC_ENCODER_FUNCS, 187 - }; 188 - 189 - static const struct drm_connector_helper_funcs mgag200_g200eh_vga_connector_helper_funcs = { 190 - MGAG200_VGA_CONNECTOR_HELPER_FUNCS, 191 - }; 192 - 193 - static const struct drm_connector_funcs mgag200_g200eh_vga_connector_funcs = { 194 - MGAG200_VGA_CONNECTOR_FUNCS, 195 - }; 196 - 197 186 static int mgag200_g200eh_pipeline_init(struct mga_device *mdev) 198 187 { 199 188 struct drm_device *dev = &mdev->base; 200 189 struct drm_plane *primary_plane = &mdev->primary_plane; 201 190 struct drm_crtc *crtc = &mdev->crtc; 202 - struct drm_encoder *encoder = &mdev->encoder; 203 - struct drm_connector *connector = &mdev->connector; 204 - struct i2c_adapter *ddc; 205 191 int ret; 206 192 207 193 ret = drm_universal_plane_init(dev, primary_plane, 0, ··· 214 230 drm_mode_crtc_set_gamma_size(crtc, MGAG200_LUT_SIZE); 215 231 drm_crtc_enable_color_mgmt(crtc, 0, false, MGAG200_LUT_SIZE); 216 232 217 - encoder->possible_crtcs = drm_crtc_mask(crtc); 218 - ret = drm_encoder_init(dev, encoder, &mgag200_g200eh_dac_encoder_funcs, 219 - DRM_MODE_ENCODER_DAC, NULL); 220 - if (ret) { 221 - drm_err(dev, "drm_encoder_init() failed: %d\n", ret); 233 + ret = mgag200_vga_output_init(mdev); 234 + if (ret) 222 235 return ret; 223 - } 224 - 225 - ddc = mgag200_ddc_create(mdev); 226 - if (IS_ERR(ddc)) { 227 - ret = PTR_ERR(ddc); 228 - drm_err(dev, "failed to add DDC bus: %d\n", ret); 229 - return ret; 230 - } 231 - 232 - ret = drm_connector_init_with_ddc(dev, connector, 233 - &mgag200_g200eh_vga_connector_funcs, 234 - DRM_MODE_CONNECTOR_VGA, ddc); 235 - if (ret) { 236 - drm_err(dev, "drm_connector_init_with_ddc() failed: %d\n", ret); 237 - return ret; 238 - } 239 - drm_connector_helper_add(connector, &mgag200_g200eh_vga_connector_helper_funcs); 240 - 241 - ret = drm_connector_attach_encoder(connector, encoder); 242 - if (ret) { 243 - drm_err(dev, "drm_connector_attach_encoder() failed: %d\n", ret); 244 - return ret; 245 - } 246 236 247 237 return 0; 248 238 }
+2 -44
drivers/gpu/drm/mgag200/mgag200_g200eh3.c
··· 8 8 #include <drm/drm_gem_atomic_helper.h> 9 9 #include <drm/drm_probe_helper.h> 10 10 11 - #include "mgag200_ddc.h" 12 11 #include "mgag200_drv.h" 13 12 14 13 /* ··· 86 87 MGAG200_CRTC_FUNCS, 87 88 }; 88 89 89 - static const struct drm_encoder_funcs mgag200_g200eh3_dac_encoder_funcs = { 90 - MGAG200_DAC_ENCODER_FUNCS, 91 - }; 92 - 93 - static const struct drm_connector_helper_funcs mgag200_g200eh3_vga_connector_helper_funcs = { 94 - MGAG200_VGA_CONNECTOR_HELPER_FUNCS, 95 - }; 96 - 97 - static const struct drm_connector_funcs mgag200_g200eh3_vga_connector_funcs = { 98 - MGAG200_VGA_CONNECTOR_FUNCS, 99 - }; 100 - 101 90 static int mgag200_g200eh3_pipeline_init(struct mga_device *mdev) 102 91 { 103 92 struct drm_device *dev = &mdev->base; 104 93 struct drm_plane *primary_plane = &mdev->primary_plane; 105 94 struct drm_crtc *crtc = &mdev->crtc; 106 - struct drm_encoder *encoder = &mdev->encoder; 107 - struct drm_connector *connector = &mdev->connector; 108 - struct i2c_adapter *ddc; 109 95 int ret; 110 96 111 97 ret = drm_universal_plane_init(dev, primary_plane, 0, ··· 118 134 drm_mode_crtc_set_gamma_size(crtc, MGAG200_LUT_SIZE); 119 135 drm_crtc_enable_color_mgmt(crtc, 0, false, MGAG200_LUT_SIZE); 120 136 121 - encoder->possible_crtcs = drm_crtc_mask(crtc); 122 - ret = drm_encoder_init(dev, encoder, &mgag200_g200eh3_dac_encoder_funcs, 123 - DRM_MODE_ENCODER_DAC, NULL); 124 - if (ret) { 125 - drm_err(dev, "drm_encoder_init() failed: %d\n", ret); 137 + ret = mgag200_vga_output_init(mdev); 138 + if (ret) 126 139 return ret; 127 - } 128 - 129 - ddc = mgag200_ddc_create(mdev); 130 - if (IS_ERR(ddc)) { 131 - ret = PTR_ERR(ddc); 132 - drm_err(dev, "failed to add DDC bus: %d\n", ret); 133 - return ret; 134 - } 135 - 136 - ret = drm_connector_init_with_ddc(dev, connector, 137 - &mgag200_g200eh3_vga_connector_funcs, 138 - DRM_MODE_CONNECTOR_VGA, ddc); 139 - if (ret) { 140 - drm_err(dev, "drm_connector_init_with_ddc() failed: %d\n", ret); 141 - return ret; 142 - } 143 - drm_connector_helper_add(connector, &mgag200_g200eh3_vga_connector_helper_funcs); 144 - 145 - ret = drm_connector_attach_encoder(connector, encoder); 146 - if (ret) { 147 - drm_err(dev, "drm_connector_attach_encoder() failed: %d\n", ret); 148 - return ret; 149 - } 150 140 151 141 return 0; 152 142 }
+2 -44
drivers/gpu/drm/mgag200/mgag200_g200er.c
··· 9 9 #include <drm/drm_gem_atomic_helper.h> 10 10 #include <drm/drm_probe_helper.h> 11 11 12 - #include "mgag200_ddc.h" 13 12 #include "mgag200_drv.h" 14 13 15 14 static void mgag200_g200er_init_registers(struct mga_device *mdev) ··· 225 226 MGAG200_CRTC_FUNCS, 226 227 }; 227 228 228 - static const struct drm_encoder_funcs mgag200_g200er_dac_encoder_funcs = { 229 - MGAG200_DAC_ENCODER_FUNCS, 230 - }; 231 - 232 - static const struct drm_connector_helper_funcs mgag200_g200er_vga_connector_helper_funcs = { 233 - MGAG200_VGA_CONNECTOR_HELPER_FUNCS, 234 - }; 235 - 236 - static const struct drm_connector_funcs mgag200_g200er_vga_connector_funcs = { 237 - MGAG200_VGA_CONNECTOR_FUNCS, 238 - }; 239 - 240 229 static int mgag200_g200er_pipeline_init(struct mga_device *mdev) 241 230 { 242 231 struct drm_device *dev = &mdev->base; 243 232 struct drm_plane *primary_plane = &mdev->primary_plane; 244 233 struct drm_crtc *crtc = &mdev->crtc; 245 - struct drm_encoder *encoder = &mdev->encoder; 246 - struct drm_connector *connector = &mdev->connector; 247 - struct i2c_adapter *ddc; 248 234 int ret; 249 235 250 236 ret = drm_universal_plane_init(dev, primary_plane, 0, ··· 257 273 drm_mode_crtc_set_gamma_size(crtc, MGAG200_LUT_SIZE); 258 274 drm_crtc_enable_color_mgmt(crtc, 0, false, MGAG200_LUT_SIZE); 259 275 260 - encoder->possible_crtcs = drm_crtc_mask(crtc); 261 - ret = drm_encoder_init(dev, encoder, &mgag200_g200er_dac_encoder_funcs, 262 - DRM_MODE_ENCODER_DAC, NULL); 263 - if (ret) { 264 - drm_err(dev, "drm_encoder_init() failed: %d\n", ret); 276 + ret = mgag200_vga_output_init(mdev); 277 + if (ret) 265 278 return ret; 266 - } 267 - 268 - ddc = mgag200_ddc_create(mdev); 269 - if (IS_ERR(ddc)) { 270 - ret = PTR_ERR(ddc); 271 - drm_err(dev, "failed to add DDC bus: %d\n", ret); 272 - return ret; 273 - } 274 - 275 - ret = drm_connector_init_with_ddc(dev, connector, 276 - &mgag200_g200er_vga_connector_funcs, 277 - DRM_MODE_CONNECTOR_VGA, ddc); 278 - if (ret) { 279 - drm_err(dev, "drm_connector_init_with_ddc() failed: %d\n", ret); 280 - return ret; 281 - } 282 - drm_connector_helper_add(connector, &mgag200_g200er_vga_connector_helper_funcs); 283 - 284 - ret = drm_connector_attach_encoder(connector, encoder); 285 - if (ret) { 286 - drm_err(dev, "drm_connector_attach_encoder() failed: %d\n", ret); 287 - return ret; 288 - } 289 279 290 280 return 0; 291 281 }
+2 -44
drivers/gpu/drm/mgag200/mgag200_g200ev.c
··· 9 9 #include <drm/drm_gem_atomic_helper.h> 10 10 #include <drm/drm_probe_helper.h> 11 11 12 - #include "mgag200_ddc.h" 13 12 #include "mgag200_drv.h" 14 13 15 14 static void mgag200_g200ev_init_registers(struct mga_device *mdev) ··· 226 227 MGAG200_CRTC_FUNCS, 227 228 }; 228 229 229 - static const struct drm_encoder_funcs mgag200_g200ev_dac_encoder_funcs = { 230 - MGAG200_DAC_ENCODER_FUNCS, 231 - }; 232 - 233 - static const struct drm_connector_helper_funcs mgag200_g200ev_vga_connector_helper_funcs = { 234 - MGAG200_VGA_CONNECTOR_HELPER_FUNCS, 235 - }; 236 - 237 - static const struct drm_connector_funcs mgag200_g200ev_vga_connector_funcs = { 238 - MGAG200_VGA_CONNECTOR_FUNCS, 239 - }; 240 - 241 230 static int mgag200_g200ev_pipeline_init(struct mga_device *mdev) 242 231 { 243 232 struct drm_device *dev = &mdev->base; 244 233 struct drm_plane *primary_plane = &mdev->primary_plane; 245 234 struct drm_crtc *crtc = &mdev->crtc; 246 - struct drm_encoder *encoder = &mdev->encoder; 247 - struct drm_connector *connector = &mdev->connector; 248 - struct i2c_adapter *ddc; 249 235 int ret; 250 236 251 237 ret = drm_universal_plane_init(dev, primary_plane, 0, ··· 258 274 drm_mode_crtc_set_gamma_size(crtc, MGAG200_LUT_SIZE); 259 275 drm_crtc_enable_color_mgmt(crtc, 0, false, MGAG200_LUT_SIZE); 260 276 261 - encoder->possible_crtcs = drm_crtc_mask(crtc); 262 - ret = drm_encoder_init(dev, encoder, &mgag200_g200ev_dac_encoder_funcs, 263 - DRM_MODE_ENCODER_DAC, NULL); 264 - if (ret) { 265 - drm_err(dev, "drm_encoder_init() failed: %d\n", ret); 277 + ret = mgag200_vga_output_init(mdev); 278 + if (ret) 266 279 return ret; 267 - } 268 - 269 - ddc = mgag200_ddc_create(mdev); 270 - if (IS_ERR(ddc)) { 271 - ret = PTR_ERR(ddc); 272 - drm_err(dev, "failed to add DDC bus: %d\n", ret); 273 - return ret; 274 - } 275 - 276 - ret = drm_connector_init_with_ddc(dev, connector, 277 - &mgag200_g200ev_vga_connector_funcs, 278 - DRM_MODE_CONNECTOR_VGA, ddc); 279 - if (ret) { 280 - drm_err(dev, "drm_connector_init_with_ddc() failed: %d\n", ret); 281 - return ret; 282 - } 283 - drm_connector_helper_add(connector, &mgag200_g200ev_vga_connector_helper_funcs); 284 - 285 - ret = drm_connector_attach_encoder(connector, encoder); 286 - if (ret) { 287 - drm_err(dev, "drm_connector_attach_encoder() failed: %d\n", ret); 288 - return ret; 289 - } 290 280 291 281 return 0; 292 282 }
+2 -44
drivers/gpu/drm/mgag200/mgag200_g200ew3.c
··· 8 8 #include <drm/drm_gem_atomic_helper.h> 9 9 #include <drm/drm_probe_helper.h> 10 10 11 - #include "mgag200_ddc.h" 12 11 #include "mgag200_drv.h" 13 12 14 13 static void mgag200_g200ew3_init_registers(struct mga_device *mdev) ··· 95 96 MGAG200_CRTC_FUNCS, 96 97 }; 97 98 98 - static const struct drm_encoder_funcs mgag200_g200ew3_dac_encoder_funcs = { 99 - MGAG200_DAC_ENCODER_FUNCS, 100 - }; 101 - 102 - static const struct drm_connector_helper_funcs mgag200_g200ew3_vga_connector_helper_funcs = { 103 - MGAG200_VGA_CONNECTOR_HELPER_FUNCS, 104 - }; 105 - 106 - static const struct drm_connector_funcs mgag200_g200ew3_vga_connector_funcs = { 107 - MGAG200_VGA_CONNECTOR_FUNCS, 108 - }; 109 - 110 99 static int mgag200_g200ew3_pipeline_init(struct mga_device *mdev) 111 100 { 112 101 struct drm_device *dev = &mdev->base; 113 102 struct drm_plane *primary_plane = &mdev->primary_plane; 114 103 struct drm_crtc *crtc = &mdev->crtc; 115 - struct drm_encoder *encoder = &mdev->encoder; 116 - struct drm_connector *connector = &mdev->connector; 117 - struct i2c_adapter *ddc; 118 104 int ret; 119 105 120 106 ret = drm_universal_plane_init(dev, primary_plane, 0, ··· 127 143 drm_mode_crtc_set_gamma_size(crtc, MGAG200_LUT_SIZE); 128 144 drm_crtc_enable_color_mgmt(crtc, 0, false, MGAG200_LUT_SIZE); 129 145 130 - encoder->possible_crtcs = drm_crtc_mask(crtc); 131 - ret = drm_encoder_init(dev, encoder, &mgag200_g200ew3_dac_encoder_funcs, 132 - DRM_MODE_ENCODER_DAC, NULL); 133 - if (ret) { 134 - drm_err(dev, "drm_encoder_init() failed: %d\n", ret); 146 + ret = mgag200_vga_output_init(mdev); 147 + if (ret) 135 148 return ret; 136 - } 137 - 138 - ddc = mgag200_ddc_create(mdev); 139 - if (IS_ERR(ddc)) { 140 - ret = PTR_ERR(ddc); 141 - drm_err(dev, "failed to add DDC bus: %d\n", ret); 142 - return ret; 143 - } 144 - 145 - ret = drm_connector_init_with_ddc(dev, connector, 146 - &mgag200_g200ew3_vga_connector_funcs, 147 - DRM_MODE_CONNECTOR_VGA, ddc); 148 - if (ret) { 149 - drm_err(dev, "drm_connector_init_with_ddc() failed: %d\n", ret); 150 - return ret; 151 - } 152 - drm_connector_helper_add(connector, &mgag200_g200ew3_vga_connector_helper_funcs); 153 - 154 - ret = drm_connector_attach_encoder(connector, encoder); 155 - if (ret) { 156 - drm_err(dev, "drm_connector_attach_encoder() failed: %d\n", ret); 157 - return ret; 158 - } 159 149 160 150 return 0; 161 151 }
+2 -44
drivers/gpu/drm/mgag200/mgag200_g200se.c
··· 9 9 #include <drm/drm_gem_atomic_helper.h> 10 10 #include <drm/drm_probe_helper.h> 11 11 12 - #include "mgag200_ddc.h" 13 12 #include "mgag200_drv.h" 14 13 15 14 static int mgag200_g200se_init_pci_options(struct pci_dev *pdev) ··· 357 358 MGAG200_CRTC_FUNCS, 358 359 }; 359 360 360 - static const struct drm_encoder_funcs mgag200_g200se_dac_encoder_funcs = { 361 - MGAG200_DAC_ENCODER_FUNCS, 362 - }; 363 - 364 - static const struct drm_connector_helper_funcs mgag200_g200se_vga_connector_helper_funcs = { 365 - MGAG200_VGA_CONNECTOR_HELPER_FUNCS, 366 - }; 367 - 368 - static const struct drm_connector_funcs mgag200_g200se_vga_connector_funcs = { 369 - MGAG200_VGA_CONNECTOR_FUNCS, 370 - }; 371 - 372 361 static int mgag200_g200se_pipeline_init(struct mga_device *mdev) 373 362 { 374 363 struct drm_device *dev = &mdev->base; 375 364 struct drm_plane *primary_plane = &mdev->primary_plane; 376 365 struct drm_crtc *crtc = &mdev->crtc; 377 - struct drm_encoder *encoder = &mdev->encoder; 378 - struct drm_connector *connector = &mdev->connector; 379 - struct i2c_adapter *ddc; 380 366 int ret; 381 367 382 368 ret = drm_universal_plane_init(dev, primary_plane, 0, ··· 389 405 drm_mode_crtc_set_gamma_size(crtc, MGAG200_LUT_SIZE); 390 406 drm_crtc_enable_color_mgmt(crtc, 0, false, MGAG200_LUT_SIZE); 391 407 392 - encoder->possible_crtcs = drm_crtc_mask(crtc); 393 - ret = drm_encoder_init(dev, encoder, &mgag200_g200se_dac_encoder_funcs, 394 - DRM_MODE_ENCODER_DAC, NULL); 395 - if (ret) { 396 - drm_err(dev, "drm_encoder_init() failed: %d\n", ret); 408 + ret = mgag200_vga_output_init(mdev); 409 + if (ret) 397 410 return ret; 398 - } 399 - 400 - ddc = mgag200_ddc_create(mdev); 401 - if (IS_ERR(ddc)) { 402 - ret = PTR_ERR(ddc); 403 - drm_err(dev, "failed to add DDC bus: %d\n", ret); 404 - return ret; 405 - } 406 - 407 - ret = drm_connector_init_with_ddc(dev, connector, 408 - &mgag200_g200se_vga_connector_funcs, 409 - DRM_MODE_CONNECTOR_VGA, ddc); 410 - if (ret) { 411 - drm_err(dev, "drm_connector_init_with_ddc() failed: %d\n", ret); 412 - return ret; 413 - } 414 - drm_connector_helper_add(connector, &mgag200_g200se_vga_connector_helper_funcs); 415 - 416 - ret = drm_connector_attach_encoder(connector, encoder); 417 - if (ret) { 418 - drm_err(dev, "drm_connector_attach_encoder() failed: %d\n", ret); 419 - return ret; 420 - } 421 411 422 412 return 0; 423 413 }
+2 -44
drivers/gpu/drm/mgag200/mgag200_g200wb.c
··· 9 9 #include <drm/drm_gem_atomic_helper.h> 10 10 #include <drm/drm_probe_helper.h> 11 11 12 - #include "mgag200_ddc.h" 13 12 #include "mgag200_drv.h" 14 13 15 14 void mgag200_g200wb_init_registers(struct mga_device *mdev) ··· 229 230 MGAG200_CRTC_FUNCS, 230 231 }; 231 232 232 - static const struct drm_encoder_funcs mgag200_g200wb_dac_encoder_funcs = { 233 - MGAG200_DAC_ENCODER_FUNCS, 234 - }; 235 - 236 - static const struct drm_connector_helper_funcs mgag200_g200wb_vga_connector_helper_funcs = { 237 - MGAG200_VGA_CONNECTOR_HELPER_FUNCS, 238 - }; 239 - 240 - static const struct drm_connector_funcs mgag200_g200wb_vga_connector_funcs = { 241 - MGAG200_VGA_CONNECTOR_FUNCS, 242 - }; 243 - 244 233 static int mgag200_g200wb_pipeline_init(struct mga_device *mdev) 245 234 { 246 235 struct drm_device *dev = &mdev->base; 247 236 struct drm_plane *primary_plane = &mdev->primary_plane; 248 237 struct drm_crtc *crtc = &mdev->crtc; 249 - struct drm_encoder *encoder = &mdev->encoder; 250 - struct drm_connector *connector = &mdev->connector; 251 - struct i2c_adapter *ddc; 252 238 int ret; 253 239 254 240 ret = drm_universal_plane_init(dev, primary_plane, 0, ··· 261 277 drm_mode_crtc_set_gamma_size(crtc, MGAG200_LUT_SIZE); 262 278 drm_crtc_enable_color_mgmt(crtc, 0, false, MGAG200_LUT_SIZE); 263 279 264 - encoder->possible_crtcs = drm_crtc_mask(crtc); 265 - ret = drm_encoder_init(dev, encoder, &mgag200_g200wb_dac_encoder_funcs, 266 - DRM_MODE_ENCODER_DAC, NULL); 267 - if (ret) { 268 - drm_err(dev, "drm_encoder_init() failed: %d\n", ret); 280 + ret = mgag200_vga_output_init(mdev); 281 + if (ret) 269 282 return ret; 270 - } 271 - 272 - ddc = mgag200_ddc_create(mdev); 273 - if (IS_ERR(ddc)) { 274 - ret = PTR_ERR(ddc); 275 - drm_err(dev, "failed to add DDC bus: %d\n", ret); 276 - return ret; 277 - } 278 - 279 - ret = drm_connector_init_with_ddc(dev, connector, 280 - &mgag200_g200wb_vga_connector_funcs, 281 - DRM_MODE_CONNECTOR_VGA, ddc); 282 - if (ret) { 283 - drm_err(dev, "drm_connector_init_with_ddc() failed: %d\n", ret); 284 - return ret; 285 - } 286 - drm_connector_helper_add(connector, &mgag200_g200wb_vga_connector_helper_funcs); 287 - 288 - ret = drm_connector_attach_encoder(connector, encoder); 289 - if (ret) { 290 - drm_err(dev, "drm_connector_attach_encoder() failed: %d\n", ret); 291 - return ret; 292 - } 293 283 294 284 return 0; 295 285 }
+68
drivers/gpu/drm/mgag200/mgag200_vga.c
··· 1 + // SPDX-License-Identifier: GPL-2.0-only 2 + 3 + #include <drm/drm_atomic_helper.h> 4 + #include <drm/drm_modeset_helper_vtables.h> 5 + #include <drm/drm_probe_helper.h> 6 + 7 + #include "mgag200_ddc.h" 8 + #include "mgag200_drv.h" 9 + 10 + static const struct drm_encoder_funcs mgag200_dac_encoder_funcs = { 11 + .destroy = drm_encoder_cleanup 12 + }; 13 + 14 + static const struct drm_connector_helper_funcs mgag200_vga_connector_helper_funcs = { 15 + .get_modes = drm_connector_helper_get_modes 16 + }; 17 + 18 + static const struct drm_connector_funcs mgag200_vga_connector_funcs = { 19 + .reset = drm_atomic_helper_connector_reset, 20 + .fill_modes = drm_helper_probe_single_connector_modes, 21 + .destroy = drm_connector_cleanup, 22 + .atomic_duplicate_state = drm_atomic_helper_connector_duplicate_state, 23 + .atomic_destroy_state = drm_atomic_helper_connector_destroy_state 24 + }; 25 + 26 + int mgag200_vga_output_init(struct mga_device *mdev) 27 + { 28 + struct drm_device *dev = &mdev->base; 29 + struct drm_crtc *crtc = &mdev->crtc; 30 + struct drm_encoder *encoder; 31 + struct drm_connector *connector; 32 + struct i2c_adapter *ddc; 33 + int ret; 34 + 35 + encoder = &mdev->output.vga.encoder; 36 + ret = drm_encoder_init(dev, encoder, &mgag200_dac_encoder_funcs, 37 + DRM_MODE_ENCODER_DAC, NULL); 38 + if (ret) { 39 + drm_err(dev, "drm_encoder_init() failed: %d\n", ret); 40 + return ret; 41 + } 42 + encoder->possible_crtcs = drm_crtc_mask(crtc); 43 + 44 + ddc = mgag200_ddc_create(mdev); 45 + if (IS_ERR(ddc)) { 46 + ret = PTR_ERR(ddc); 47 + drm_err(dev, "failed to add DDC bus: %d\n", ret); 48 + return ret; 49 + } 50 + 51 + connector = &mdev->output.vga.connector; 52 + ret = drm_connector_init_with_ddc(dev, connector, 53 + &mgag200_vga_connector_funcs, 54 + DRM_MODE_CONNECTOR_VGA, ddc); 55 + if (ret) { 56 + drm_err(dev, "drm_connector_init_with_ddc() failed: %d\n", ret); 57 + return ret; 58 + } 59 + drm_connector_helper_add(connector, &mgag200_vga_connector_helper_funcs); 60 + 61 + ret = drm_connector_attach_encoder(connector, encoder); 62 + if (ret) { 63 + drm_err(dev, "drm_connector_attach_encoder() failed: %d\n", ret); 64 + return ret; 65 + } 66 + 67 + return 0; 68 + }