/* * CDDL HEADER START * * The contents of this file are subject to the terms of the * Common Development and Distribution License, v.1, (the "License"). * You may not use this file except in compliance with the License. * * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE * or http://opensource.org/licenses/CDDL-1.0. * See the License for the specific language governing permissions * and limitations under the License. * * When distributing Covered Code, include this CDDL HEADER in each * file and include the License file at usr/src/OPENSOLARIS.LICENSE. * If applicable, add the following below this CDDL HEADER, with the * fields enclosed by brackets "[]" replaced with your own identifying * information: Portions Copyright [yyyy] [name of copyright owner] * * CDDL HEADER END */ /* * Copyright 2014-2017 Cavium, Inc. * The contents of this file are subject to the terms of the Common Development * and Distribution License, v.1, (the "License"). * You may not use this file except in compliance with the License. * You can obtain a copy of the License at available * at http://opensource.org/licenses/CDDL-1.0 * See the License for the specific language governing permissions and * limitations under the License. */ #ifndef _COMMON_NVM_H_ #define _COMMON_NVM_H_ #include "nvm_map.h" #include "append.h" // Callbacks: #ifndef MFW #ifndef UEFI #define TRACE(module, ...) EDIAG_ERR(__VA_ARGS__) #else // UEFI #define TRACE #endif #else // MFW extern void memset32(u32 *ptr, u32 val, u32 byte_cnt); extern void memcpy32(u32 *ptr, u32 *src, u32 byte_cnt); #endif extern int nvm_read(u32 nvm_addr, u32 n_bytes, u32 *read_buf); extern void compute_crc_from_buf(u32 *buf_p, u32 len, u32 *crc_p); extern int nvm_write(u32 nvm_addr, u32 byte_cnt, u32 *buf); extern int validate_dir(u32 bundle_id, u32 num_images); extern void nvm_write_progress_cb(u32 byte_cnt, u32 orig_byte_cnt); #ifndef ERROR #define ERROR (-1) #endif #ifndef OK #define OK (0) #endif #define ROMIMG_NUM_MAX 8 #define PCIR_OFFSET(f) ((u32)((int_ptr_t) &(((pci30_rom_hdr *)0)->f))) typedef enum { MBA_MBA_LEGACY_IDX = 0, MBA_MBA_PCI3CLP_IDX, MBA_MBA_PCI3_IDX, MBA_FCODE_IDX, EFI_X86_IDX, EFI_IPF_IDX, EFI_EBC_IDX, EFI_X64_IDX } mba_image_t; typedef struct _exp_rom_hdr_t { #define ROM_HEADER_SIG 0x0AA55 u16 Signature; u8 Size; u8 Entry[4]; u8 Cksum; u16 VendorOffset; /* Offset to vendor_data_t structure */ u8 reserved1[12]; u16 ROMIDoffset; u16 PCIdsOffset; u16 PnPehOffset; /* Offset to pci_rom_hdr_t structure */ u8 reserved2[4]; } exp_rom_hdr; typedef struct _pci30_rom_hdr_t { u8 Signature[4]; /* PCIR */ u16 VendorID; u16 DeviceID; u16 VP; u16 StructLength; u8 StructRev; /* PCI30 or not */ u8 BaseClass; u8 SubClass; u8 Interface; u16 ImageLength; u16 ImageRev; u8 CodeType; u8 Indicator; u16 RunTimeImgLen; u16 CfgCodeHdr; u16 DmtfEntry; } pci30_rom_hdr; /***************************************************************************** * * FUNCTION: validate_image_header * * DESCRIPTION: Returns the flash size in bytes. * * INPUT: p_img_hdr * * OUTPUT: None * * RETURNS: Flash size in bytes *****************************************************************************/ int validate_image_header(struct image_header *p_img_hdr); /***************************************************************************** * * FUNCTION: get_flash_size * * DESCRIPTION: Returns the flash size in bytes. * * INPUT: None * * OUTPUT: None * * RETURNS: Flash size in bytes *****************************************************************************/ u32 get_flash_size(void); /***************************************************************************** * * FUNCTION: allocate_nvram_for_image * * DESCRIPTION: Responsible allocating nvram room for an image. * 1. Remove the image from the directory (if exists) * 2. In case it is MIM or LIM, select the fixed nvram offset, * otherwise, use the "find_room_for_image" to find room. * 3. Add the new image_header to the directory. * * INPUT: p_dir - Pointer to directory * p_image_header - Pointer to the requested image header. * * OUTPUT: o_nvm_offset - nvm offset of the allocated room. * * RETURNS: OK / ERROR *****************************************************************************/ int allocate_nvram_for_image(struct nvm_dir *p_dir, struct image_header *p_image_header, u32 *o_nvm_offset); /***************************************************************************** * * FUNCTION: find_room_for_image * * DESCRIPTION: Finds room for new nvm image * * INPUT image_type * byte_cnt * p_dir * OUTPUT: out_nvm_offset * * RETURNS: OK/ERROR * *****************************************************************************/ int find_room_for_image(u32 image_type, u32 byte_cnt, struct nvm_dir *p_dir, u32 *out_nvm_offset); /***************************************************************************** * * FUNCTION: get_active_dir * * DESCRIPTION: Responsible allocating nvram room for an image. * 1. Read headers of both directories * 2. Validate their CRC with accordance to their sequence number. * 3. In case a directory is valid, return its id along with its next MFW. * OUTPUT: o_dir_id - Active Dir ID * o_next_mfw - Next MFW scheduled to run from the dir. * * RETURNS: OK / ERROR *****************************************************************************/ int get_active_dir(u32 *o_dir_id, u32 *o_next_mfw); /***************************************************************************** * * FUNCTION: prepare_bootstrap * * DESCRIPTION: This function updates the active NVM bootstrap. The active bootstrap is * read by the device ROM upon reset, and according to the bootstrap * information it loads LIM, which starts running the MFW. * * INPUT: i_lim_header - Image header of LIM * * OUTPUT: o_bootstrap - Bootstrap struct to be stored in nvram. * * RETURNS: none *****************************************************************************/ void prepare_bootstrap(struct image_header *i_lim_header, struct legacy_bootstrap_region *o_bootstrap); /***************************************************************************** * * FUNCTION: nvm_update_dir * * DESCRIPTION: Update directory to nvram. * * INPUT: p_dir - Pointer to the directory * is_mfw - true/false * INPUT/OUTPUT: dir_id - Input - the current dir id. Output - The updated dir id * * RETURNS: none *****************************************************************************/ int nvm_update_dir(struct nvm_dir *p_dir, u32 *dir_id, u32 is_mfw); /***************************************************************************** * * FUNCTION: add_nvm_entry_to_dir * * DESCRIPTION: Adds new image entry to a given directory. * 1. Verify number of images doesn't exceed some crazy number - 200 * 2. Since the dir is sorted according to nvram offset, move up * all image entries higher than the requested offset for the * new image entry * 3. Insert the new image entry * 4. Increase the number of entries in the directory. * * INPUT/OUTPUT p_dir - Pointer to the directory buffer * nvm_offset - The nvram address for the new image * p_image_header - Pointer to the image header. * * RETURNS: ERROR/OK *****************************************************************************/ int add_nvm_entry_to_dir(struct nvm_dir *p_dir, u32 nvm_offset, struct image_header *p_image_header); /***************************************************************************** * FUNCTION: get_alt_image_type * * DESCRIPTION: If image type is part of the MFW bundle (which has two * bundles/slots in the nvram), then set the image type as the * non-running one, otherwise, change nothing. * * INPUT: running_mfw - 0/1 * image_type * * RETURNS: Alternate image type *****************************************************************************/ u32 get_alt_image_type(u32 running_mfw, u32 image_type); /***************************************************************************** * FUNCTION: load_active_nvm_dir * * DESCRIPTION: Loads the active nvm dir to the o_dir_p * * INPUT: None * * OUTPUT: o_dir_p - Pointer to directory structure to be populated. * o_cur_dir_id - Active Dir ID * * RETURNS: OK/ERROR *****************************************************************************/ int load_active_nvm_dir(struct nvm_dir *o_dir_p, u32 *o_cur_dir_id); /***************************************************************************** * * FUNCTION: remove_image_from_dir * * DESCRIPTION: Removes requested images from a giveN dir pointer, and * squeeze images back. In case the requested image is not found, * it does nothing. * NOTE: This function doesn't recalc the CRC, or write the dir * back to nvram ! * * INPUT: p_dir - pointer to the directory * image_type - Requested image type to remove * * RETURNS: OK - Image removed * ERROR - Image not found *****************************************************************************/ int remove_image_from_dir(struct nvm_dir *p_dir, u32 image_type); /***************************************************************************** * * FUNCTION: inner_nvm_block_write * * DESCRIPTION: Internal function for writting block of data to nvram. * NOTE: 1. This function doesn't take nvram lock to allow multiple * transactions within the same page. * 2. When calling this function, please use the nvm_flags * correctly: * MCP_REG_NVM_COMMAND_FIRST - Sets the FIRST flag on the first * transaction. * MCP_REG_NVM_COMMAND_LAST - Sets the LAST flag on the last byte write. * Avoid setting this flag for multiple * transaction on the same page, and set it * only for the last one. * In any case, the LAST flag will be set at * the end of NVM page (4KB). * * INPUT: nvm_flags - MCP_REG_NVM_COMMAND_FIRST/MCP_REG_NVM_COMMAND_LAST/0 - See above * nvm_addr - Destination nvm address * byte_cnt - Number of bytes * p_buf - Pointer to the input buffer. * * RETURNS: OK - Image removed * ERROR - Image not found *****************************************************************************/ #define MCP_REG_NVM_COMMAND_DISPLAY (0x1<<31) int inner_nvm_write(u32 nvm_flags, u32 nvm_addr, u32 byte_cnt, u32 *p_buf); /********************************************************************** * FUNCTION: find_image_by_type_in_dir * * DESCRIPTION: Checks if the requested image type exist in the directory. * If so, it provide it in the output parameter index, and returns OK * Otherwise it returns ERROR; * * INPUT: dir_p - Pointer to directory * requested_type - Image type to look for * * RETURNS: OK - If requested image found * ERROR - Otherwise. ***********************************************************************/ int find_image_by_type_in_dir(struct nvm_dir *dir_p, u32 requested_type, u32 *index); #endif /* _COMMON_NVM_H_ */
