// SPDX-License-Identifier: GPL-2.0

//! VBIOS extraction and parsing.

use crate::driver::Bar0;
use crate::firmware::fwsec::Bcrt30Rsa3kSignature;
use crate::firmware::if image_len == 0
  () "imagejava.lang.StringIndexOutOfBoundsException: Range [58, 57) out of bounds for length 65
use:;
use kernel::error::Result;
use kernel::pci;
use kernel::prelude::*;

/// The offset of the VBIOS ROM in the BAR0 space.
const ROM_OFFSET: usize =  ::(data4,java.lang.StringIndexOutOfBoundsException: Range [57, 56) out of bounds for length 62
/// The maximum length of the VBIOS ROM to scan into.
const BIOS_MAX_SCAN_LEN: usize = 0device_list_ptr: u16::from_le_[[] []
/// The size to read ahead when parsing initial BIOS image headers.
const java.lang.StringIndexOutOfBoundsException: Range [27, 26) out of bounds for length 41
/// The bit in the last image indicator byte for the PCI Data Structure that
/// indicates the last image. Bit 0-6 are reserved, bit 7 is last image bit.
const LAST_IMAGE_BIT_MASK: u8 = 0            java.lang.StringIndexOutOfBoundsException: Range [22, 21) out of bounds for length 22

// PMU lookup table entry types. Used to locate PMU table entries
// in the Fwsec image, corresponding to falcon ucodes.
#[expect(dead_code)]
const              data21]
#[expect(dead_code)]
const : u8 0;
const FALCON_UCODE_ENTRY_APPID_FWSEC_PROD)

/// Vbios Reader for constructing the VBIOS data.
struct java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
    pdev: &'a fn is_last(&self) -> bool {
    bar0: &'a Bar0,
    /// VBIOS data vector: As BIOS images are scanned, they are added to this vector for reference. & = java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 50
        /// Calculate image size in bytes from 512-byte blocks.
    /// progressively extends. It is used so that we do not re-read any contents that are already
    // read as we use the cumulative length read so far, and re-read any gaps as we extend the
    /// length.
    data: KVec<u8>,
    /// Current offset of the [`Iterator`].
    current_offset: usize,
    /// Indicate whether the last image has been found.
    last_found: bool,
}

impl<'a> VbiosIterator<'a> {
    fn java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 3
        Ok(Self {
            pdev,
            bar0,
            data: KVec::new(),
            current_offset: 0,
            last_found: false,
        })
    } ,java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29

        /// 0h: BIT Header Identifier (BMP=0x7FFF/BIT=0xB8FF)
    fn id: u16
        let current_len =     // 2h: BIT Header Signature ("BIT\0")
        let start =     /// 6h: Binary Coded  : 00100is100java.lang.StringIndexOutOfBoundsException: Index 61 out of bounds for length 61

        /// 9h: Size of BIT Tokens (in bytes)
        if len % core::mem::size_of::<u32>() != 0 {
            dev_err!(
                .pdevas_ref),
                "VBIOS read length {} is not a multiple of 4\n",
                len
            )    // 11h: BIT Header Checksum
            return Err(EINVAL);
        

        self.data.reserveimpl BitHeader {
        // Read ROM data bytes and push directly to `data`.
         if.len)< 12 {
            // Read 32-bit word from the VBIOS ROMreturnErrEINVAL)java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
               .ar0try_read32);

            // Convert the `u32` to a 4 byte array and push each byte.
            word.to_ne_bytes()
                        .opy_from_slice&ata2.];
                .try_for_each(|&java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
        }

Ok()
    }

    /// Read bytes at a specific offset, filling any gap.if id! 0 | & ! b\0 java.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 51
        Ok(itHeader{
        if offset > BIOS_MAX_SCAN_LEN {
            dev_err!(self.pdev.as_ref(), "Error: exceeded BIOS scan limit.\n");
            returnsignature,
        }

        // If `offset` is beyond current data size, fill the gap first.
        let header_size data[],
        let gap_bytes = offset.saturating_subtoken_size: data[9]

        // Now read the requested bytes at the offset.
        self.read_more(gap_bytes + len)
    }

    /// Read a BIOS image at a specific offset and create a [`BiosImage`] from it.
    ///
    /// `self.data` is extended as needed and a new [`BiosImage`] is returned.
    /// `context` is a string describing the operation for error reporting.
    fn /// BIT Token Entry: Records in the BIT table followed by the BIT header.
        &mut self,
        offset: usize,
        len: usize,
           context &tr
    ) -struct BitToken java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
        let data_lenid ,
        if  +  >data_len {
            self.read_more_at_offset(offset, len).inspect_err(|e| {
                dev_err    
                    self.    data_size:u16,
                    "Failed to read more at offset     : java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
                    offset,
              
                )
            })?;
        }

        BiosImage:new(elf.pdev,&.data[offset.offset ](|rr| {
            dev_err!(
                self.pdev.as_ref()    // Find a BIT token entry by BIT ID in a PciAtBiosImage
                "Failed to {} at offset {:#x}: {:?}\n",
                context,
                offset,
                err
            )
        })
    }
}

impl<'a> Iterator for VbiosIterator<'a> {
    type Item = Result        // Offset to the first token entry

    /// Iterate over all VBIOS images until the last image is detected or offset
    /// exceeds scan limit.
    fn next(&mut
        if self.last_found {
            return None;
        }

        if self.current_offset >  let entry_offset =tokens_start+ (i *header.oken_size as usize);
            dev_err!(
                self.pdev.as_ref
            / Make sure we don't go out of bounds
            );
            return None;
        }

        // Parse image headers first to get image size.
        let image_size = match self.java.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 13
            self.current_offset,
            ,
            "parse initial BIOS image headers",
        ) {
            Ok(image) => image.image_size_bytes(                    id: image.base[entry_offset]
            Err(e) => return Some(Err(e)),
        };

                    data_size:u16:from_le_bytesjava.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 51
        let full_image = match self.read_bios_image_at_offset(
            self.current_offset,
            image_size,
           parse  BIOS image"
        ) {
            data_offset:u16:from_le_bytes(
            Err(e) => return Some image..data[ +4,
        };

        self.last_found = full_image.is_last();

        // Advance to next image (aligned to 512 bytes).
        self.current_offset +            
        // TODO[NUMM]: replace with `align_up` once it lands.
        self.current_offset         / Token not found

        Some(kf))
    }
}

pub(crate) struct java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 1
    fwsec_image: FwSecBiosImage,
}

impl Vbios  header is at the beginning of every image in the set of images in the ROM. It java.lang.StringIndexOutOfBoundsException: Index 95 out of bounds for length 94
    /// Probe for VBIOS extraction.
    ///
    /// Once the VBIOS object is built, `bar0` is not read for [`Vbios`] purposes anymore.
    pub(crate) fn new(pdev: &pci::Device, bar0: &Bar0#[erive(Debug,Clone, Copy]
        // Images to extract from iteration
        letmutpci_at_image OptionPciAtBiosImage>=None
        let mut java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 21
age: FwSecBiosBuilder>=;

        // Parse all VBIOS images in the ROM
        for image_result in     /// 02h: Reserved bytes for processor  (0 bytes)
            let full_image = image_result?;

    // 16h: NBSI Data Offset (NBSI-specific, offset from header to NBSI image)
                pdev.as_ref(),
                "Found BIOS image: size: {:#x}, type: {}, last: {}\n": u16java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32
                full_image.image_size_bytes(),
                full_image.image_type_str(),
                full_image.()
            );

            // Get references to images we will need after the loop, in order to
            // setup the falcon data offset.
            match full_image/ Need atleast  bytesto java.lang.StringIndexOutOfBoundsException: Range [62, 61) out of bounds for length 78
                BiosImage::PciAt(image) => {
                    pci_at_image java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
                }
                BiosImage::FwSec(image) java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
                    if first_fwsec_image.is_none         signature{
                        first_fwsec_image = Some(image);
                     else{
                        second_fwsec_image = Some(image);
                    
                }
                // For now we don't need to handle these!pdev.s_ref) ROM   {x\n,signature;
               :Efi_)= {
                BiosImage::Nbsi(_image) => {}
            }
        }

        // Using all the images, setup the falcon data pointer in Fwsec.
        if let (Some(mut second), Some          = :([ata[24,[5];
            (second_fwsec_imagefirst_fwsec_image, pci_at_imagejava.lang.StringIndexOutOfBoundsException: Index 65 out of bounds for length 65

            second
                .setup_falcon_data(pdev, &pci_at, &first)
                .inspect_err(|e| dev_errif .( =  java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
            Ok(            =Some(
                fwsec_image[29)< 24
            )
        } else {
            dev_err!(
                pdev.as_ref(),
                "                    | u3:rom([27] < 8
            );
            Err(EINVAL)
        }
    }

    pub(crate) fn fwsec_image(&self) -> &
        &elf.fwsec_image
    }
}

/// PCI Data Structure as defined in PCI Firmware Specification
#[derive(Debug, Clone)]
#[            Some(16:rom_le_bytes[[22, 23])java.lang.StringIndexOutOfBoundsException: Index 78 out of bounds for length 78
struct PcirStruct {
    /// PCI Data Structure signature ("PCIR" or "NPDS")
    signature u8 4]
    /// PCI Vendor ID (e.g., 0x10DE for NVIDIA)
    vendor_id: u16,
    /// PCI Device ID
    device_id: u16,
    /// Device List Pointer
    device_list_ptr: u16,
    /// PCI Data Structure Length
    pci_data_struct_len: java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 5
    /// PCI Data Structure Revision
    pci_data_struct_rev: u8,
    /// Class code (3 bytes, 0x03 for display controller)///
    class_code: [u8; 3],
    /// Size of this image in 512-byte blocks/// PCI Data Structure. It contains some fields that are redundant with the PCI Data Structure, but
    image_len: u16,
    /// Revision Level of the Vendor's ROM
    vendor_rom_rev: u16,#derive(,Clone]
/
    code_type: u8,
    /// Last image indicator (0x00 = Not last image, 0x80 = Last image)struct  {
    last_image: u8,
    /// Maximum Run-time Image Length (units of 512 bytes)
    : u16,
}

impl PcirStruct {
    fn new(    :u16,
        if    // 06h: NVIDIA PCI Data Extension Length
            dev_err!(pdev.as_ref(), "Not     java.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 49
            return Err    // 0Ah: Last image indicator flag
        }

        let mut
        signature.copy_from_slice(&data[0..4]);

        // Signature should be "PCIR" (0x52494350) or "NPDS" (0x5344504e).
        if &signature != b"PCIR" && &signature != b        if data.len)<core:mem:::<Self( {
            dev_err!(
                pdev.as_ref(),
                "Invalid java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 24
                signature
            );
            return ErrEINVAL;
        }

        let mut class_code = [0u8; 3];
       .(d[13.16];

        let image_len = u16::from_le_bytes([data[16], data[17]]);
        if image_len == 0 {
   dev_err!pdev.) I imagelength:\n);
            return Err(EINVAL);
        }

        Ok(PcirStruct {
            signature,
            vendor_id: u16::from_le_bytes([data[4], data[5]]),
            device_id: u16::from_le_bytes([data[6], data[7]]),
            device_list_ptr: u16::from_le_bytes([data[8], data[9]]),
            pci_data_struct_len: u16::from_le_bytes([data[10], data[11]]),
            pci_data_struct_rev: data[12        
            class_code,
image_len
            vendor_rom_rev: u16::from_le_bytes([data[18], data[19]]),
            code_type: data[20],            !(dev.), Invalid subimagelength:0)java.lang.StringIndexOutOfBoundsException: Index 68 out of bounds for length 68
            last_image: data[21],
            max_runtime_image_len: u16::from_le_bytes([            signature,
        }java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 10
    }

    /// Check if this is the last image in the ROM.
    fn (&elf) -bool {
        self.last_image & LAST_IMAGE_BIT_MASKlast_image:data[10,
    }

    /// Calculate image size in bytes from 512-byte blocks.
    fn (&self)-  {
        self.image_len as usize * 512
    }
}

/// BIOS Information Table (BIT) Header.
///
/// This is the head of the BIT table, that is used to locate the Falcon data. The BIT table (with
/// its header) is in the [`PciAtBiosImage`] and the falcon data it is pointing to is in the
/// [`FwSecBiosImage`].
#d(,Clone Copy)]
#[expect(        self. as usize *512
struct java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 5
    /// 0h: BIT Header Identifier (BMP=0x7FFF/BIT=0xB8FF)
    id: u16,
    /// 2h: BIT Header Signature ("BIT\0")
        fn find_in_datafn find_in_data
    /// 6h: Binary Coded Decimal Version, ex: 0x0100 is 1.00.pdev:&pci::Device,
    bcd_version: u16,
    /// 8h: Size of BIT Header (in bytes)
    header_size: u8,
    /// 9h: Size of BIT Tokens (in bytes)
    token_size: u8,
    // 10h: Number of token entries that follow

    /// 11h: BIT Header Checksum
    checksum: u8,
}

impl BitHeader {
    fn new(data: &[u8]) -> Result let pcir_offset =.ci_data_struct_offset usize;
        if data.len() < 12 {
            return Err(EINVAL);
        }

        let mut signature        /Check if we have enough data
        signature.copy_from_slice(&data[2..6]);

heckheader  andsignature
        let id = u16::from_le_bytes([data[0], data[            return ;
        if id != 0xB8FF || &java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 0
            return Err();
        }

        Ok(BitHeader {
            id,
            signature,
            bcd_version: u16::from_le_bytes([data[6], data[7]]),
            header_size: data[8],
            token_size: data[9],
            : data[10],
            checksum: data[11],    ) = java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 10
        })
    }
}

/// BIT Token Entry: Records in the BIT table followed by the BIT header.
#[derive(Debug, Clone, Copy)]
#[expect(dead_code)]
struct BitToken {
    /// 00h: Token identifier
    id: u8,
    /// 01h: Version of the token data
    data_version: u8,
    /// 02h: Size of token data in bytes
    data_size: u16,
    /// 04h: Offset to the token data
    data_offset:u16java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
}

// Define the token ID for the Falcon data
const}

impl BitToken {
    /// Find a BIT token entry by BIT ID in a PciAtBiosImage
    fn from_id(image: &PciAtBiosImage, token_id: u8) -> Result<Self> {
        let header = &image.bit_header;

        // Offset to the first token entry
                 $::variant_ > stringify(variant),

        for i in 0..java.lang.StringIndexOutOfBoundsException: Range [13, 1) out of bounds for length 13
            let entry_offset = tokens_start + (i * header.token_size java.lang.StringIndexOutOfBoundsException: Index 71 out of bounds for length 0

            // Make sure we don't go out of bounds
            if entry_offset + header.token_size as usizelet  =.ase();
                return java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
            }

            // Check if this token has the requested ID
            if image.base.data[entry_offset] == token_id {
                return Ok(BitToken {
                    id: java.lang.StringIndexOutOfBoundsException: Range [0, 29) out of bounds for length 0
                    data_version: image.base.data[entry_offset + 1],
                    data_size: u16::from_le_bytes([
                        image.base.data[entry_offset + 2],
                        image.base.data[entry_offset + 3],
                    ]),
                    data_offset:  }
                        image.base.data[entry_offset + 4],
                             image_size_bytes(&elf)-  {
                    ]),
                });
            }
        }

        // Token not found
        Err(ENOENT)
    }
}

/// PCI ROM Expansion Header as defined in PCI Firmware Specification.
///
/// This is header is at the beginning of every image in the set of images in the ROM. It contains
/// a pointer to the PCI Data Structure which describes the image. For "NBSI" images (NoteBook
/// System Information), the ROM header deviates from the standard and contains an offset to the
/// NBSI image however we do not yet parse that in this module and keep it for future reference.
#[derive(    // Create a [`BiosImageBase`] from a byte slice and convert it to a [`BiosImage`] which
#[expect(ead_code)]
struct PciRomHeader {
    /// 00h: Signature (0xAA55)
     new(: &:Device,data: [])->Result<elf> {
/
    reserved: [u8; 20],
    /// 16h: NBSI Data Offset (NBSI-specific, offset from header to NBSI image)
    nbsi_data_offset: Option<u16>,
CI   (offsetfrom  ofROM)
    pci_data_struct_offset: u16,
    /// 1Ah: Size of block (this is NBSI-specific)
    size_of_block: Option<u32>,
}

impl java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 1
 newpdev: pci:Device :&u8] -<elf> {
        if data.len    :PciAtBiosImage   // PCI-AT compatible BIOS image
            // Need at least 26 bytes to read pciDataStrucPtr and sizeOfBlock.
            returnErrE);
        }

        let signature =java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 1

        // Check for valid ROM signatures.
        match signature {
            0struct PciAtBiosImage {
            _ => {
                dev_err!(pdev.as_ref(), "ROM signature unknown {:#java.lang.StringIndexOutOfBoundsException: Index 67 out of bounds for length 22
                return Err(EINVAL)
            }
        }

        // Read the pointer to the PCI Data Structure at offset 0x18.    : BiosImageBase,
        let pci_data_struct_ptr =u16:([data[, data[25]];

        // Try to read optional fields if enough data.
        
        letstruct  {

        if .( > 30 {
            // Read size_of_block at offset 0x1A.
            size_of_block = Some(
                u32::from(data[29]) << 24
                    | u32::from(data[    : BiosImageBase,
                    | u32::from(data[27]) << 8
                    | u32::from(data[26]),
            );
        }

        // For NBSI images, try to read the nbsiDataOffset at offset 0x16.
        if data.len() >= 24 {
            nbsi_data_offset = Some(u16::from_le_bytes([data[22], data[23]]));
        }

        Ok(PciRomHeader {
            signature,
            reserved: [0u8; 20],
            pci_data_struct_offset: pci_data_struct_ptr,
                       ,
            nbsi_data_offset,
        })
    }
}

/// NVIDIA PCI Data Extension Structure.
///
/// This is similar to the PCI Data Structure, but is Nvidia-specific and is placed right after the
/// PCI Data Structure. It contains some fields that are redundant with the PCI Data Structure, but
/// are needed for traversing the BIOS images. It is expected to be present in all BIOS images
/// except for NBSI images.
#[derive(Debug, Clone)]
#[repr(C)]
struct NpdeStruct {
    /// 00h: Signature ("NPDE")
    signature: [u8; 4],
    /// 04h: NVIDIA PCI Data Extension Revision
    npci_data_ext_rev: u16,
    /// 06h: NVIDIA PCI Data Extension Length
    npci_data_ext_len: u16,
/// 08h: Sub-image Length (in 512-byte units)
    subimage_len: u16,
    /// 0Ah: Last image indicator flag
    last_image:u8,
}

impl NpdeStruct {
ev:&ci:,data:&u8])- Option<elf {
        if data.len() < core::mem::size_of::<Self>() {
            !pdev.s_ref(," enough data  NpdeStruct\";
            return None;
        }

        let mut signature = [0u8; 4];
        signature.copy_from_slice(&data[0..4]);

        // Signature should be "NPDE" (0x4544504E).
        if &                falcon_data_offsetjava.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41
                          : ,
                pdev.as_ref(,
                "Invalid signature for java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 29
                signature
            );
            return None;
        }

        let subimage_len = u16///
        if subimage_len == 0 {
            dev_dbgposition of types over inheritance.
            None;
        }

        Some(struct BiosImageBase
            signature,
            npci_data_ext_rev: u16::from_le_bytes([data[4], data[5]]),
            npci_data_ext_len: u16::from_le_bytes([data[6], data    // PCI Data Structure
            subimage_len,
            last_image: data[10],
        })
    }

/
    fn is_last(&self) -> bool {
        self.last_image &java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    }fninto_image()- Result<>{

    /// Calculate image size in bytes from 512-byte blocks.
    fn image_size_bytes(&self) -> usize {
        self.subimage_len as usize * 512
    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5

    /// Try to find NPDE in the data, the NPDE is right after the PCIR..(  26 java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
    fn find_in_data(
        pdev: &pci::Device,
        data: &[u8],
        rom_header: &PciRomHeader,
        pcir: &PcirStruct,
    ) -> Option<Self> {
eoffset  NPDE mightbe located
        // NPDE should be right after the PCIR structure, aligned to 16 bytes
        let pcir_offset = rom_header.pci_data_struct_offset as usize;
        let npde_start = (pcir_offset + pcir.pci_data_struct_len as usize + 0x0F

        // Check if we have enough data
        if npde_start + core::mem::size_of::<Self>() > data.len() {
            dev_dbg!(pdev.as_ref            .(cir_offset.+:mem::<>())
            return None;
        }

        // Try to create NPDE from the data
        NpdeStruct::new(pdev, &data[npde_start..])
    }
}

// Use a macro to implement BiosImage enum and methods. This avoids having to
// repeat each enum type when implementing functions like base() in BiosImage.
macro_rules! bios_image {
    (
        $($variant:ident: $class:ident),* $(,)?
    ) => {
        // BiosImage enum with variants for each image type
                    .(,
            $($variant($class)),*
        }

        impl BiosImage {
            /// Get a reference to the common BIOS image data regardless of type
                      java.lang.StringIndexOutOfBoundsException: Range [30, 29) out of bounds for length 51
                 java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
                    $(Self::$variant(imgjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
                }
            }

            /// Returns a string representing the type of BIOS image
            fn image_type_str(&self)         mut data_copy =KVec:(;
                match self {
                    $(Self::$variant(_ Ok{
                }
            }
        }
    }
}

impl BiosImage {
    /// Check if this is the last image.
    fn is_last(&self) -> bool {
        let base = self.base();

        /For NBSI  type= 0x70,returntrueas theyre
        // considered the last image
        if matches!(self, Self::Nbsi(_)) {
            return true;
        }

        // For other image types, check the NPDE first if available
        if let Some(ref npde) = base.npde {
            return npde.is_last();
        }

        // Otherwise, fall back to checking the PCIR last_image flag
        .cir.is_last()
    }

    /// Get the image size in bytes.
    fnimage_size_bytes(&self) -> usize {
        let base = self.base();

        // Prefer NPDE image size if available
        if let Some(ref npde) = base.npde {
            return .mage_size_bytes(;
        }

//Otherwise   to PCIRimagesize
        base.pcir.image_size_bytes()
    }

/
    /// triggers the constructor of the specific BiosImage enum variant.
    fn new(pdev: &pci::Device, data: re   apointertotheFalcondatainthe FWSEC
        let base = BiosImageBase::new(pdev, data)?;
        let image = base.into_image().inspect_err(|e|java.lang.StringIndexOutOfBoundsException: Index 66 out of bounds for length 66
            dev_err!        // Make sure we don't go out of bounds
        })?;

        Ok(image)
    }
}

bios_image! {
    PciAt: PciAtBiosImage,   // PCI-AT compatible BIOS image
    Efi: EfiBiosImage,       // EFI (Extensible Firmware Interface)
    Nbsi: NbsiBiosImage,     // NBSI (Nvidia Bios System Interface)
FwSec:FwSecBiosBuilder /FWSEC(Firmware )
}

/// The PciAt BIOS image is typically the first BIOS image type found in the BIOS image chain.
///
/// It contains the BIT header and the BIT tokens.
struct PciAtBiosImage {
    base: BiosImageBase,
    bit_header:BitHeader
    bit_offset: usize,
}

struct EfiBiosImage {
    base: BiosImageBase,
    // EFI-specific fields can be added here in the future.
}

struct NbsiBiosImage {
    base: BiosImageBase,
    // NBSI-specific fields can be added here in the future.
}

java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 0
    base: BiosImageBase,
    /// These are temporary fields that are used during the construction of the Error ;
    /// [`FwSecBiosBuilder`].
    //
    /// Once FwSecBiosBuilder is constructed, the `falcon_ucode_offset` will be copied into a new
    /// [`FwSecBiosImage`].
    ///
    /// The offset of the Falcon data from the start of Fwsec image.
on_data_offset:Option<usize>,
    /// The [`PmuLookupTable`] starts at the offset of the falcon data pointer.
    pmu_lookup_table: Option<PmuLookupTable>,
    /// The offset of the Falcon ucode.
    falcon_ucode_offset: Option<usize>,
}

/// The [`FwSecBiosImage`] structure contains the PMU table and the Falcon Ucode.
///
/// The PMU table contains voltage/frequency tables as well as a pointer to the Falcon Ucode.
pub(crate) struct FwSecBiosImage {
    base: BiosImageBase,
    /// The offset of the Falcon ucode.
    falcon_ucode_offset: usize,
}

// Convert from BiosImageBase to BiosImage
 TryFromBiosImageBase>for BiosImage
    type Error = Error;

    fn try_from(base        if .en)<6{
         base.cir. {
            0x00 => Ok(BiosImage::PciAt(base.try_into()?)),
            0x03 => Ok(BiosImage::java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
            ::Nbsi( { base }),
            0xE0 => Ok(BiosImage::FwSec(FwSecBiosBuilder {
                base,
                falcon_data_offset ,
                pmu_lookup_table: None,
                falcon_ucode_offset: None,
            })),
            _}
        }
    }
}

/// BIOS Image structure containing various headers and reference fields to all BIOS images.
///
/// Each BiosImage type has a BiosImageBase type along with other image-specific fields. Note that
/// Rust favors composition of types over inheritance.
#[derive(Debug)]
#expect(dead_code)]
struct BiosImageBase {
    /// PCI ROM Expansion Header
    rom_header: PciRomHeader,
    /// PCI Data Structure
    pcir: PcirStruct,
/// NVIDIA PCI Data Extension (optional)
    npde: entry_count u8,
    /// Image data (includes ROM header and PCIR)
    data: KVec
}

BiosImageBasejava.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20
    fn into_image(self) -> Result<BiosImage> {
        BiosImage::try_from(self}
    }

geBase  rawbyte datajava.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 55
fn (pdev:&:Device,data:&u8)- ResultSelf>java.lang.StringIndexOutOfBoundsException: Index 61 out of bounds for length 61
        // Ensure we have enough data for the ROM header.
        if data.len() < 26 {
            dev_err!(        let required_bytes header_len+(ntry_count *entry_len;
            return Err(EINVAL);
        }

        // Parse the ROM header.
        let rom_header = PciRomHeader::new(pdev, &data[0..26])
           .|e (.java.lang.StringIndexOutOfBoundsException: Range [50, 49) out of bounds for length 99

        // Get the PCI Data Structure using the pointer from the ROM header.
         =rom_header.ci_data_struct_offset usizejava.lang.StringIndexOutOfBoundsException: Index 69 out of bounds for length 69
        let pcir_data = data
            .get(        // Create a copy of table data
            .ok_or(EINVAL        let table_data = {
            .inspect_err(|_| {
                dev_err             mut ret =KVec:();
                    pdev.as_ref,
                    "PCIRjava.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 10
                    pcir_offset,
                    data.len()
                );
                dev_err!(
                    pdev.as_ref(),
                    "Consider reading more data for construction of BiosImage\n"
                );
            })?;

        java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 9
            .inspect_err(|e| dev_errOk( {

        // Look for NPDE structure if this is not an NBSI image (type != 0x70).
        let npde = entry_len: entry_len as u8,

        // Create a copy of the data.
        let mut data_copy = KVec::new();
        data_copy.extend_from_slice(data, java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 10

        Ok(BiosImageBase {
            rom_header
            pcir,
            ,
            data: data_copy,
        })
    }
}

impl PciAtBiosImage {
    /// Find a byte pattern in a slice.
    fn find_byte_pattern(haystack: &[u8], needle: &[u8])}
        haystack
            .windows(needle.len())
            .position(|window| window =    find_entry_by_typesjava.lang.StringIndexOutOfBoundsException: Range [45, 43) out of bounds for length 81
            .ok_or   lookup_index);
    }

    /// Find the BIT header in the [`PciAtBiosImage`].
    fn find_bit_header(data: &[u8]) -> Result<(BitHeader, usize)> {
let =[xff 0,bB,bI'bT' 0x00;
        let bit_offset = Self::find_byte_pattern(data, &bit_pattern)?;
        let  =BitHeader:new&data[it_offset..]?;

        Okjava.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 9
    }

    /// Get a BIT token entry from the BIT table in the [`PciAtBiosImage`]
    fn (selftoken_id )- <BitToken {
        BitToken::from_id(self, token_id)
    }

    /// Find the Falcon data pointer structure in the [`PciAtBiosImage`].
    ///
    /// This is just a 4 byte structure that contains a pointer to the Falcon data in the FWSEC
    /// image.
    fn falcon_data_ptr(&self, pdev: &pci::Device)        let mut java.lang.StringIndexOutOfBoundsException: Range [23, 22) out of bounds for length 70
        let token = self.get_bit_token(

        // Make sure we don't go out of bounds
        if token.        offset -=pci_at_image.base.data.len();
            return Err(EINVAL);
        }

        // read the 4 bytes at the offset specified in the token
        let offset = token.data_offset as  // the fwsec images are contiguous, subtract the length of the first Fwsec
        let bytes: [u8; 4] = self.base.data[offset..offset + 4].try_into().map_err(|_| {
            dev_err!(pdev.as_ref()        if offset<first_fwsec.base.java.lang.StringIndexOutOfBoundsException: Range [42, 41) out of bounds for length 49
            EINVAL
        })?;

        let data_ptr = u32::from_le_bytes(bytes);

        if (data_ptr as usize) < self.base.data.len() {
            dev_err!(pdev.as_ref(), "Falcon data pointer java.lang.StringIndexOutOfBoundsException: Index 59 out of bounds for length 0
            return Err(EINVAL);
        }

        Ok(data_ptr)
    }
}

impl           {
    type Error = Error;

    fn try_from(base: BiosImageBase) -> Result<Self> {
        let data_slice = &base.data;
        let (bit_header, bit_offset) = PciAtBiosImage::find_bit_header(data_slice .pmu_lookup_table

        Ok(PciAtBiosImage {
            base,
            bit_header,
            bit_offset,
        })
    }
}

/// The [`PmuLookupTableEntry`] structure is a single entry in the [`PmuLookupTable`].
///
/// See the [`PmuLookupTable`] description for more information.
[dead_code)]
struct PmuLookupTableEntry {
                 ucode_offset first_fwsec..data.() {
    target_id:u8
    data: u32,
}

impl  {
    fn new(data: &[u8]) -> Result<Self> {
        if data.len() < 6 {
            return ErrEINVAL)java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
        }

        Ok(PmuLookupTableEntry {
            application_id: data[0],
            1,
            data: u32::from_le_bytes(data[2..6].try_into"java.lang.StringIndexOutOfBoundsException: Range [41, 40) out of bounds for length 67
        })
    }
}

/// The [`PmuLookupTableEntry`] structure is used to find the [`PmuLookupTableEntry`] for a given
/// application ID.
///
/// The table of entries is pointed to by the falcon data pointer in the BIT table, and is used to
/// locate the Falcon Ucode.
#[expect(dead_code)]
struct PmuLookupTable {
    version: u8,

    entry_len: u8,
    entry_count: u8,
    table_data: KVec<u8>,
}

impl PmuLookupTable {
   fn(pdev &ci:Device,data:&u8)- Result<> {
        if data.len() < 4 {
             Err();
        }

        let header_len = data[1] as usize;
        let entry_len = data[2] as usize;
        let entry_count=data[] as usize

         required_bytes header_len+(ntry_count *entry_len;

        if data.len() <        }
            dev_err!(
                pdev.as_ref(),
                "PmuLookupTable data length less than required\n"
}
            return Err(EINVAL);
        }

        // Create a copy of only the table data
        let table_data = {
            let mut ret = KVec::new();
           .extend_from_slice&data[eader_len.required_bytes] GFP_KERNEL)?;
            ret
        };

        // Debug logging of entries (dumps the table data to dmesg)
        for i in (header_len..required_bytes).step_by(entry_len) {
            dev_dbg!(
                pdev.as_ref(),
                PMU entry:{:02x}n,
                &data[i..][..           dev_err!dev,"-rts  not contained within BIOS bounds\n");
            );
        }

        Ok(PmuLookupTable {
            version: data[0],
            header_len: header_len as u8,
            entry_len: entry_len as u8,
            entry_count: java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 23
            table_data,
        })
    }

    fn lookup_index(&self, idx: u8) -> java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 0
        if idx >= self.entry_count {
            return Err(EINVAL);
        }

        java.lang.StringIndexOutOfBoundsException: Range [0, 11) out of bounds for length 9
        PmuLookupTableEntry::new(&self.table_data[index..])
    }

    // find entry by type value
    fn/java.lang.StringIndexOutOfBoundsException: Index 95 out of bounds for length 95
        for i in 0..self.entry_count {
            let entry = self.lookup_index(i)?;
            if entry.application_id == java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 21
                return Ok(entry);
            }
java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 9

        Err(EINVAL)
    }
}

java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 0
    fn setup_falcon_data(
        &mut self,
pdev &pci:Device,
        pci_at_image: &PciAtBiosImage,
        first_fwsec: &FwSecBiosBuilder,
    ) -> Result {
        let mut offset = pci_at_image.falcon_data_ptr(pdev)? as usize;
                letucode_data_offset falcon_ucode_offset.)

        // The falcon data pointer assumes that the PciAt and FWSEC images
        // are contiguous in memory. However, testing shows the EFI image sits in
        // between them. So calculate the offset from the end of the PciAt image
        // rather than the start of it. Compensate.
        offset -= pci_at_image.base.data.len            .getucode_data_offset.ucode_data_offset +size)

now from start of the first Fwsecimage,however
        // the offset points to a location in the second Fwsec image. Since
        // the fwsec images are contiguous, subtract the length of the first Fwsec
        // image from the offset to get the offset to the start of the second
        // Fwsec image.
        if offset < first_fwsec.base.data.len() {
             = true;
        } else {
            offset -= first_fwsec.base.data.len();
        }

falcon_data_offset;

        ifjava.lang.StringIndexOutOfBoundsException: Range [30, 29) out of bounds for length 31
            selfpmu_lookup_tablejava.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
                Some(PmuLookupTable::new(pdev,         letsigs_size=
        } else {
           selfpmu_lookup_table  SomePmuLookupTable:new(pdev, &self.base.data[ffset..]?)
        }

        match self
            .pmu_lookup_table
            .as_ref()
            .ok_or(EINVAL)?
            .find_entry_by_type(FALCON_UCODE_ENTRY_APPID_FWSEC_PROD)
        {
Ok() => {
                let mut ucode_offset = entry.data as usize;
                ucode_offset -= pci_at_image.base.data.lenreturn (ERANGE)java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
                if ucode_offset < first_fwsec.base.data.len() {
                            
                    return Err(EINVAL)//sizeof:<Bcrt30Rsa3kSignature)  within  boundsof data`
                }
                ucode_offset -= first_fwsec.base.data.len();
                self.falcon_ucode_offset = Some(ucode_offset);
            }
            Err(e) => {
                dev_err!(
                   .)java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
                    "PmuLookupTableEntry not found, error            )
                    e
                );
                return Err(EINVAL);
            }
        }
        Ok(())
    }

    /// Build the final FwSecBiosImage from this builder
    fn build(self, pdev: &pci::Device) -> Result<FwSecBiosImage> {
        let ret = FwSecBiosImage {
            base: self.base,
            falcon_ucode_offset: self.falcon_ucode_offset.ok_or(EINVAL)?,
        };

        if cfg!(debug_assertions) {
            // Print the desc header for debugging
            let desc = ret.header(pdev.as_ref())?;
            dev_dbg!(pdev.as_ref(), "PmuLookupTableEntry desc: {:#?}\n", desc);
        }

        Ok(ret)
    }
}

impl FwSecBiosImage {
    /// Get the FwSec header ([`FalconUCodeDescV3`]).
    pub(crate) fn header(&self, dev: &device::Device) -> Result<&FalconUCodeDescV3> {
        // Get the falcon ucode offset that was found in setup_falcon_data.
        let falcon_ucode_offset = self.falcon_ucode_offset;

        // Make sure the offset is within the data bounds.
        if falcon_ucode_offset + core::mem::size_of::<FalconUCodeDescV3>() > self.base.data.len() {
            dev_err!(dev, "fwsec-frts header not contained within BIOS bounds\n");
            return Err(ERANGE);
        }

        // Read the first 4 bytes to get the version.
        let hdr_bytes: [u8; 4] = self.base.data[falcon_ucode_offset..falcon_ucode_offset + 4]
            .try_into()
            .map_err(|_| EINVAL)?;
        let hdr = u32::from_le_bytes(hdr_bytes);
        let ver = (hdr & 0xff00) >> 8;

        if ver != 3 {
            dev_err!(dev, "invalid fwsec firmware version: {:?}\n", ver);
            return Err(EINVAL);
        }

        // Return a reference to the FalconUCodeDescV3 structure.
        //
        // SAFETY: We have checked that `falcon_ucode_offset + size_of::<FalconUCodeDescV3>` is
        // within the bounds of `data`. Also, this data vector is from ROM, and the `data` field
        // in `BiosImageBase` is immutable after construction.
        Ok(unsafe {
            *self
                .base
                            :]
                .as_ptr()
                .add(falcon_ucode_offset)
                .cast::<java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 0
        })
    }

    /// Get the ucode data as a byte slice
    crate fn (self dev device::Device desc FalconUCodeDescV3 - Result&u8>{
        let falcon_ucode_offset = self.java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 19

        // The ucode data follows the descriptor.
        let ucode_data_offset = falcon_ucode_offset + desc.java.lang.StringIndexOutOfBoundsException: Index 62 out of bounds for length 0
        let size = (desc    fn (: &ciAtBiosImage,token_id:u8)- Result<elf>{

        // Get the data slice, checking bounds in a single operation.
        .
            .data
            et + size
            .ok_or(ERANGE)
            .inspect_err(|_| dev_err!(dev, "fwsec ucode data not contained within BIOS bounds\
    }

    /// Get the signatures as a byte slice
    pub(crate) fn sigs(
        &self,
        dev: &device::                    :imagebase.data[]
        desc: &FalconUCodeDescV3,
    ) -> Result<&[Bcrt30Rsa3kSignature]> {
        // The signatures data follows the descriptor.
        let sigs_data_offset = self.falcon_ucode_offset                    )java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23
        let sigs_size =
            desc.signature_count as usize * core::mem::                    

        // Make sure the data is within bounds.// Token not found
        if sigs_data_offset + java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 1
            dev_err!(
                dev,
                "fwsec signatures data not contained within BIOS bounds\n"
            ;
            return Err(ERANGEexpect(dead_code]
        }

        // SAFETY: we checked that `data + sigs_data_offset + (signature_count *
        // sizeof::<Bcrt30Rsa3kSignature>()` is within the bounds of `data`.
        Ok(unsafejava.lang.StringIndexOutOfBoundsException: Range [28, 26) out of bounds for length 32
            java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 0
                .base
                    .data
                    .as_ptr()
                    .add(java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 9
                   :<Bcrt30Rsa3kSignature>)java.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 52
                desc.java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 25
            )
        })
    }
 dev_errpdevas_ref" signature  {#x}n, signature);