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-2019-09-06' of git://anongit.freedesktop.org/drm/drm

Pull drm fixes from Dave Airlie:
"Live from my friend's couch in Barcelona, latest round of drm fixes.

The command line parser regression fixes look a bit larger because
they come with selftests included for the bugs they fix. Otherwise a
single nouveau, single ingenic and single vmwgfx fix:

nouveau:
- add missing MODULE_FIRMWARE definitions

igenic:
- hardcode panel type DPI

vmwgfx:
- double free fix

core:
- command line mode parser fixes"

* tag 'drm-fixes-2019-09-06' of git://anongit.freedesktop.org/drm/drm:
drm/vmwgfx: Fix double free in vmw_recv_msg()
drm/nouveau/sec2/gp102: add missing MODULE_FIRMWAREs
drm/selftests: modes: Add more unit tests for the cmdline parser
drm/modes: Introduce a whitelist for the named modes
drm/modes: Fix the command line parser to take force options into account
drm/modes: Add a switch to differentiate free standing options
drm/ingenic: Hardcode panel type to DPI

Linus Torvalds 08d433d8 9d098a62

+202 -14
+48 -6
drivers/gpu/drm/drm_modes.c
··· 1454 1454 } 1455 1455 1456 1456 static int drm_mode_parse_cmdline_extra(const char *str, int length, 1457 + bool freestanding, 1457 1458 const struct drm_connector *connector, 1458 1459 struct drm_cmdline_mode *mode) 1459 1460 { ··· 1463 1462 for (i = 0; i < length; i++) { 1464 1463 switch (str[i]) { 1465 1464 case 'i': 1465 + if (freestanding) 1466 + return -EINVAL; 1467 + 1466 1468 mode->interlace = true; 1467 1469 break; 1468 1470 case 'm': 1471 + if (freestanding) 1472 + return -EINVAL; 1473 + 1469 1474 mode->margins = true; 1470 1475 break; 1471 1476 case 'D': ··· 1549 1542 if (extras) { 1550 1543 int ret = drm_mode_parse_cmdline_extra(end_ptr + i, 1551 1544 1, 1545 + false, 1552 1546 connector, 1553 1547 mode); 1554 1548 if (ret) ··· 1677 1669 return 0; 1678 1670 } 1679 1671 1672 + static const char *drm_named_modes_whitelist[] = { 1673 + "NTSC", 1674 + "PAL", 1675 + }; 1676 + 1677 + static bool drm_named_mode_is_in_whitelist(const char *mode, unsigned int size) 1678 + { 1679 + int i; 1680 + 1681 + for (i = 0; i < ARRAY_SIZE(drm_named_modes_whitelist); i++) 1682 + if (!strncmp(mode, drm_named_modes_whitelist[i], size)) 1683 + return true; 1684 + 1685 + return false; 1686 + } 1687 + 1680 1688 /** 1681 1689 * drm_mode_parse_command_line_for_connector - parse command line modeline for connector 1682 1690 * @mode_option: optional per connector mode option ··· 1749 1725 * bunch of things: 1750 1726 * - We need to make sure that the first character (which 1751 1727 * would be our resolution in X) is a digit. 1752 - * - However, if the X resolution is missing, then we end up 1753 - * with something like x<yres>, with our first character 1754 - * being an alpha-numerical character, which would be 1755 - * considered a named mode. 1728 + * - If not, then it's either a named mode or a force on/off. 1729 + * To distinguish between the two, we need to run the 1730 + * extra parsing function, and if not, then we consider it 1731 + * a named mode. 1756 1732 * 1757 1733 * If this isn't enough, we should add more heuristics here, 1758 1734 * and matching unit-tests. 1759 1735 */ 1760 - if (!isdigit(name[0]) && name[0] != 'x') 1736 + if (!isdigit(name[0]) && name[0] != 'x') { 1737 + unsigned int namelen = strlen(name); 1738 + 1739 + /* 1740 + * Only the force on/off options can be in that case, 1741 + * and they all take a single character. 1742 + */ 1743 + if (namelen == 1) { 1744 + ret = drm_mode_parse_cmdline_extra(name, namelen, true, 1745 + connector, mode); 1746 + if (!ret) 1747 + return true; 1748 + } 1749 + 1761 1750 named_mode = true; 1751 + } 1762 1752 1763 1753 /* Try to locate the bpp and refresh specifiers, if any */ 1764 1754 bpp_ptr = strchr(name, '-'); ··· 1810 1772 if (named_mode) { 1811 1773 if (mode_end + 1 > DRM_DISPLAY_MODE_LEN) 1812 1774 return false; 1775 + 1776 + if (!drm_named_mode_is_in_whitelist(name, mode_end)) 1777 + return false; 1778 + 1813 1779 strscpy(mode->name, name, mode_end + 1); 1814 1780 } else { 1815 1781 ret = drm_mode_parse_cmdline_res_mode(name, mode_end, ··· 1853 1811 extra_ptr != options_ptr) { 1854 1812 int len = strlen(name) - (extra_ptr - name); 1855 1813 1856 - ret = drm_mode_parse_cmdline_extra(extra_ptr, len, 1814 + ret = drm_mode_parse_cmdline_extra(extra_ptr, len, false, 1857 1815 connector, mode); 1858 1816 if (ret) 1859 1817 return false;
+2 -3
drivers/gpu/drm/ingenic/ingenic-drm.c
··· 656 656 return ret; 657 657 } 658 658 659 - if (panel) { 659 + if (panel) 660 660 bridge = devm_drm_panel_bridge_add(dev, panel, 661 - DRM_MODE_CONNECTOR_Unknown); 662 - } 661 + DRM_MODE_CONNECTOR_DPI); 663 662 664 663 priv->dma_hwdesc = dma_alloc_coherent(dev, sizeof(*priv->dma_hwdesc), 665 664 &priv->dma_hwdesc_phys,
+12
drivers/gpu/drm/nouveau/nvkm/subdev/secboot/gp102.c
··· 190 190 MODULE_FIRMWARE("nvidia/gp102/sec2/desc.bin"); 191 191 MODULE_FIRMWARE("nvidia/gp102/sec2/image.bin"); 192 192 MODULE_FIRMWARE("nvidia/gp102/sec2/sig.bin"); 193 + MODULE_FIRMWARE("nvidia/gp102/sec2/desc-1.bin"); 194 + MODULE_FIRMWARE("nvidia/gp102/sec2/image-1.bin"); 195 + MODULE_FIRMWARE("nvidia/gp102/sec2/sig-1.bin"); 193 196 MODULE_FIRMWARE("nvidia/gp104/acr/bl.bin"); 194 197 MODULE_FIRMWARE("nvidia/gp104/acr/unload_bl.bin"); 195 198 MODULE_FIRMWARE("nvidia/gp104/acr/ucode_load.bin"); ··· 213 210 MODULE_FIRMWARE("nvidia/gp104/sec2/desc.bin"); 214 211 MODULE_FIRMWARE("nvidia/gp104/sec2/image.bin"); 215 212 MODULE_FIRMWARE("nvidia/gp104/sec2/sig.bin"); 213 + MODULE_FIRMWARE("nvidia/gp104/sec2/desc-1.bin"); 214 + MODULE_FIRMWARE("nvidia/gp104/sec2/image-1.bin"); 215 + MODULE_FIRMWARE("nvidia/gp104/sec2/sig-1.bin"); 216 216 MODULE_FIRMWARE("nvidia/gp106/acr/bl.bin"); 217 217 MODULE_FIRMWARE("nvidia/gp106/acr/unload_bl.bin"); 218 218 MODULE_FIRMWARE("nvidia/gp106/acr/ucode_load.bin"); ··· 236 230 MODULE_FIRMWARE("nvidia/gp106/sec2/desc.bin"); 237 231 MODULE_FIRMWARE("nvidia/gp106/sec2/image.bin"); 238 232 MODULE_FIRMWARE("nvidia/gp106/sec2/sig.bin"); 233 + MODULE_FIRMWARE("nvidia/gp106/sec2/desc-1.bin"); 234 + MODULE_FIRMWARE("nvidia/gp106/sec2/image-1.bin"); 235 + MODULE_FIRMWARE("nvidia/gp106/sec2/sig-1.bin"); 239 236 MODULE_FIRMWARE("nvidia/gp107/acr/bl.bin"); 240 237 MODULE_FIRMWARE("nvidia/gp107/acr/unload_bl.bin"); 241 238 MODULE_FIRMWARE("nvidia/gp107/acr/ucode_load.bin"); ··· 259 250 MODULE_FIRMWARE("nvidia/gp107/sec2/desc.bin"); 260 251 MODULE_FIRMWARE("nvidia/gp107/sec2/image.bin"); 261 252 MODULE_FIRMWARE("nvidia/gp107/sec2/sig.bin"); 253 + MODULE_FIRMWARE("nvidia/gp107/sec2/desc-1.bin"); 254 + MODULE_FIRMWARE("nvidia/gp107/sec2/image-1.bin"); 255 + MODULE_FIRMWARE("nvidia/gp107/sec2/sig-1.bin");
+7
drivers/gpu/drm/selftests/drm_cmdline_selftests.h
··· 9 9 10 10 #define cmdline_test(test) selftest(test, test) 11 11 12 + cmdline_test(drm_cmdline_test_force_d_only) 13 + cmdline_test(drm_cmdline_test_force_D_only_dvi) 14 + cmdline_test(drm_cmdline_test_force_D_only_hdmi) 15 + cmdline_test(drm_cmdline_test_force_D_only_not_digital) 16 + cmdline_test(drm_cmdline_test_force_e_only) 17 + cmdline_test(drm_cmdline_test_margin_only) 18 + cmdline_test(drm_cmdline_test_interlace_only) 12 19 cmdline_test(drm_cmdline_test_res) 13 20 cmdline_test(drm_cmdline_test_res_missing_x) 14 21 cmdline_test(drm_cmdline_test_res_missing_y)
+130
drivers/gpu/drm/selftests/test-drm_cmdline_parser.c
··· 17 17 18 18 static const struct drm_connector no_connector = {}; 19 19 20 + static int drm_cmdline_test_force_e_only(void *ignored) 21 + { 22 + struct drm_cmdline_mode mode = { }; 23 + 24 + FAIL_ON(!drm_mode_parse_command_line_for_connector("e", 25 + &no_connector, 26 + &mode)); 27 + FAIL_ON(mode.specified); 28 + FAIL_ON(mode.refresh_specified); 29 + FAIL_ON(mode.bpp_specified); 30 + 31 + FAIL_ON(mode.rb); 32 + FAIL_ON(mode.cvt); 33 + FAIL_ON(mode.interlace); 34 + FAIL_ON(mode.margins); 35 + FAIL_ON(mode.force != DRM_FORCE_ON); 36 + 37 + return 0; 38 + } 39 + 40 + static int drm_cmdline_test_force_D_only_not_digital(void *ignored) 41 + { 42 + struct drm_cmdline_mode mode = { }; 43 + 44 + FAIL_ON(!drm_mode_parse_command_line_for_connector("D", 45 + &no_connector, 46 + &mode)); 47 + FAIL_ON(mode.specified); 48 + FAIL_ON(mode.refresh_specified); 49 + FAIL_ON(mode.bpp_specified); 50 + 51 + FAIL_ON(mode.rb); 52 + FAIL_ON(mode.cvt); 53 + FAIL_ON(mode.interlace); 54 + FAIL_ON(mode.margins); 55 + FAIL_ON(mode.force != DRM_FORCE_ON); 56 + 57 + return 0; 58 + } 59 + 60 + static const struct drm_connector connector_hdmi = { 61 + .connector_type = DRM_MODE_CONNECTOR_HDMIB, 62 + }; 63 + 64 + static int drm_cmdline_test_force_D_only_hdmi(void *ignored) 65 + { 66 + struct drm_cmdline_mode mode = { }; 67 + 68 + FAIL_ON(!drm_mode_parse_command_line_for_connector("D", 69 + &connector_hdmi, 70 + &mode)); 71 + FAIL_ON(mode.specified); 72 + FAIL_ON(mode.refresh_specified); 73 + FAIL_ON(mode.bpp_specified); 74 + 75 + FAIL_ON(mode.rb); 76 + FAIL_ON(mode.cvt); 77 + FAIL_ON(mode.interlace); 78 + FAIL_ON(mode.margins); 79 + FAIL_ON(mode.force != DRM_FORCE_ON_DIGITAL); 80 + 81 + return 0; 82 + } 83 + 84 + static const struct drm_connector connector_dvi = { 85 + .connector_type = DRM_MODE_CONNECTOR_DVII, 86 + }; 87 + 88 + static int drm_cmdline_test_force_D_only_dvi(void *ignored) 89 + { 90 + struct drm_cmdline_mode mode = { }; 91 + 92 + FAIL_ON(!drm_mode_parse_command_line_for_connector("D", 93 + &connector_dvi, 94 + &mode)); 95 + FAIL_ON(mode.specified); 96 + FAIL_ON(mode.refresh_specified); 97 + FAIL_ON(mode.bpp_specified); 98 + 99 + FAIL_ON(mode.rb); 100 + FAIL_ON(mode.cvt); 101 + FAIL_ON(mode.interlace); 102 + FAIL_ON(mode.margins); 103 + FAIL_ON(mode.force != DRM_FORCE_ON_DIGITAL); 104 + 105 + return 0; 106 + } 107 + 108 + static int drm_cmdline_test_force_d_only(void *ignored) 109 + { 110 + struct drm_cmdline_mode mode = { }; 111 + 112 + FAIL_ON(!drm_mode_parse_command_line_for_connector("d", 113 + &no_connector, 114 + &mode)); 115 + FAIL_ON(mode.specified); 116 + FAIL_ON(mode.refresh_specified); 117 + FAIL_ON(mode.bpp_specified); 118 + 119 + FAIL_ON(mode.rb); 120 + FAIL_ON(mode.cvt); 121 + FAIL_ON(mode.interlace); 122 + FAIL_ON(mode.margins); 123 + FAIL_ON(mode.force != DRM_FORCE_OFF); 124 + 125 + return 0; 126 + } 127 + 128 + static int drm_cmdline_test_margin_only(void *ignored) 129 + { 130 + struct drm_cmdline_mode mode = { }; 131 + 132 + FAIL_ON(drm_mode_parse_command_line_for_connector("m", 133 + &no_connector, 134 + &mode)); 135 + 136 + return 0; 137 + } 138 + 139 + static int drm_cmdline_test_interlace_only(void *ignored) 140 + { 141 + struct drm_cmdline_mode mode = { }; 142 + 143 + FAIL_ON(drm_mode_parse_command_line_for_connector("i", 144 + &no_connector, 145 + &mode)); 146 + 147 + return 0; 148 + } 149 + 20 150 static int drm_cmdline_test_res(void *ignored) 21 151 { 22 152 struct drm_cmdline_mode mode = { };
+3 -5
drivers/gpu/drm/vmwgfx/vmwgfx_msg.c
··· 353 353 !!(HIGH_WORD(ecx) & MESSAGE_STATUS_HB)); 354 354 if ((HIGH_WORD(ebx) & MESSAGE_STATUS_SUCCESS) == 0) { 355 355 kfree(reply); 356 - 356 + reply = NULL; 357 357 if ((HIGH_WORD(ebx) & MESSAGE_STATUS_CPT) != 0) { 358 358 /* A checkpoint occurred. Retry. */ 359 359 continue; ··· 377 377 378 378 if ((HIGH_WORD(ecx) & MESSAGE_STATUS_SUCCESS) == 0) { 379 379 kfree(reply); 380 - 380 + reply = NULL; 381 381 if ((HIGH_WORD(ecx) & MESSAGE_STATUS_CPT) != 0) { 382 382 /* A checkpoint occurred. Retry. */ 383 383 continue; ··· 389 389 break; 390 390 } 391 391 392 - if (retries == RETRIES) { 393 - kfree(reply); 392 + if (!reply) 394 393 return -EINVAL; 395 - } 396 394 397 395 *msg_len = reply_len; 398 396 *msg = reply;