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

Configure Feed

Select the types of activity you want to include in your feed.

Merge tag 'drm-fixes-2022-03-04' of git://anongit.freedesktop.org/drm/drm

Pull drm fixes from Dave Airlie:
"Things are quieting down as expected, just a small set of fixes, i915,
exynos, amdgpu, vrr, bridge and hdlcd. Nothing scary at all.

i915:
- Fix GuC SLPC unset command
- Fix misidentification of some Apple MacBook Pro laptops as Jasper Lake

amdgpu:
- Suspend regression fix

exynos:
- irq handling fixes
- Fix two regressions to TE-gpio handling

arm/hdlcd:
- Select DRM_GEM_CMEA_HELPER for HDLCD

bridge:
- ti-sn65dsi86: Properly undo autosuspend

vrr:
- Fix potential NULL-pointer deref"

* tag 'drm-fixes-2022-03-04' of git://anongit.freedesktop.org/drm/drm:
drm/amdgpu: fix suspend/resume hang regression
drm/vrr: Set VRR capable prop only if it is attached to connector
drm/arm: arm hdlcd select DRM_GEM_CMA_HELPER
drm/bridge: ti-sn65dsi86: Properly undo autosuspend
drm/i915: s/JSP2/ICP2/ PCH
drm/i915/guc/slpc: Correct the param count for unset param
drm/exynos: Search for TE-gpio in DSI panel's node
drm/exynos: Don't fail if no TE-gpio is defined for DSI driver
drm/exynos: gsc: Use platform_get_irq() to get the interrupt
drm/exynos/fimc: Use platform_get_irq() to get the interrupt
drm/exynos/exynos_drm_fimd: Use platform_get_irq_byname() to get the interrupt
drm/exynos: mixer: Use platform_get_irq() to get the interrupt
drm/exynos/exynos7_drm_decon: Use platform_get_irq_byname() to get the interrupt

Linus Torvalds c4fc118a 0b7344a6

+37 -49
+2 -1
drivers/gpu/drm/amd/amdgpu/amdgpu_vm.c
··· 777 777 amdgpu_vm_eviction_lock(vm); 778 778 ret = !vm->evicting; 779 779 amdgpu_vm_eviction_unlock(vm); 780 - return ret; 780 + 781 + return ret && list_empty(&vm->evicted); 781 782 } 782 783 783 784 /**
+1
drivers/gpu/drm/arm/Kconfig
··· 6 6 depends on DRM && OF && (ARM || ARM64 || COMPILE_TEST) 7 7 depends on COMMON_CLK 8 8 select DRM_KMS_HELPER 9 + select DRM_GEM_CMA_HELPER 9 10 help 10 11 Choose this option if you have an ARM High Definition Colour LCD 11 12 controller.
+3 -2
drivers/gpu/drm/bridge/ti-sn65dsi86.c
··· 1802 1802 1803 1803 static void ti_sn65dsi86_runtime_disable(void *data) 1804 1804 { 1805 + pm_runtime_dont_use_autosuspend(data); 1805 1806 pm_runtime_disable(data); 1806 1807 } 1807 1808 ··· 1862 1861 "failed to get reference clock\n"); 1863 1862 1864 1863 pm_runtime_enable(dev); 1864 + pm_runtime_set_autosuspend_delay(pdata->dev, 500); 1865 + pm_runtime_use_autosuspend(pdata->dev); 1865 1866 ret = devm_add_action_or_reset(dev, ti_sn65dsi86_runtime_disable, dev); 1866 1867 if (ret) 1867 1868 return ret; 1868 - pm_runtime_set_autosuspend_delay(pdata->dev, 500); 1869 - pm_runtime_use_autosuspend(pdata->dev); 1870 1869 1871 1870 ti_sn65dsi86_debugfs_init(pdata); 1872 1871
+3
drivers/gpu/drm/drm_connector.c
··· 2330 2330 void drm_connector_set_vrr_capable_property( 2331 2331 struct drm_connector *connector, bool capable) 2332 2332 { 2333 + if (!connector->vrr_capable_property) 2334 + return; 2335 + 2333 2336 drm_object_property_set_value(&connector->base, 2334 2337 connector->vrr_capable_property, 2335 2338 capable);
+3 -9
drivers/gpu/drm/exynos/exynos7_drm_decon.c
··· 678 678 struct device *dev = &pdev->dev; 679 679 struct decon_context *ctx; 680 680 struct device_node *i80_if_timings; 681 - struct resource *res; 682 681 int ret; 683 682 684 683 if (!dev->of_node) ··· 727 728 goto err_iounmap; 728 729 } 729 730 730 - res = platform_get_resource_byname(pdev, IORESOURCE_IRQ, 731 - ctx->i80_if ? "lcd_sys" : "vsync"); 732 - if (!res) { 733 - dev_err(dev, "irq request failed.\n"); 734 - ret = -ENXIO; 731 + ret = platform_get_irq_byname(pdev, ctx->i80_if ? "lcd_sys" : "vsync"); 732 + if (ret < 0) 735 733 goto err_iounmap; 736 - } 737 734 738 - ret = devm_request_irq(dev, res->start, decon_irq_handler, 739 - 0, "drm_decon", ctx); 735 + ret = devm_request_irq(dev, ret, decon_irq_handler, 0, "drm_decon", ctx); 740 736 if (ret) { 741 737 dev_err(dev, "irq request failed.\n"); 742 738 goto err_iounmap;
+4 -2
drivers/gpu/drm/exynos/exynos_drm_dsi.c
··· 1334 1334 int ret; 1335 1335 int te_gpio_irq; 1336 1336 1337 - dsi->te_gpio = devm_gpiod_get_optional(dsi->dev, "te", GPIOD_IN); 1338 - if (IS_ERR(dsi->te_gpio)) { 1337 + dsi->te_gpio = gpiod_get_optional(panel, "te", GPIOD_IN); 1338 + if (!dsi->te_gpio) { 1339 + return 0; 1340 + } else if (IS_ERR(dsi->te_gpio)) { 1339 1341 dev_err(dsi->dev, "gpio request failed with %ld\n", 1340 1342 PTR_ERR(dsi->te_gpio)); 1341 1343 return PTR_ERR(dsi->te_gpio);
+5 -8
drivers/gpu/drm/exynos/exynos_drm_fimc.c
··· 1267 1267 struct exynos_drm_ipp_formats *formats; 1268 1268 struct device *dev = &pdev->dev; 1269 1269 struct fimc_context *ctx; 1270 - struct resource *res; 1271 1270 int ret; 1272 1271 int i, j, num_limits, num_formats; 1273 1272 ··· 1329 1330 return PTR_ERR(ctx->regs); 1330 1331 1331 1332 /* resource irq */ 1332 - res = platform_get_resource(pdev, IORESOURCE_IRQ, 0); 1333 - if (!res) { 1334 - dev_err(dev, "failed to request irq resource.\n"); 1335 - return -ENOENT; 1336 - } 1333 + ret = platform_get_irq(pdev, 0); 1334 + if (ret < 0) 1335 + return ret; 1337 1336 1338 - ret = devm_request_irq(dev, res->start, fimc_irq_handler, 1339 - 0, dev_name(dev), ctx); 1337 + ret = devm_request_irq(dev, ret, fimc_irq_handler, 1338 + 0, dev_name(dev), ctx); 1340 1339 if (ret < 0) { 1341 1340 dev_err(dev, "failed to request irq.\n"); 1342 1341 return ret;
+4 -9
drivers/gpu/drm/exynos/exynos_drm_fimd.c
··· 1133 1133 struct device *dev = &pdev->dev; 1134 1134 struct fimd_context *ctx; 1135 1135 struct device_node *i80_if_timings; 1136 - struct resource *res; 1137 1136 int ret; 1138 1137 1139 1138 if (!dev->of_node) ··· 1205 1206 if (IS_ERR(ctx->regs)) 1206 1207 return PTR_ERR(ctx->regs); 1207 1208 1208 - res = platform_get_resource_byname(pdev, IORESOURCE_IRQ, 1209 - ctx->i80_if ? "lcd_sys" : "vsync"); 1210 - if (!res) { 1211 - dev_err(dev, "irq request failed.\n"); 1212 - return -ENXIO; 1213 - } 1209 + ret = platform_get_irq_byname(pdev, ctx->i80_if ? "lcd_sys" : "vsync"); 1210 + if (ret < 0) 1211 + return ret; 1214 1212 1215 - ret = devm_request_irq(dev, res->start, fimd_irq_handler, 1216 - 0, "drm_fimd", ctx); 1213 + ret = devm_request_irq(dev, ret, fimd_irq_handler, 0, "drm_fimd", ctx); 1217 1214 if (ret) { 1218 1215 dev_err(dev, "irq request failed.\n"); 1219 1216 return ret;
+3 -7
drivers/gpu/drm/exynos/exynos_drm_gsc.c
··· 1220 1220 struct gsc_driverdata *driver_data; 1221 1221 struct exynos_drm_ipp_formats *formats; 1222 1222 struct gsc_context *ctx; 1223 - struct resource *res; 1224 1223 int num_formats, ret, i, j; 1225 1224 1226 1225 ctx = devm_kzalloc(dev, sizeof(*ctx), GFP_KERNEL); ··· 1274 1275 return PTR_ERR(ctx->regs); 1275 1276 1276 1277 /* resource irq */ 1277 - res = platform_get_resource(pdev, IORESOURCE_IRQ, 0); 1278 - if (!res) { 1279 - dev_err(dev, "failed to request irq resource.\n"); 1280 - return -ENOENT; 1281 - } 1278 + ctx->irq = platform_get_irq(pdev, 0); 1279 + if (ctx->irq < 0) 1280 + return ctx->irq; 1282 1281 1283 - ctx->irq = res->start; 1284 1282 ret = devm_request_irq(dev, ctx->irq, gsc_irq_handler, 0, 1285 1283 dev_name(dev), ctx); 1286 1284 if (ret < 0) {
+6 -8
drivers/gpu/drm/exynos/exynos_mixer.c
··· 809 809 return -ENXIO; 810 810 } 811 811 812 - res = platform_get_resource(mixer_ctx->pdev, IORESOURCE_IRQ, 0); 813 - if (res == NULL) { 814 - dev_err(dev, "get interrupt resource failed.\n"); 815 - return -ENXIO; 816 - } 812 + ret = platform_get_irq(mixer_ctx->pdev, 0); 813 + if (ret < 0) 814 + return ret; 815 + mixer_ctx->irq = ret; 817 816 818 - ret = devm_request_irq(dev, res->start, mixer_irq_handler, 819 - 0, "drm_mixer", mixer_ctx); 817 + ret = devm_request_irq(dev, mixer_ctx->irq, mixer_irq_handler, 818 + 0, "drm_mixer", mixer_ctx); 820 819 if (ret) { 821 820 dev_err(dev, "request interrupt failed.\n"); 822 821 return ret; 823 822 } 824 - mixer_ctx->irq = res->start; 825 823 826 824 return 0; 827 825 }
+1 -1
drivers/gpu/drm/i915/gt/uc/intel_guc_slpc.c
··· 110 110 { 111 111 u32 request[] = { 112 112 GUC_ACTION_HOST2GUC_PC_SLPC_REQUEST, 113 - SLPC_EVENT(SLPC_EVENT_PARAMETER_UNSET, 2), 113 + SLPC_EVENT(SLPC_EVENT_PARAMETER_UNSET, 1), 114 114 id, 115 115 }; 116 116
+1 -1
drivers/gpu/drm/i915/intel_pch.c
··· 108 108 /* Comet Lake V PCH is based on KBP, which is SPT compatible */ 109 109 return PCH_SPT; 110 110 case INTEL_PCH_ICP_DEVICE_ID_TYPE: 111 + case INTEL_PCH_ICP2_DEVICE_ID_TYPE: 111 112 drm_dbg_kms(&dev_priv->drm, "Found Ice Lake PCH\n"); 112 113 drm_WARN_ON(&dev_priv->drm, !IS_ICELAKE(dev_priv)); 113 114 return PCH_ICP; ··· 124 123 !IS_GEN9_BC(dev_priv)); 125 124 return PCH_TGP; 126 125 case INTEL_PCH_JSP_DEVICE_ID_TYPE: 127 - case INTEL_PCH_JSP2_DEVICE_ID_TYPE: 128 126 drm_dbg_kms(&dev_priv->drm, "Found Jasper Lake PCH\n"); 129 127 drm_WARN_ON(&dev_priv->drm, !IS_JSL_EHL(dev_priv)); 130 128 return PCH_JSP;
+1 -1
drivers/gpu/drm/i915/intel_pch.h
··· 50 50 #define INTEL_PCH_CMP2_DEVICE_ID_TYPE 0x0680 51 51 #define INTEL_PCH_CMP_V_DEVICE_ID_TYPE 0xA380 52 52 #define INTEL_PCH_ICP_DEVICE_ID_TYPE 0x3480 53 + #define INTEL_PCH_ICP2_DEVICE_ID_TYPE 0x3880 53 54 #define INTEL_PCH_MCC_DEVICE_ID_TYPE 0x4B00 54 55 #define INTEL_PCH_TGP_DEVICE_ID_TYPE 0xA080 55 56 #define INTEL_PCH_TGP2_DEVICE_ID_TYPE 0x4380 56 57 #define INTEL_PCH_JSP_DEVICE_ID_TYPE 0x4D80 57 - #define INTEL_PCH_JSP2_DEVICE_ID_TYPE 0x3880 58 58 #define INTEL_PCH_ADP_DEVICE_ID_TYPE 0x7A80 59 59 #define INTEL_PCH_ADP2_DEVICE_ID_TYPE 0x5180 60 60 #define INTEL_PCH_ADP3_DEVICE_ID_TYPE 0x7A00