1 files changed, 19 insertions, 20 deletions

diff --git a/drivers/gpu/drm/udl/udl_transfer.c b/drivers/gpu/drm/udl/udl_transfer.c
index f343db73e095..917dcb978c2c 100644
--- a/drivers/gpu/drm/udl/udl_transfer.c
+++ b/drivers/gpu/drm/udl/udl_transfer.c
@@ -82,12 +82,14 @@ static inline u16 pixel32_to_be16(const uint32_t pixel)
                 ((pixel >> 8) & 0xf800));
 }
 
-static bool pixel_repeats(const void *pixel, const uint32_t repeat, int bpp)
+static inline u16 get_pixel_val16(const uint8_t *pixel, int bpp)
 {
+        u16 pixel_val16 = 0;
         if (bpp == 2)
-                return *(const uint16_t *)pixel == repeat;
-        else
-                return *(const uint32_t *)pixel == repeat;
+                pixel_val16 = *(const uint16_t *)pixel;
+        else if (bpp == 4)
+                pixel_val16 = pixel32_to_be16(*(const uint32_t *)pixel);
+        return pixel_val16;
 }
 
 /*
@@ -134,6 +136,7 @@ static void udl_compress_hline16(
                 uint8_t *cmd_pixels_count_byte = NULL;
                 const u8 *raw_pixel_start = NULL;
                 const u8 *cmd_pixel_start, *cmd_pixel_end = NULL;
+                uint16_t pixel_val16;
 
                 prefetchw((void *) cmd); /* pull in one cache line at least */
 
@@ -154,33 +157,29 @@ static void udl_compress_hline16(
                             (int)(cmd_buffer_end - cmd) / 2))) * bpp;
 
                 prefetch_range((void *) pixel, (cmd_pixel_end - pixel) * bpp);
+                pixel_val16 = get_pixel_val16(pixel, bpp);
 
                 while (pixel < cmd_pixel_end) {
                         const u8 *const start = pixel;
-                        u32 repeating_pixel;
-
-                        if (bpp == 2) {
-                                repeating_pixel = *(uint16_t *)pixel;
-                                *(uint16_t *)cmd = cpu_to_be16(repeating_pixel);
-                        } else {
-                                repeating_pixel = *(uint32_t *)pixel;
-                                *(uint16_t *)cmd = cpu_to_be16(pixel32_to_be16(repeating_pixel));
-                        }
+                        const uint16_t repeating_pixel_val16 = pixel_val16;
+
+                        *(uint16_t *)cmd = cpu_to_be16(pixel_val16);
 
                         cmd += 2;
                         pixel += bpp;
 
-                        if (unlikely((pixel < cmd_pixel_end) &&
-                                     (pixel_repeats(pixel, repeating_pixel, bpp)))) {
+                        while (pixel < cmd_pixel_end) {
+                                pixel_val16 = get_pixel_val16(pixel, bpp);
+                                if (pixel_val16 != repeating_pixel_val16)
+                                        break;
+                                pixel += bpp;
+                        }
+
+                        if (unlikely(pixel > start + bpp)) {
                                 /* go back and fill in raw pixel count */
                                 *raw_pixels_count_byte = (((start -
                                                 raw_pixel_start) / bpp) + 1) & 0xFF;
 
-                                while ((pixel < cmd_pixel_end) &&
-                                       (pixel_repeats(pixel, repeating_pixel, bpp))) {
-                                        pixel += bpp;
-                                }
-
                                 /* immediately after raw data is repeat byte */
                                 *cmd++ = (((pixel - start) / bpp) - 1) & 0xFF;