misaligned access measurements at different sizes

diff --git a/arch/riscv/kernel/cpufeature.c b/arch/riscv/kernel/cpufeature.c
index cc09444352b2..a92c7e60374f 100644
--- a/arch/riscv/kernel/cpufeature.c
+++ b/arch/riscv/kernel/cpufeature.c
@@ -403,11 +403,11 @@ unsigned long riscv_get_elf_hwcap(void)
        return hwcap;
 }

-void check_unaligned_access(int cpu)
+void do_check_unaligned_access(int cpu, int size)
 {
        u64 start_cycles, end_cycles;
-       u64 word_cycles;
-       u64 byte_cycles;
+       u64 word_cycles, word_cycles_worst = 0;
+       u64 byte_cycles, byte_cycles_worst = 0;
        int ratio;
        unsigned long start_jiffies, now;
        struct page *page;
@@ -428,7 +428,7 @@ void check_unaligned_access(int cpu)
        src += 2;
        word_cycles = -1ULL;
        /* Do a warmup. */
-       __riscv_copy_words_unaligned(dst, src, MISALIGNED_COPY_SIZE);
+       __riscv_copy_words_unaligned(dst, src, size);
        preempt_disable();
        start_jiffies = jiffies;
        while ((now = jiffies) == start_jiffies)
@@ -442,16 +442,19 @@ void check_unaligned_access(int cpu)
                start_cycles = get_cycles64();
                /* Ensure the CSR read can't reorder WRT to the copy. */
                mb();
-               __riscv_copy_words_unaligned(dst, src, MISALIGNED_COPY_SIZE);
+               __riscv_copy_words_unaligned(dst, src, size);
                /* Ensure the copy ends before the end time is snapped. */
                mb();
                end_cycles = get_cycles64();
                if ((end_cycles - start_cycles) < word_cycles)
                        word_cycles = end_cycles - start_cycles;
+
+               if (end_cycles - start_cycles > word_cycles_worst)
+                       word_cycles_worst = end_cycles - start_cycles;
        }

        byte_cycles = -1ULL;
-       __riscv_copy_bytes_unaligned(dst, src, MISALIGNED_COPY_SIZE);
+       __riscv_copy_bytes_unaligned(dst, src, size);
        start_jiffies = jiffies;
        while ((now = jiffies) == start_jiffies)
                cpu_relax();
@@ -459,11 +462,14 @@ void check_unaligned_access(int cpu)
        while (time_before(jiffies, now + (1 << MISALIGNED_ACCESS_JIFFIES_LG2))) {
                start_cycles = get_cycles64();
                mb();
-               __riscv_copy_bytes_unaligned(dst, src, MISALIGNED_COPY_SIZE);
+               __riscv_copy_bytes_unaligned(dst, src, size);
                mb();
                end_cycles = get_cycles64();
                if ((end_cycles - start_cycles) < byte_cycles)
                        byte_cycles = end_cycles - start_cycles;
+
+               if (end_cycles - start_cycles > byte_cycles_worst)
+                       byte_cycles_worst = end_cycles - start_cycles;
        }

        preempt_enable();
@@ -486,12 +492,24 @@ void check_unaligned_access(int cpu)
                ratio % 100,
                (speed == RISCV_HWPROBE_MISALIGNED_FAST) ? "fast" : "slow");

+printk("EVAN size 0x%x word cycles best %llx worst %llx, byte cycles best %llx worst %llx\n",
+       size, word_cycles, word_cycles_worst, byte_cycles, byte_cycles_worst);
+
        per_cpu(misaligned_access_speed, cpu) = speed;

 out:
        __free_pages(page, get_order(MISALIGNED_BUFFER_SIZE));
 }

+void check_unaligned_access(int cpu)
+{
+       do_check_unaligned_access(cpu, MISALIGNED_COPY_SIZE);
+       do_check_unaligned_access(cpu, 0x1000);
+       do_check_unaligned_access(cpu, 512);
+       do_check_unaligned_access(cpu, 256);
+       do_check_unaligned_access(cpu, 128);
+}
+
 static int check_unaligned_access_boot_cpu(void)
 {
        check_unaligned_access(0);