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/gma500: Rename psb_intel_connector to gma_connector

The psb_intel_connector is generic and should be named appropriately

Signed-off-by: Patrik Jakobsson <patrik.r.jakobsson@gmail.com>

Patrik Jakobsson a3d5d75f 6306865d

+64 -65
+7 -7
drivers/gpu/drm/gma500/cdv_intel_crt.c
··· 259 259 struct psb_intel_mode_device *mode_dev) 260 260 { 261 261 262 - struct psb_intel_connector *psb_intel_connector; 262 + struct gma_connector *gma_connector; 263 263 struct psb_intel_encoder *psb_intel_encoder; 264 264 struct drm_connector *connector; 265 265 struct drm_encoder *encoder; ··· 270 270 if (!psb_intel_encoder) 271 271 return; 272 272 273 - psb_intel_connector = kzalloc(sizeof(struct psb_intel_connector), GFP_KERNEL); 274 - if (!psb_intel_connector) 273 + gma_connector = kzalloc(sizeof(struct gma_connector), GFP_KERNEL); 274 + if (!gma_connector) 275 275 goto failed_connector; 276 276 277 - connector = &psb_intel_connector->base; 277 + connector = &gma_connector->base; 278 278 connector->polled = DRM_CONNECTOR_POLL_HPD; 279 279 drm_connector_init(dev, connector, 280 280 &cdv_intel_crt_connector_funcs, DRM_MODE_CONNECTOR_VGA); ··· 283 283 drm_encoder_init(dev, encoder, 284 284 &cdv_intel_crt_enc_funcs, DRM_MODE_ENCODER_DAC); 285 285 286 - gma_connector_attach_encoder(psb_intel_connector, psb_intel_encoder); 286 + gma_connector_attach_encoder(gma_connector, psb_intel_encoder); 287 287 288 288 /* Set up the DDC bus. */ 289 289 i2c_reg = GPIOA; ··· 317 317 return; 318 318 failed_ddc: 319 319 drm_encoder_cleanup(&psb_intel_encoder->base); 320 - drm_connector_cleanup(&psb_intel_connector->base); 321 - kfree(psb_intel_connector); 320 + drm_connector_cleanup(&gma_connector->base); 321 + kfree(gma_connector); 322 322 failed_connector: 323 323 kfree(psb_intel_encoder); 324 324 return;
+8 -8
drivers/gpu/drm/gma500/cdv_intel_dp.c
··· 648 648 } 649 649 650 650 static int 651 - cdv_intel_dp_i2c_init(struct psb_intel_connector *connector, struct psb_intel_encoder *encoder, const char *name) 651 + cdv_intel_dp_i2c_init(struct gma_connector *connector, struct psb_intel_encoder *encoder, const char *name) 652 652 { 653 653 struct cdv_intel_dp *intel_dp = encoder->dev_priv; 654 654 int ret; ··· 1803 1803 cdv_intel_dp_init(struct drm_device *dev, struct psb_intel_mode_device *mode_dev, int output_reg) 1804 1804 { 1805 1805 struct psb_intel_encoder *psb_intel_encoder; 1806 - struct psb_intel_connector *psb_intel_connector; 1806 + struct gma_connector *gma_connector; 1807 1807 struct drm_connector *connector; 1808 1808 struct drm_encoder *encoder; 1809 1809 struct cdv_intel_dp *intel_dp; ··· 1813 1813 psb_intel_encoder = kzalloc(sizeof(struct psb_intel_encoder), GFP_KERNEL); 1814 1814 if (!psb_intel_encoder) 1815 1815 return; 1816 - psb_intel_connector = kzalloc(sizeof(struct psb_intel_connector), GFP_KERNEL); 1817 - if (!psb_intel_connector) 1816 + gma_connector = kzalloc(sizeof(struct gma_connector), GFP_KERNEL); 1817 + if (!gma_connector) 1818 1818 goto err_connector; 1819 1819 intel_dp = kzalloc(sizeof(struct cdv_intel_dp), GFP_KERNEL); 1820 1820 if (!intel_dp) ··· 1823 1823 if ((output_reg == DP_C) && cdv_intel_dpc_is_edp(dev)) 1824 1824 type = DRM_MODE_CONNECTOR_eDP; 1825 1825 1826 - connector = &psb_intel_connector->base; 1826 + connector = &gma_connector->base; 1827 1827 encoder = &psb_intel_encoder->base; 1828 1828 1829 1829 drm_connector_init(dev, connector, &cdv_intel_dp_connector_funcs, type); 1830 1830 drm_encoder_init(dev, encoder, &cdv_intel_dp_enc_funcs, DRM_MODE_ENCODER_TMDS); 1831 1831 1832 - gma_connector_attach_encoder(psb_intel_connector, psb_intel_encoder); 1832 + gma_connector_attach_encoder(gma_connector, psb_intel_encoder); 1833 1833 1834 1834 if (type == DRM_MODE_CONNECTOR_DisplayPort) 1835 1835 psb_intel_encoder->type = INTEL_OUTPUT_DISPLAYPORT; ··· 1864 1864 1865 1865 cdv_disable_intel_clock_gating(dev); 1866 1866 1867 - cdv_intel_dp_i2c_init(psb_intel_connector, psb_intel_encoder, name); 1867 + cdv_intel_dp_i2c_init(gma_connector, psb_intel_encoder, name); 1868 1868 /* FIXME:fail check */ 1869 1869 cdv_intel_dp_add_properties(connector); 1870 1870 ··· 1947 1947 return; 1948 1948 1949 1949 err_priv: 1950 - kfree(psb_intel_connector); 1950 + kfree(gma_connector); 1951 1951 err_connector: 1952 1952 kfree(psb_intel_encoder); 1953 1953 }
+6 -6
drivers/gpu/drm/gma500/cdv_intel_hdmi.c
··· 295 295 struct psb_intel_mode_device *mode_dev, int reg) 296 296 { 297 297 struct psb_intel_encoder *psb_intel_encoder; 298 - struct psb_intel_connector *psb_intel_connector; 298 + struct gma_connector *gma_connector; 299 299 struct drm_connector *connector; 300 300 struct drm_encoder *encoder; 301 301 struct mid_intel_hdmi_priv *hdmi_priv; ··· 307 307 if (!psb_intel_encoder) 308 308 return; 309 309 310 - psb_intel_connector = kzalloc(sizeof(struct psb_intel_connector), 310 + gma_connector = kzalloc(sizeof(struct gma_connector), 311 311 GFP_KERNEL); 312 312 313 - if (!psb_intel_connector) 313 + if (!gma_connector) 314 314 goto err_connector; 315 315 316 316 hdmi_priv = kzalloc(sizeof(struct mid_intel_hdmi_priv), GFP_KERNEL); ··· 318 318 if (!hdmi_priv) 319 319 goto err_priv; 320 320 321 - connector = &psb_intel_connector->base; 321 + connector = &gma_connector->base; 322 322 connector->polled = DRM_CONNECTOR_POLL_HPD; 323 323 encoder = &psb_intel_encoder->base; 324 324 drm_connector_init(dev, connector, ··· 328 328 drm_encoder_init(dev, encoder, &psb_intel_lvds_enc_funcs, 329 329 DRM_MODE_ENCODER_TMDS); 330 330 331 - gma_connector_attach_encoder(psb_intel_connector, psb_intel_encoder); 331 + gma_connector_attach_encoder(gma_connector, psb_intel_encoder); 332 332 psb_intel_encoder->type = INTEL_OUTPUT_HDMI; 333 333 hdmi_priv->hdmi_reg = reg; 334 334 hdmi_priv->has_hdmi_sink = false; ··· 378 378 drm_encoder_cleanup(encoder); 379 379 drm_connector_cleanup(connector); 380 380 err_priv: 381 - kfree(psb_intel_connector); 381 + kfree(gma_connector); 382 382 err_connector: 383 383 kfree(psb_intel_encoder); 384 384 }
+6 -6
drivers/gpu/drm/gma500/cdv_intel_lvds.c
··· 611 611 struct psb_intel_mode_device *mode_dev) 612 612 { 613 613 struct psb_intel_encoder *psb_intel_encoder; 614 - struct psb_intel_connector *psb_intel_connector; 614 + struct gma_connector *gma_connector; 615 615 struct cdv_intel_lvds_priv *lvds_priv; 616 616 struct drm_connector *connector; 617 617 struct drm_encoder *encoder; ··· 633 633 if (!psb_intel_encoder) 634 634 return; 635 635 636 - psb_intel_connector = kzalloc(sizeof(struct psb_intel_connector), 636 + gma_connector = kzalloc(sizeof(struct gma_connector), 637 637 GFP_KERNEL); 638 - if (!psb_intel_connector) 638 + if (!gma_connector) 639 639 goto failed_connector; 640 640 641 641 lvds_priv = kzalloc(sizeof(struct cdv_intel_lvds_priv), GFP_KERNEL); ··· 644 644 645 645 psb_intel_encoder->dev_priv = lvds_priv; 646 646 647 - connector = &psb_intel_connector->base; 647 + connector = &gma_connector->base; 648 648 encoder = &psb_intel_encoder->base; 649 649 650 650 ··· 657 657 DRM_MODE_ENCODER_LVDS); 658 658 659 659 660 - gma_connector_attach_encoder(psb_intel_connector, psb_intel_encoder); 660 + gma_connector_attach_encoder(gma_connector, psb_intel_encoder); 661 661 psb_intel_encoder->type = INTEL_OUTPUT_LVDS; 662 662 663 663 drm_encoder_helper_add(encoder, &cdv_intel_lvds_helper_funcs); ··· 791 791 drm_connector_cleanup(connector); 792 792 kfree(lvds_priv); 793 793 failed_lvds_priv: 794 - kfree(psb_intel_connector); 794 + kfree(gma_connector); 795 795 failed_connector: 796 796 kfree(psb_intel_encoder); 797 797 }
+1 -1
drivers/gpu/drm/gma500/framebuffer.c
··· 744 744 } 745 745 encoder->possible_crtcs = crtc_mask; 746 746 encoder->possible_clones = 747 - psb_intel_connector_clones(dev, clone_mask); 747 + gma_connector_clones(dev, clone_mask); 748 748 } 749 749 } 750 750
+1 -1
drivers/gpu/drm/gma500/framebuffer.h
··· 41 41 42 42 #define to_psb_fb(x) container_of(x, struct psb_framebuffer, base) 43 43 44 - extern int psb_intel_connector_clones(struct drm_device *dev, int type_mask); 44 + extern int gma_connector_clones(struct drm_device *dev, int type_mask); 45 45 46 46 #endif 47 47
+1 -1
drivers/gpu/drm/gma500/gma_display.c
··· 672 672 return &psb_intel_encoder->base; 673 673 } 674 674 675 - void gma_connector_attach_encoder(struct psb_intel_connector *connector, 675 + void gma_connector_attach_encoder(struct gma_connector *connector, 676 676 struct psb_intel_encoder *encoder) 677 677 { 678 678 connector->encoder = encoder;
+4 -4
drivers/gpu/drm/gma500/mdfld_dsi_output.h
··· 227 227 #define DSI_DPI_DISABLE_BTA BIT(3) 228 228 229 229 struct mdfld_dsi_connector { 230 - struct psb_intel_connector base; 230 + struct gma_connector base; 231 231 232 232 int pipe; 233 233 void *private; ··· 269 269 static inline struct mdfld_dsi_connector *mdfld_dsi_connector( 270 270 struct drm_connector *connector) 271 271 { 272 - struct psb_intel_connector *psb_connector; 272 + struct gma_connector *gma_connector; 273 273 274 - psb_connector = to_psb_intel_connector(connector); 274 + gma_connector = to_gma_connector(connector); 275 275 276 - return container_of(psb_connector, struct mdfld_dsi_connector, base); 276 + return container_of(gma_connector, struct mdfld_dsi_connector, base); 277 277 } 278 278 279 279 static inline struct mdfld_dsi_encoder *mdfld_dsi_encoder(
+5 -5
drivers/gpu/drm/gma500/oaktrail_hdmi.c
··· 641 641 struct psb_intel_mode_device *mode_dev) 642 642 { 643 643 struct psb_intel_encoder *psb_intel_encoder; 644 - struct psb_intel_connector *psb_intel_connector; 644 + struct gma_connector *gma_connector; 645 645 struct drm_connector *connector; 646 646 struct drm_encoder *encoder; 647 647 ··· 649 649 if (!psb_intel_encoder) 650 650 return; 651 651 652 - psb_intel_connector = kzalloc(sizeof(struct psb_intel_connector), GFP_KERNEL); 653 - if (!psb_intel_connector) 652 + gma_connector = kzalloc(sizeof(struct gma_connector), GFP_KERNEL); 653 + if (!gma_connector) 654 654 goto failed_connector; 655 655 656 - connector = &psb_intel_connector->base; 656 + connector = &gma_connector->base; 657 657 encoder = &psb_intel_encoder->base; 658 658 drm_connector_init(dev, connector, 659 659 &oaktrail_hdmi_connector_funcs, ··· 663 663 &oaktrail_hdmi_enc_funcs, 664 664 DRM_MODE_ENCODER_TMDS); 665 665 666 - gma_connector_attach_encoder(psb_intel_connector, psb_intel_encoder); 666 + gma_connector_attach_encoder(gma_connector, psb_intel_encoder); 667 667 668 668 psb_intel_encoder->type = INTEL_OUTPUT_HDMI; 669 669 drm_encoder_helper_add(encoder, &oaktrail_hdmi_helper_funcs);
+6 -6
drivers/gpu/drm/gma500/oaktrail_lvds.c
··· 326 326 struct psb_intel_mode_device *mode_dev) 327 327 { 328 328 struct psb_intel_encoder *psb_intel_encoder; 329 - struct psb_intel_connector *psb_intel_connector; 329 + struct gma_connector *gma_connector; 330 330 struct drm_connector *connector; 331 331 struct drm_encoder *encoder; 332 332 struct drm_psb_private *dev_priv = dev->dev_private; ··· 338 338 if (!psb_intel_encoder) 339 339 return; 340 340 341 - psb_intel_connector = kzalloc(sizeof(struct psb_intel_connector), GFP_KERNEL); 342 - if (!psb_intel_connector) 341 + gma_connector = kzalloc(sizeof(struct gma_connector), GFP_KERNEL); 342 + if (!gma_connector) 343 343 goto failed_connector; 344 344 345 - connector = &psb_intel_connector->base; 345 + connector = &gma_connector->base; 346 346 encoder = &psb_intel_encoder->base; 347 347 dev_priv->is_lvds_on = true; 348 348 drm_connector_init(dev, connector, ··· 352 352 drm_encoder_init(dev, encoder, &psb_intel_lvds_enc_funcs, 353 353 DRM_MODE_ENCODER_LVDS); 354 354 355 - gma_connector_attach_encoder(psb_intel_connector, psb_intel_encoder); 355 + gma_connector_attach_encoder(gma_connector, psb_intel_encoder); 356 356 psb_intel_encoder->type = INTEL_OUTPUT_LVDS; 357 357 358 358 drm_encoder_helper_add(encoder, &oaktrail_lvds_helper_funcs); ··· 440 440 441 441 drm_encoder_cleanup(encoder); 442 442 drm_connector_cleanup(connector); 443 - kfree(psb_intel_connector); 443 + kfree(gma_connector); 444 444 failed_connector: 445 445 kfree(psb_intel_encoder); 446 446 }
+1 -1
drivers/gpu/drm/gma500/psb_intel_display.c
··· 594 594 return crtc; 595 595 } 596 596 597 - int psb_intel_connector_clones(struct drm_device *dev, int type_mask) 597 + int gma_connector_clones(struct drm_device *dev, int type_mask) 598 598 { 599 599 int index_mask = 0; 600 600 struct drm_connector *connector;
+5 -5
drivers/gpu/drm/gma500/psb_intel_drv.h
··· 137 137 struct psb_intel_i2c_chan *ddc_bus; 138 138 }; 139 139 140 - struct psb_intel_connector { 140 + struct gma_connector { 141 141 struct drm_connector base; 142 142 struct psb_intel_encoder *encoder; 143 143 }; ··· 195 195 196 196 #define to_gma_crtc(x) \ 197 197 container_of(x, struct gma_crtc, base) 198 - #define to_psb_intel_connector(x) \ 199 - container_of(x, struct psb_intel_connector, base) 198 + #define to_gma_connector(x) \ 199 + container_of(x, struct gma_connector, base) 200 200 #define to_psb_intel_encoder(x) \ 201 201 container_of(x, struct psb_intel_encoder, base) 202 202 #define to_psb_intel_framebuffer(x) \ ··· 227 227 struct psb_intel_mode_device *mode_dev, int dsi_num); 228 228 229 229 extern struct drm_encoder *gma_best_encoder(struct drm_connector *connector); 230 - extern void gma_connector_attach_encoder(struct psb_intel_connector *connector, 230 + extern void gma_connector_attach_encoder(struct gma_connector *connector, 231 231 struct psb_intel_encoder *encoder); 232 232 233 233 static inline struct psb_intel_encoder *gma_attached_encoder( 234 234 struct drm_connector *connector) 235 235 { 236 - return to_psb_intel_connector(connector)->encoder; 236 + return to_gma_connector(connector)->encoder; 237 237 } 238 238 239 239 extern struct drm_display_mode *psb_intel_crtc_mode_get(struct drm_device *dev,
+7 -8
drivers/gpu/drm/gma500/psb_intel_lvds.c
··· 690 690 struct psb_intel_mode_device *mode_dev) 691 691 { 692 692 struct psb_intel_encoder *psb_intel_encoder; 693 - struct psb_intel_connector *psb_intel_connector; 693 + struct gma_connector *gma_connector; 694 694 struct psb_intel_lvds_priv *lvds_priv; 695 695 struct drm_connector *connector; 696 696 struct drm_encoder *encoder; ··· 707 707 return; 708 708 } 709 709 710 - psb_intel_connector = 711 - kzalloc(sizeof(struct psb_intel_connector), GFP_KERNEL); 712 - if (!psb_intel_connector) { 713 - dev_err(dev->dev, "psb_intel_connector allocation error\n"); 710 + gma_connector = kzalloc(sizeof(struct gma_connector), GFP_KERNEL); 711 + if (!gma_connector) { 712 + dev_err(dev->dev, "gma_connector allocation error\n"); 714 713 goto failed_encoder; 715 714 } 716 715 ··· 721 722 722 723 psb_intel_encoder->dev_priv = lvds_priv; 723 724 724 - connector = &psb_intel_connector->base; 725 + connector = &gma_connector->base; 725 726 encoder = &psb_intel_encoder->base; 726 727 drm_connector_init(dev, connector, 727 728 &psb_intel_lvds_connector_funcs, ··· 731 732 &psb_intel_lvds_enc_funcs, 732 733 DRM_MODE_ENCODER_LVDS); 733 734 734 - gma_connector_attach_encoder(psb_intel_connector, psb_intel_encoder); 735 + gma_connector_attach_encoder(gma_connector, psb_intel_encoder); 735 736 psb_intel_encoder->type = INTEL_OUTPUT_LVDS; 736 737 737 738 drm_encoder_helper_add(encoder, &psb_intel_lvds_helper_funcs); ··· 847 848 drm_encoder_cleanup(encoder); 848 849 drm_connector_cleanup(connector); 849 850 failed_connector: 850 - kfree(psb_intel_connector); 851 + kfree(gma_connector); 851 852 failed_encoder: 852 853 kfree(psb_intel_encoder); 853 854 }
+6 -6
drivers/gpu/drm/gma500/psb_intel_sdvo.c
··· 140 140 }; 141 141 142 142 struct psb_intel_sdvo_connector { 143 - struct psb_intel_connector base; 143 + struct gma_connector base; 144 144 145 145 /* Mark the type of connector */ 146 146 uint16_t output_flag; ··· 206 206 207 207 static struct psb_intel_sdvo_connector *to_psb_intel_sdvo_connector(struct drm_connector *connector) 208 208 { 209 - return container_of(to_psb_intel_connector(connector), struct psb_intel_sdvo_connector, base); 209 + return container_of(to_gma_connector(connector), struct psb_intel_sdvo_connector, base); 210 210 } 211 211 212 212 static bool ··· 2074 2074 { 2075 2075 struct drm_encoder *encoder = &psb_intel_sdvo->base.base; 2076 2076 struct drm_connector *connector; 2077 - struct psb_intel_connector *intel_connector; 2077 + struct gma_connector *intel_connector; 2078 2078 struct psb_intel_sdvo_connector *psb_intel_sdvo_connector; 2079 2079 2080 2080 psb_intel_sdvo_connector = kzalloc(sizeof(struct psb_intel_sdvo_connector), GFP_KERNEL); ··· 2114 2114 { 2115 2115 struct drm_encoder *encoder = &psb_intel_sdvo->base.base; 2116 2116 struct drm_connector *connector; 2117 - struct psb_intel_connector *intel_connector; 2117 + struct gma_connector *intel_connector; 2118 2118 struct psb_intel_sdvo_connector *psb_intel_sdvo_connector; 2119 2119 2120 2120 psb_intel_sdvo_connector = kzalloc(sizeof(struct psb_intel_sdvo_connector), GFP_KERNEL); ··· 2153 2153 { 2154 2154 struct drm_encoder *encoder = &psb_intel_sdvo->base.base; 2155 2155 struct drm_connector *connector; 2156 - struct psb_intel_connector *intel_connector; 2156 + struct gma_connector *intel_connector; 2157 2157 struct psb_intel_sdvo_connector *psb_intel_sdvo_connector; 2158 2158 2159 2159 psb_intel_sdvo_connector = kzalloc(sizeof(struct psb_intel_sdvo_connector), GFP_KERNEL); ··· 2187 2187 { 2188 2188 struct drm_encoder *encoder = &psb_intel_sdvo->base.base; 2189 2189 struct drm_connector *connector; 2190 - struct psb_intel_connector *intel_connector; 2190 + struct gma_connector *intel_connector; 2191 2191 struct psb_intel_sdvo_connector *psb_intel_sdvo_connector; 2192 2192 2193 2193 psb_intel_sdvo_connector = kzalloc(sizeof(struct psb_intel_sdvo_connector), GFP_KERNEL);