Commit 675008f1 authored by Jocelyn Falempe's avatar Jocelyn Falempe
Browse files

drm/panic: Use a decimal fifo to avoid u64 by u64 divide 

On 32bits ARM, u64/u64 is not supported [1], so change the algorithm
to use a simple fifo with decimal digits as u8 instead.
This is slower but should compile on all architecture.

Link: https://lore.kernel.org/dri-devel/CANiq72ke45eOwckMhWHvmwxc03dxr4rnxxKvx+HvWdBLopZfrQ@mail.gmail.com/

 [1]
Reported-by: default avatarMiguel Ojeda <ojeda@kernel.org>
Closes: https://lore.kernel.org/dri-devel/CANiq72ke45eOwckMhWHvmwxc03dxr4rnxxKvx+HvWdBLopZfrQ@mail.gmail.com/


Fixes: ccb8ce52 ("ARM: 9441/1: rust: Enable Rust support for ARMv7")
Signed-off-by: default avatarJocelyn Falempe <jfalempe@redhat.com>
Link: https://lore.kernel.org/r/20250418165059.560503-1-jfalempe@redhat.com


Acked-by: default avatarJavier Martinez Canillas <javierm@redhat.com>
parent 760e2961

drivers/gpu/drm/drm_panic_qr.rs

+48 −23
Original line number Diff line number Diff line
@@ -366,8 +366,48 @@ fn iter(&self) -> SegmentIterator<'_> { 
        SegmentIterator {

            segment: self,

            offset: 0,

            carry: 0,

            carry_len: 0,

            decfifo: Default::default(),

        }

    }

}



/// Max fifo size is 17 (max push) + 2 (max remaining)

const MAX_FIFO_SIZE: usize = 19;



/// A simple Decimal digit FIFO

#[derive(Default)]

struct DecFifo {

    decimals: [u8; MAX_FIFO_SIZE],

    len: usize,

}



impl DecFifo {

    fn push(&mut self, data: u64, len: usize) {

        let mut chunk = data;

        for i in (0..self.len).rev() {

            self.decimals[i + len] = self.decimals[i];

        }

        for i in 0..len {

            self.decimals[i] = (chunk % 10) as u8;

            chunk /= 10;

        }

        self.len += len;

    }



    /// Pop 3 decimal digits from the FIFO

    fn pop3(&mut self) -> Option<(u16, usize)> {

        if self.len == 0 {

            None

        } else {

            let poplen = 3.min(self.len);

            self.len -= poplen;

            let mut out = 0;

            let mut exp = 1;

            for i in 0..poplen {

                out += self.decimals[self.len + i] as u16 * exp;

                exp *= 10;

            }

            Some((out, NUM_CHARS_BITS[poplen]))

        }

    }

}
@@ -375,8 +415,7 @@ fn iter(&self) -> SegmentIterator<'_> { 
struct SegmentIterator<'a> {

    segment: &'a Segment<'a>,

    offset: usize,

    carry: u64,

    carry_len: usize,

    decfifo: DecFifo,

}



impl Iterator for SegmentIterator<'_> {
@@ -394,31 +433,17 @@ fn next(&mut self) -> Option<Self::Item> { 
                }

            }

            Segment::Numeric(data) => {

                if self.carry_len < 3 && self.offset < data.len() {

                    // If there are less than 3 decimal digits in the carry,

                    // take the next 7 bytes of input, and add them to the carry.

                if self.decfifo.len < 3 && self.offset < data.len() {

                    // If there are less than 3 decimal digits in the fifo,

                    // take the next 7 bytes of input, and push them to the fifo.

                    let mut buf = [0u8; 8];

                    let len = 7.min(data.len() - self.offset);

                    buf[..len].copy_from_slice(&data[self.offset..self.offset + len]);

                    let chunk = u64::from_le_bytes(buf);

                    let pow = u64::pow(10, BYTES_TO_DIGITS[len] as u32);

                    self.carry = chunk + self.carry * pow;

                    self.decfifo.push(chunk, BYTES_TO_DIGITS[len]);

                    self.offset += len;

                    self.carry_len += BYTES_TO_DIGITS[len];

                }

                match self.carry_len {

                    0 => None,

                    len => {

                        // take the next 3 decimal digits of the carry

                        // and return 10bits of numeric data.

                        let out_len = 3.min(len);

                        self.carry_len -= out_len;

                        let pow = u64::pow(10, self.carry_len as u32);

                        let out = (self.carry / pow) as u16;

                        self.carry %= pow;

                        Some((out, NUM_CHARS_BITS[out_len]))

                    }

                }

                self.decfifo.pop3()

            }

        }

    }