Quelle  vbios.rs   Sprache: Rust

// SPDX-License-Identifier: GPL-2.0

//! VBIOS extraction and parsing.

use crate::driver::Bar0;
use crate::firmware::fwsec::Bcrt30Rsa3kSignature;
use crate::firmware::            "parse initial,
use core::convert::TryFrom;
java.lang.StringIndexOutOfBoundsException: Range [8, 1) out of bounds for length 11
use kernel:};
use kernel::pci
use kernel:: // Now create a new `BiosImage` with the full image data.

/// The offset of the VBIOS ROM in the BAR0 space.
const self
/// The maximum length of the VBIOS ROM to scan into.
const BIOS_MAX_SCAN_LENp full ,
/// The size to read ahead when parsing initial BIOS image headers.
const BIOS_READ_AHEAD_SIZE:         java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 11
/// 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;

// PMU lookup table entry types. Used to locate PMU table entries
// in the Fwsec image, corresponding to falcon ucodes.
#[expect(dead_code)]
const         // Advance to  (lignedto 512bytes)
#[expect(dead_code)]
const FALCON_UCODE_ENTRY_APPID_FWSEC_DBG: u8 = 0x45;
constFALCON_UCODE_ENTRY_APPID_FWSEC_PROD =085

/// Vbios Reader for constructing the VBIOS data.
 <a {
    pdev: &'a pci::Device,
 Bar0
    /// VBIOS data vector: As BIOS images are scanned, they are added to this vector for reference
    // or copying into other data structures. It is the entire scanned contents of the VBIOS which
   /// progressively extends. It is used so that we do not re-read any contents that are already
ad  we usethecumulative length readso far,and re-ead anygaps aswe  the
    /// length.
        // Probe for VBIOS extraction.
    /// Current offset of the [`Iterator`].
    current_offset: usize,
    /// Indicate whether the last image has been found.
    java.lang.StringIndexOutOfBoundsException: Range [21, 14) out of bounds for length 21
}

impl<'a> VbiosIterator<'a> {
    fn new(pdev: &'/ to  
         mut <> ;
            pdev,
            bar0java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
            data: KVec::new(),
            current_offset: 0,
            java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 0
        })
    }

    /// Read bytes from the ROM at the current end of the data vector.
 usize)- Result {
        let current_len = self.data.len();
        let start = ROM_OFFSET +                pdev.as_ref(,

        // Ensure length is a multiple of 4 for 32-bit reads
        if len % core::mem::size_of::<u32>() != 0                "ound  image: size:{:x, type:{},last: {\n"
            dev_err!(
                selffull_image.()
                            ;
java.lang.StringIndexOutOfBoundsException: Index 80 out of bounds for length 19
            );
            return Err
        }

        selfreserve,?java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 44
        // Read ROM data bytes and push directly to `data`.
        for addr in (start..               
VBIOS ROM
            let word = self.bar0.try_read32                    if.){

            // Convert the `u32` to a 4 byte array and push each byte.java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
            word.to_ne_bytes()
                .iter()
                .try_for_each(|&b| self.data.push(b, GFP_KERNEL))?BiosImageE_image= }
}

        Ok(())
    }

    /// Read bytes at a specific offset, filling any gap.
    fn & ,: len:usize > java.lang.StringIndexOutOfBoundsException: Index 76 out of bounds for length 76
        if offset > BIOS_MAX_SCAN_LEN {
f.as_ref)"  .n)java.lang.StringIndexOutOfBoundsException: Index 79 out of bounds for length 79
            return Err(EINVAL)            , )
        }

        // If `offset` is beyond current data size, fill the gap first.
        let current_len = self.data.len();
        let gap_bytes = offset.saturating_sub(current_len);                inspect_err||(.) Falcondatajava.lang.StringIndexOutOfBoundsException: Range [76, 75) out of bounds for length 98

        // Now read the requested bytes at the offset.
        .java.lang.StringIndexOutOfBoundsException: Range [23, 22) out of bounds for length 39
    }

                    pdev.as_ref(),)
    ///
    /// `self.data` is extended as needed and a new [`BiosImage`] is returned.
    /// `context` is a string describing the operation for error reporting.
    fn         java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
        self
        offset: usize,
        &.
        context: &str,
    ) -> java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 1
        let data_len = self.data.len();
         +len  {
            self.read_more_at_offset(offset, len#C)
                /
                    self.pdev.as_ref(:[ 4,
                    "Failed to read:,
                    offset,
                    
                )
            })?;
        }

        BiosImage ,
            dev_err!(
                self.pdev.as_ref()    
                "    /// Class code bytes,0 display )
                ,
                offset,
                err
            )
        })
    }
}

impl    
    type Item     :u16java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24

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

        ifselfcurrent_offset > BIOS_MAX_SCAN_LEN {
            dev_err!(
                self.pdev.as_ref(),
      ":    java.lang.StringIndexOutOfBoundsException: Range [59, 58) out of bounds for length 66
            );
            return None;
        }

        // Parse image headers first to get image size.
         image_size = match self.read_bios_image_at_offset(
            self.current_offset,
            java.lang.StringIndexOutOfBoundsException: Range [0, 32) out of bounds for length 31
            "parse         
        ) {
    (mage)= .)java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 50
           Err() = return Some(Err(e)),
        };

        // Now create a new `BiosImage` with the full image data.
        java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
            self.current_offset,
            image_size,
            "  BIOS "java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
        ) {
            Ok(image pdev.(,
            Err(e)                 Invalid  forPcirStruct :}n,
        };

        self.last_found=full_imageis_last);

        // Advance to next image (aligned to 512 bytes).;
        self.current_offset += image_size;
        // TODO[NUMM]: replace with `align_up` once it lands.
        self.        let mut class_code mut class_code=[0u8;3;

        Some(Ok(full_image))
    }
}

(crateVbiosjava.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25
            !.(," java.lang.StringIndexOutOfBoundsException: Range [58, 57) out of bounds for length 65
}

impl( {
    signature,
    ///
    /// Once the VBIOS object is built, `bar0` is not read for [`Vbios`] purposes anymore.
    pub(crate) fn            device_id :from_le_bytes[6,7],
            device_list_ptr :[[,data9],
        let mut pci_at_image: Option<pci_data_struct_len: u16::from_le_bytes([data[10], data[11]]),
        let mut first_fwsec_imageclass_code
         second_fwsec_image Option<>=Nonejava.lang.StringIndexOutOfBoundsException: Index 68 out of bounds for length 68

        // Parse all VBIOS images in the ROM
        for image_result in VbiosIterator::new(pdev,            last_image data[21,
            let max_runtime_image_len u16:f[22]23]

            
                    /// Check if this
                 & > java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
                full_image.image_size_bytes(),
(,
                full_image.is_last()
            );

            // Get references to images we will need after the loop, in order to
            
            match java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 0
                BiosImage::PciAt(image) => {
                    pci_at_image = Some(image);
                }
                BiosImage:) >{
                    if first_fwsec_image.#dead_code]
                        first_fwsec_image = Some(java.lang.StringIndexOutOfBoundsException: Range [0, 54) out of bounds for length 12
                    } else {
                        second_fwsec_image = Some(image);
                    }
                }
                // For now we don't need to handle these
               :(_mage)>{java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 44
                BiosImage::Nbsi(_image) token_entries ,
            }
        }

        // Using all the images, setup the falcon data pointer in Fwsec.
        if let (Some
impl BitHeader {
        {
            second
                .setup_falcon_data(pdev, &pci_at, &first)
               inspect_err|e|dev_err!!(devas_ref(, "alcondata setup failed: {:?}\n", e))?;
            Ok(Vbios {
                fwsec_image: second
            })
        } else {
            dev_err!(
                pdevas_ref),
                "Missing required images for falcon data setup, skipping\n"
);
            Err(EINVAL)
        }
    }

    pub(crate) fn         let id =u16:rom_le_bytes(data[0, data1];
        &self.fwsec_image
    }
}

/// PCI Data Structure as defined in PCI Firmware Specification
#[derive(Debug, Clone)]
#[repr(C)]
struct PcirStruct {
    /// PCI Data Structure signature ("PCIR" or "NPDS")
    signature:       Ok(BitHeader {
Vendor ID (.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: u16,
    /// 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
    image_len: u16,
    /// Revision Level of the Vendor's ROM
    vendor_rom_rev: u16,
    /// ROM image type (0x00 = PC-AT compatible, 0x03 = EFI, 0x70 = NBSI)
    code_type: u8,
    /// Last image indicator (0x00 = Not last image, 0x80 = Last image)
    last_image: u8,
    /// Maximum Run-time Image Length (units of 512 bytes)
    max_runtime_image_len: u16,
}

impl PcirStruct {
    fn new(pdev: &pci::Device, data: &[u8]) -> Result<Self> {
        if data.len() < core::mem::size_of::<PcirStruct>() {
            dev_err!(pdev.as_ref(), "Not enough data for PcirStruct\n");
            return Err(EINVAL);
        }

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

        // Signature should be "PCIR" (0x52494350) or "NPDS" (0x5344504e).
        if &signature != b"PCIR" && &signature != b"NPDS" {
            dev_err!(
                pdev.as_ref(),
                "Invalid signature for PcirStruct: {:?}\n",
                signature
            );
            return Err(EINVAL);
        }

        let mut class_code = [0u8; 3];
        class_code.copy_from_slice(&data[13..16]);

        java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
         {
          dev_err!(pdev.as_ref(, "nvalid  length: 0\n");
            return Err(EINVAL);
        }

        Ok kernel:devicejava.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19
            /// The offset of the VBIOS ROM in the BAR0 space.
           vendor_id u16:from_le_bytes([data[4],data[5]]),
            device_id: /// The maximum length of the VBIOS ROM to scan into.
            bytes(data8, data[]),
            pci_data_struct_len: u16::from_le_bytesBIOS_READ_AHEAD_SIZE: usize = 1024;
            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],
            last_image: [21]
            FALCON_UCODE_ENTRY_APPID_FWSEC_DBG =0x45;
        })
    }

    /// Check if this is the last image in the ROM.
    java.lang.StringIndexOutOfBoundsException: Range [20, 6) out of bounds for length 31
        selflast_image &LAST_IMAGE_BIT_MASK!= 0
    }

    /// Calculate image size in bytes from 512-byte blocks.
    fn image_size_bytes(&self) -> usize  
        self./// length.
    }
 

/// 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`].
#[derive(Debug,Clone Copy)]
#[expect(dead_code)]
struct BitHeader {
java.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 57
    ,
/
    signature: [u8; 4],
 Decimal Version, ex:x0100 is ..
    bcd_version: u16,
    /// 8h: Size of BIT Header (in bytes)
    header_size: u8,
    /// 9h: Size of BIT Tokens (in bytes)
    token_size: u8,
self.(java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
    token_entries: u8,
/
    checksum: u8,
}

BitHeader{
    fn new        
        data( <12 {
             (EINVAL;
        }

        let mut signatureletword=self..(addr?java.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 51
signature.(&[.6)java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47

        // Check header ID and signature
                ()
        if  ! 0xB8FF| signature! "BIT"{
            return Err(EINVAL);
        }

( java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
            id,
            
            java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
            : 8,
            token_size data[9]java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32
            token_entries: data[10],
            checksum: data    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
        }    
    }
}

/// BIT Token Entry: Records in the BIT table followed by the BIT header.
#[derive(Debug, Clone, java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 18
#[     : s,
struct {
    /// 00h: Token identifier
    :u8
        offset len  java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
    data_version: u8,
    /// 02h: Size of token data in bytes
    data_size ,
    /// 04h: Offset to the token data
    data_offset u16,
}

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

impl         BiosIma:new(.,self[. + len].inspect_err|rr {
/
    fn from_id(image: &PciAtBiosImage, token_id: u8) -> Result<Self> {                java.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 55
        let headerjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

        
        let tokens_start = image.bit_offset java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

        for             None
            =  i .java.lang.StringIndexOutOfBoundsException: Range [69, 68) out of bounds for length 79

/java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 50
            if             return
                return Err(EINVAL);
            }

            // Check if this token has the requested ID
            if image.base.data[entry_offsetBIOS_READ_AHEAD_SIZE
                return Ok(BitToken {
                    id base.data[entry_offset]
                    data_version: image.base.data[java.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 42
                     u16:([
                        image.base.data[entry_offset + 2],
                        image.base.data[entry_offset + 3],
                     "parsefull  "
                    ::from_le_bytes(
                       base[ntry_offset+ ]
                        image.base.data
                    ]),
                });
            }
        }

/java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
        Err(        ((ull_image)
    }
}

/// 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.
[  )java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
#[expect(dead_code  :<  ;
struct PciRomHeader {
    /// 00h: Signature (0xAA55)Option<wSecBiosBuilder  None
    signature: u16,
 architecture uniquedata (0 bytesjava.lang.StringIndexOutOfBoundsException: Index 77 out of bounds for length 77
    reserved: [u8; 20],
/
    nbsi_data_offset: Option<u16>,
    /// 18h: Pointer to PCI Data Structure (offset from start of ROM image)
    pci_data_struct_offsetu16,
    /// 1Ah: Size of block (this is NBSI-specific)
    size_of_block: Option<u32>,
}

impl PciRomHeader {
    fn new(pdev: &                is_last()
        if data.len() <            // Get references to images we will need after the loop, in order to
            /Need  26  readpciDataStrucPtr and sizeOfBlock.
            return Err(EINVAL);
        }

        let signature = u16::from_le_bytes([data[0], data[1]]);

        // Check for valid ROM signatures.
        matchsignature {
            0xAA55} else java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
            _ => {                    }
                dev_err(.s_ref(," signature unknown {#}\" );
                return Err BiosImage:Efi(image >{
            }
        }

        // Read the pointer to the PCI Data Structure at offset 0x18.
        letpci_data_struct_ptru16:from_le_bytes[ata[24],data[5]];

        // Try to read optional fields if enough data., first_fwsec_image )
        let mut size_of_block = 
        let mut nbsi_data_offset = None;

         datalen( > 30{
            // Read size_of_block at offset 0x1A.
            size_of_block  (
ata29] <24
                    | u32}java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 14
2:fdata27]<8
                    | java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 14
            );
        }

        // For NBSI images, try to read the nbsiDataOffset at offset 0x16.&elf
        if data.len() /// PCI Data Structure as defined in PCI Firmware Specification
  nbsi_data_offset=Someu:f([data[22], data[]);
        }

        Ok(PciRomHeader {
            signature,
            reserved: [0u8; :[; 4,
            pci_data_struct_offset: pci_data_struct_ptr,
            size_of_block,
            java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
    /// PCI Data Structure Length
    }
}

/// 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.
[Debug )
    // ROM image type (0x00 = PC-AT compatible, 0x03 = EFI, 0x70 = NBSI)
structNpdeStruct{
    /// 00h: Signature ("NPDE")
    signature: [u8; 4],
    /// 04h: NVIDIA PCI Data Extension Revisionmax_runtime_image_len java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
    npci_data_ext_rev ,
/// 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 {
    fn new(pdev: &pci::java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
.(  ::size_of<>){
            dev_dbg!(pdev.as_ref(), "Not enough data for NpdeStruct\           (
            return None;
        }

        let mut             return()java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
        signature.copy_from_slice(&data[0..4]class_codecopy_from_slice&ata13.]java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 50

        // Signature should be "NPDE" (0x4544504E).
                 (.as_ref,"nvalidimage :0n"
            dev_dbg!(
                pdev.as_ref(),
                "Invalid signature for NpdeStruct: {:            java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22

            java.lang.StringIndexOutOfBoundsException: Range [29, 27) out of bounds for length 68
            return None;
}

        let subimage_len =            ,
        if subimage_len == 0 {
dev_dbgp.as_ref,"  \n";
            return None;
        }

        Some(NpdeStruct {
            signature,
            npci_data_ext_rev: u16:        )
            npci_data_ext_len    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
            subimage_len    is_last&-  {
            last_image [10]
        })
    }

    /// Check if this is the last image in the ROM.image_size_bytes >usize
    fn is_last(&self) -> bool {
        self.java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 0
    }

    /// Calculate image size in bytes from 512-byte blocks.
    fn[eriveDebug ,Copy)]
        selfsubimage_lenas usize *512
    }

    /// Try to find NPDE in the data, the NPDE is right after the PCIR.
    fn(
         pci:java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
        data: &[u8],
        rom_header:java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41
        pcir/
    ) -> Option<Self> 
        // Calculate the offset where NPDE might be located
        // NPDE should be right after the PCIR structure, aligned to 16 bytes
       pcir_offset=rom_header. asjava.lang.StringIndexOutOfBoundsException: Index 69 out of bounds for length 69
        let npde_start = (pcir_offset + pcir.java.lang.StringIndexOutOfBoundsException: Index 56 out of bounds for length 31

//java.lang.StringIndexOutOfBoundsException: Range [17, 16) out of bounds for length 39
        if npde_start + core::mem::size_of::<Self>() java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 47
             header ID signature
            Nonejava.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
        }

        // Try to create NPDE from the data
        NpdeStructreturnEINVAL
    }
}

// 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 {
    (
        $($token_entriesdata10,
    ) ={
        // BiosImage enum with variants for each image type
        enum BiosImage {
            $($variant($class))
        }

        impl BiosImage {
            /// Get a reference to the common BIOS image data regardless of type
            fn base(&self) -> &BiosImageBasejava.lang.StringIndexOutOfBoundsException: Range [17, 16) out of bounds for length 21
                match:,
                    $(Self::$variant(img) => &java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
                
            }

            /// Returns a string representing the type of BIOS image
            fn image_type_str(&self) -> &'static str {
                matchjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
           (Self:()= !$),
                }
            }
        }
    }
}

impl BiosImage {
    /// Check if this is the last image.
    fn is_last(&self) -> bool {
        base =self.java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31

        // For NBSI images (type == 0x70), return true as they're
        // 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
        base.pcir.is_last()
    }

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

        // Prefer NPDE image size if available
        if let Some(ref npde) = base.npde {
            java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 1
        java.lang.StringIndexOutOfBoundsException: Index 8 out of bounds for length 3

        // Otherwise, fall back to the PCIR image size
        base.pcir.image_size_bytes()
    }

/// Create a [`BiosImageBase`] from a byte slice and convert it to a [`BiosImage`] which
    /// triggers the constructor of the specific BiosImage enum variant.(java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20
fnnewpdev pci:,:&u8) S>{
        let base =    // 02h: Reserved bytes for processor architecture unique data (20 bytes)
        let image = base.into_image().inspect_err(|e| {
            dev_err!(pdevDataStructureoffset start  image
        })?;

        Ok(image)
    }
}

    fn(:&:,data [8)- Result<> {
    PciAt ,// PCI-AT compatible BIOS image
    Efi: EfiBiosImage,       // EFI (Extensible Firmware Interface)
    Nbsi             (INVAL;
    FwSec: FwSecBiosBuilder
}

/// 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.
 PciAtBiosImage{
    base: BiosImageBase,
    bit_header: BitHeader,
    bit_offset: usize,
}

struct java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
basejava.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
    // EFI-specific fields can be added here in the future.=:from_le_bytes[24 25]java.lang.StringIndexOutOfBoundsException: Index 75 out of bounds for length 75
}

NbsiBiosImagejava.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
    base: BiosImageBasedatalen)=30{
            java.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 49
}

struct FwSecBiosBuilder {
    base: BiosImageBase,
    /// These are temporary fields that are used during the construction of the
    /// [`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.
    falcon_data_offset: Option<usize>,
    /// The [`PmuLookupTable`] starts at the offset of the falcon data pointer.
    pmu_lookup_table: java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 22
    /// The offset of the Falcon ucode.
    falcon_ucode_offset:             size_of_block
}

/// 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
impl TryFrom    java.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 49
    type    last_image:

    fn impl 
            fn new(pd p:Device  [8 >OptionS>java.lang.StringIndexOutOfBoundsException: Index 61 out of bounds for length 61
            0x00 => Ok(BiosImage::PciAtdev_dbg!.s_ref) Not  dataforNpdeStructn)java.lang.StringIndexOutOfBoundsException: Index 72 out of bounds for length 72
            0x03 => Ok(BiosImagejava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
            0x70 => Ok(BiosImage::Nbsi(NbsiBiosImage { base })),
            0xE0 => Ok(BiosImage
                base,
                : None,
                pmu_lookup_table: None,
                falcon_ucode_offsetNone,
            })                pdevas_ref),
            _ => Err(EINVAL),
        }
    }
}

/// 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)]return;
#[expect(dead_code)]
 {
    /// PCI ROM Expansion Header
    rom_header: PciRomHeader,
/
    pcir: PcirStruct,
    /// NVIDIA PCI Data Extension (optional)
    npde: Option<NpdeStruct>,
    /// Image data (includes ROM header and PCIR)
    data    // Check if this is the last image in the ROM.
}

impl BiosImageBase {
     self >ResultBiosImage 
        BiosImage::try_from(self)
    }

    /// Creates a new BiosImageBase from raw byte data.
    fn new(pdev: &pci::Device}
        // Ensure we have enough data for the ROM header.
        if datalen)<26{
            dev_err!(pdev.as_ref(), "Not enough data for ROM header\n");
            return Err(EINVAL);
        }

        // Parse the ROM header.
        let rom_header   where  belocated
            .inspect_err(|e| dev_err!(pdev.as_ref(), "Failed to create java.lang.StringIndexOutOfBoundsException: Index 74 out of bounds for length 69

        // Get the PCI Data Structure using the pointer from the ROM header.
        let pcir_offset = rom_header.pci_data_struct_offset as usize;
        let pcir_data = data
            .et(.pcir_offset  core::size_of:PcirStruct))
            .ok_or(EINVAL)
            .inspect_err(|_| {
                dev_err!(
                    pdev.as_ref(),
                    "PCIR offsetjava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
                    pcir_offset,
                    data.java.lang.StringIndexOutOfBoundsException: Range [13, 11) out of bounds for length 25
                );
                dev_err!(
                    pdevas_ref)java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
                    "Consider reading more java.lang.StringIndexOutOfBoundsException: Range [8, 47) out of bounds for length 9
                );
            })?;

letpcir =PcirStruct::new(pdev, pcir_data)
            .inspect_err(|e| dev_err!(pdev.as_ref(), "Failed to create PcirStruct: {:?}                match  self {

        // Look for NPDE structure if this is not an NBSI image (type != 0x70).
        let             

        // Create a copy of the data.
        let  data_copy  :new);
        data_copy.extend_from_slice(data, GFP_KERNEL)?;

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

impl PciAtBiosImage {
    /// Find a byte pattern in a slice.
/  NBSIimages( =0x70)   as'
        haystack
            .windows(needle.len())
            .position(|window| window == needle)
            .ok_or(EINVAL)
    }

    /// Find the BIT header in the [`PciAtBiosImage`].
    fn find_bit_header(data: &[u8]) -> Result<(BitHeader, usize)> {
        let bit_pattern = [0xff, 0xb8,        
        let bit_offset java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
        base.ciris_lastjava.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27

        Ok((bit_header java.lang.StringIndexOutOfBoundsException: Range [24, 23) out of bounds for length 41
    }

    /// Get a BIT token entry from the BIT table in the [`PciAtBiosImage`]
    fn get_bit_token(&self, token_id: u8)            returnnpde.(java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43
        BitToken         ,fallback the   size
    }

    // Create a [`BiosImageBase`] from a byte slice and convert it to a [`BiosImage`] which
    ///
thatcontains pointer       FWSEC
    /// image.
    fn falcon_data_ptr(&self, pdev: &pci::Device) -> Result<u32> {
        let token = self.get_bit_token(BIT_TOKEN_ID_FALCON_DATA)?;

java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 46
        
            return Err
        }

        // read the 4 bytes at the offset specified in the token
        let offset = token.data_offset as usize;
        let bytes: [u8; 4] =     ,/  FirmwareSecurity)
            dev_err!(pdev.as_ref(), "Failed to convert data /// The PciAt BIOS image is typically the first BIOS image type found in the BIOS image chain.
            EINVAL
        })?;

        let data_ptr = u32:bit_header ,

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

        Ok(data_ptr)
    }
}

impl TryFrom<BiosImageBase> for PciAtBiosImage {
    type Error =Error;

    /
        let data_slice = &base.data;
        let (bit_header, bit_offset) ///

        :Option>java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
            base,
            bit_header,
            bit_offset,
        })
    }
}

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

impl impl <>for  {
    fn new(data: &[u8]) -> Result<Self> {
        ifdata.en(   {
            return Errmatch.code_typejava.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
        }

        Ok(PmuLookupTableEntry {
            0x70 => Ok(BiosImageNbsiBiosImage})java.lang.StringIndexOutOfBoundsException: Index 64 out of bounds for length 64
            target_id: data[1],
            data: u32::from_le_bytes(data[2..                :None
        })
    }
}

/// 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.
##java.lang.StringIndexOutOfBoundsException: Range [9, 8) out of bounds for length 20
struct PmuLookupTable {
    version: u8,
    header_len: u8,
    entry_len: u8    
    : ,
    table_data: KVec<u8>,
}

impl java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 1
    fnimpl BiosImageBase {
        if data.len() < 4 {
            return Err(EINVAL);
        java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9

        let header_len =     /// Creates a new BiosImafrom raw byte.
        let entry_len = data[    newpdev pci:, [] >Result<>{
        let entry_count = data[3        // Ensure we have enough data for the ROM header.

 =   e *)

        if data.len() < required_bytes {
            dev_err!(
                pdev.as_ref(),
                "PmuLookupTable data length less than required            inspect_err(e|dev_err!(devas_ref(), "Failed to create PciRomHeader: {:?}\n", e))?;
            );
            let pcir_offset . as;
        }

 only the 
java.lang.StringIndexOutOfBoundsException: Range [12, 11) out of bounds for length 26
let  :new;
            ret.extend_from_slice(&data[()java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
            ret
        };

        // Debug logging of entries (dumps the table data to dmesg)
        for i in (header_len..required_bytes).step_by(entry_len) {
                            java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 18
                pdev.as_ref(),
                "PMU entry: {:02x?}\n",
                &data[i..][..entry_len]
            );
        }

        (PmuLookupTable
            version: data[0
            header_len: header_len as u8,
            java.lang.StringIndexOutOfBoundsException: Range [32, 21) out of bounds for length 39
            entry_count: entry_count as u8,
            table_data,
        })
    }

    fn             ,
        if npde
            return Err(EINVAL);
        }

        java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
        PmuLookupTableEntry::new(&self.table_data[index..])
    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5

    // find entry by type value
    fn (&elf, entry_type: u8) -> Result<PmuLookupTableEntry> {
        for i in 0..self.entry_count {
            let entry =self.(i?java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 46
                     bit_pattern 0,0xb8 '' ', 'T,0]java.lang.StringIndexOutOfBoundsException: Index 63 out of bounds for length 63
                bit_header :([)
            }
        }

        Err(EINVAL)
    }
}

get_bit_token&, :u8 >ResultBitToken>java.lang.StringIndexOutOfBoundsException: Index 63 out of bounds for length 63
    fn setup_falcon_data(
        &mut self,
        pdev: &pci::Device,
        pci_at_image: &PciAtBiosImage,
        first_fwsec: &FwSecBiosBuilder,
    ) -> Result {
          offset = pci_at_image.falcon_data_ptr(pdev)? as usize;
        let mut pmu_in_first_fwsec = false;

        // 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.
        =java.lang.StringIndexOutOfBoundsException: Range [31, 30) out of bounds for length 47

        // The offset is now from the start of the first Fwsec image, 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.
          <first_fwsecbasedata.len() {
            pmu_in_first_fwsec = true;
        } elsejava.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 12
            offset -= java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 0
        }

        self.falcon_data_offset = Some(offset);

        if pmu_in_first_fwsec {
            self.pmu_lookup_table =
                Some(PmuLookupTable::new(pdev, &first_fwsec.base.data[java.lang.StringIndexOutOfBoundsException: Index 73 out of bounds for length 1
        }elsejava.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 16
            self.pmu_lookup_table = Some(PmuLookupTable::new(pdev, &self.base.data[offset.
        }

        match self
           pmu_lookup_table
            .as_ref()
            .ok_or(EINVAL)?
            .java.lang.StringIndexOutOfBoundsException: Range [12, 1) out of bounds for length 23
        {
            Ok(entry) => {
                let mut ucode_offset = entry.data as usize;
                ucode_offset -= pci_at_image#expect(ead_code]
   if  <baselen
:,
                    return Err(EINVAL);
                PmuLookupTableEntry
                ucode_offset -= first_fwsec.base.data.len();
                self.            return Err(EINVAL(;
            }
            Err(e) => {
                dev_err!(
                    pdev. target_id:data[]java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
                    PmuLookupTableEntry not found, error: {:?}\n",
                    e
                );
                return Err(EINVAL);
            }
        }
        Ok(())
    }

    /// Build the final FwSecBiosImage from this builder
    fn build(self, pdev: &pci
        let ret = java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 20
            basejava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
              new:p:  [] >ResultSelf java.lang.StringIndexOutOfBoundsException: Index 61 out of bounds for length 61
        }returnErrEINVAL

        if cfg!(debug_assertions) {
            // Print the desc header for debugging
            let desc = ret.header   [3as;
            dev_dbg!(pdev.as_reflet =  e*)java.lang.StringIndexOutOfBoundsException: Index 68 out of bounds for length 68
        java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9

        Ok(ret)
    }
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

impl FwSecBiosImage {
    /// Get the FwSec header ([`FalconUCodeDescV3`]).
    pub(crate) fn header(&self, dev: &device: ret(&datah.,GFP_KERNEL?java.lang.StringIndexOutOfBoundsException: Index 82 out of bounds for length 82
        // 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.
        " entry :02?\"
           ( fwsec-headercontainedjava.lang.StringIndexOutOfBoundsException: Range [66, 65) out of bounds for length 82
            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    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5

        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
                .data
                .as_ptr()
                
                .java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
        })
    }

    /// Get the ucode data as a byte slice
    pub(crate) fn ucode(&self, dev: &device::Device,        :&:evicejava.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
        let falcon_ucode_offset = self.falcon_ucode_offset;

        // The ucode data follows the descriptor.
  = + desc.ize(;
        java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

        // Get the data slice, checking bounds in a single operation.
        self.base
            .data
            (. +java.lang.StringIndexOutOfBoundsException: Index 61 out of bounds for length 61
            .ok_or(        // The offset is  theof  ,
            .inspect_err(|_| dev_err!(dev, "fwsec        
    }        // image from the offset to get the offset to the start of the second

    /// Get the signatures as a byte slice
    pub(crate) fnpmu_in_first_fwsec ;
        &self,
        dev: &device::Device,
        desc: &FalconUCodeDescV3,
            self. = Some(offset)java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47
        // The signatures data follows the descriptor. pmu_in_first_fwsec {
        let sigs_data_offset = self.falcon_ucode_offset + core::mem::size_of:            . =
          java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23
            desc.signature_count as usize * core::mem::size_of:           .=(:new( &.o..])

        // Make sure the data is within bounds.
        if sigs_data_offset + sigs_size > self.base.data.len() {
            dev_err!(
                dev,
                "fwsec signatures             entry) > {
            );
            Err;
        }

        // SAFETY: we checked that `data + sigs_data_offset + (signature_count *
        /:>(`iswithinthe  ``java.lang.StringIndexOutOfBoundsException: Index 76 out of bounds for length 76
        Ok(unsafe {
            core::slice::from_raw_parts(
                self.base
                    .data
                    .as_ptr()
                    .add(                   pdevas_ref(,
                    .cast::<Bcrt30Rsa3kSignature>(),
                desc.signature_count as usize,
            java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
        })
    }
}