| /* |
| * Copyright (c) 2017, The Linux Foundation. All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions are |
| * met: |
| * * Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * * Redistributions in binary form must reproduce the above |
| * copyright notice, this list of conditions and the following |
| * disclaimer in the documentation and/or other materials provided |
| * with the distribution. |
| * * Neither the name of The Linux Foundation nor the names of its |
| * contributors may be used to endorse or promote products derived |
| * from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED |
| * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF |
| * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT |
| * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS |
| * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR |
| * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF |
| * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR |
| * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, |
| * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE |
| * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN |
| * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| |
| #ifndef _FLASH_SECTIONS_H_ |
| #define _FLASH_SECTIONS_H_ |
| |
| #include "wiburn.h" |
| #include "ini_parser_types.h" |
| #include "flash.h" |
| #include "CCRC32.h" |
| |
| enum tag_ids { |
| image_format_version_tag_id = 0x1, |
| fw_version_tag_id = 0x2, |
| fw_timestamp_tag_id = 0x3, |
| usb_format_version_tag_id = 0x1, |
| usb_version_tag_id = 0x2, |
| usb_timestamp_tag_id = 0x3, |
| configuration_id_tag_id = 0x4, |
| device_id_tag_id = 0x5, |
| hw_id_tag_id = 0x6, |
| end_tag_id = 0xff |
| }; |
| |
| #pragma pack(push, 1) |
| template <class PRODUCT> |
| struct pointers_t |
| { |
| typename PRODUCT::REG signature; |
| ADDRESS32 hw_pointer; |
| ADDRESS32 fw1_pointer; |
| typename PRODUCT::REG fw1_length; |
| ADDRESS32 fw1_data_pointer; |
| typename PRODUCT::REG fw1_data_length; |
| ADDRESS32 fw2_pointer; |
| typename PRODUCT::REG fw2_length; |
| ADDRESS32 fw2_data_pointer; |
| typename PRODUCT::REG fw2_data_length; |
| ADDRESS32 production_pointer; |
| ADDRESS32 ids_pointer; |
| typename PRODUCT::REG pointer_section_version; |
| ADDRESS32 fw1_static_conf_pointer; |
| ADDRESS32 fw2_static_conf_pointer; |
| ADDRESS32 config_section_pointer; |
| ADDRESS32 image_info_pointer; |
| ADDRESS32 radio_tx_cnf_pointer; |
| ADDRESS32 radio_rx_cnf_pointer; |
| ADDRESS32 radio_tx_cnf2_pointer; |
| ADDRESS32 radio_rx_cnf2_pointer; |
| ADDRESS32 raw_data_pointer; |
| typename PRODUCT::REG raw_data_length; |
| |
| // Unused |
| ADDRESS32 usb_pointer; |
| ADDRESS32 usb_info_pointer; |
| ADDRESS32 user_pointer; |
| }; |
| #pragma pack(pop) |
| |
| #pragma pack(push, 1) |
| template <class PRODUCT> |
| struct address_value_t |
| { |
| typename PRODUCT::ADDRESS address; |
| typename PRODUCT::REG value; |
| }; |
| #pragma pack(pop) |
| |
| #pragma pack(push, 1) |
| template <class PRODUCT> |
| struct address_value_mask_t |
| { |
| typename PRODUCT::ADDRESS address; |
| typename PRODUCT::REG value; |
| typename PRODUCT::REG mask; |
| }; |
| #pragma pack(pop) |
| |
| |
| #pragma pack(push, 1) |
| struct tag_header_t |
| { |
| BYTE reserved; |
| BYTE tag_id; |
| u_int16_t tag_size; |
| void disp(const char *name); |
| }; |
| #pragma pack(pop) |
| |
| #pragma pack(push, 1) |
| struct format_version_tag_t |
| { |
| BYTE format_version; |
| BYTE reserved [3]; |
| void disp(const char *name); |
| }; |
| #pragma pack(pop) |
| |
| #pragma pack(push, 1) |
| struct version_tag_t |
| { |
| u_int32_t minor : 8; |
| u_int32_t major : 8; |
| u_int32_t build : 13; |
| u_int32_t sub_minor : 3; |
| void disp(const char *name); |
| }; |
| #pragma pack(pop) |
| |
| #pragma pack(push, 1) |
| struct timestamp_tag_t |
| { |
| BYTE min; |
| BYTE hour; |
| BYTE reserved1; |
| BYTE sec; |
| BYTE month; |
| BYTE day; |
| u_int16_t year; |
| void disp(const char *name); |
| }; |
| #pragma pack(pop) |
| |
| #pragma pack(push, 1) |
| struct configuration_id_tag_t |
| { |
| BYTE id [16]; |
| void disp(const char *name); |
| }; |
| #pragma pack(pop) |
| |
| #pragma pack(push, 1) |
| struct device_id_tag_t |
| { |
| u_int16_t device_id; |
| BYTE revision_id; |
| BYTE misc; |
| void disp(const char *name); |
| }; |
| #pragma pack(pop) |
| |
| #pragma pack(push, 1) |
| struct hw_id_tag_t |
| { |
| BYTE digital_soc_id; |
| BYTE board_id; |
| BYTE antenna_id; |
| BYTE rf_id; |
| u_int16_t serial_id; |
| u_int16_t reserved; |
| void disp(const char *name); |
| }; |
| #pragma pack(pop) |
| |
| #pragma pack(push, 1) |
| struct end_tag_t |
| { |
| u_int16_t reserved1; |
| u_int16_t reserved2; |
| void disp(const char *name); |
| }; |
| #pragma pack(pop) |
| |
| class tag_base_t |
| { |
| public: |
| virtual char *get_tag() = 0; |
| tag_base_t (BYTE id, const char* name); |
| virtual ~tag_base_t() {}; |
| virtual void disp() = 0; |
| public: |
| tag_header_t m_header; |
| const char *m_name; |
| }; |
| |
| template <class Tag> |
| class tag_t: public tag_base_t |
| { |
| public: |
| char *get_tag(); |
| tag_t (BYTE id, const char* name = 0); |
| virtual ~tag_t() {}; |
| void disp(); |
| public: |
| Tag m_tag; |
| }; |
| |
| |
| #pragma pack(push, 1) |
| struct section_header_t |
| { |
| BYTE reserved; |
| BYTE section_id; |
| u_int16_t section_size; |
| }; |
| #pragma pack(pop) |
| |
| class flash_section |
| { |
| public: |
| flash_section (const char *name); |
| virtual void write_to_buffer(BYTE *buffer ) = 0; |
| int size () const; |
| int get_max_size () const; |
| void set_max_size ( u_int32_t max_size ); |
| void set_offset (u_int32_t offset); |
| u_int32_t get_offset () const; |
| virtual ~flash_section() {}; |
| protected: |
| u_int32_t m_size; |
| u_int32_t m_max_size; |
| u_int32_t m_offset; |
| const char *m_name; |
| u_int32_t m_crc; |
| CCRC32 m_CalcCRC; |
| }; |
| |
| class usb_section_t : public flash_section |
| { |
| public: |
| //usb_section_t (const char *name, u_int16_t *ptr_low, u_int16_t* ptr_high); |
| usb_section_t (const char *name, ADDRESS32 *ptr); |
| void write_to_buffer(BYTE *buffer ) ; |
| void handle_ini_section (const ini_section_t &ini_section); |
| void set_offset (int offset); |
| ~usb_section_t(); |
| public: |
| IMAGE *m_buffer; |
| // u_int16_t *m_ptr_low; |
| // u_int16_t *m_ptr_high; |
| ADDRESS32 *m_ptr; |
| }; |
| |
| class id_section : public flash_section |
| { |
| public: |
| //id_section (const char *name, BYTE id, u_int16_t *ptr_low, u_int16_t* ptr_high); |
| id_section (const char *name, BYTE id, ADDRESS32 *ptr); |
| void set_offset (int offset); |
| |
| public: |
| section_header_t header; |
| // u_int16_t *m_ptr_low; |
| // u_int16_t *m_ptr_high; |
| ADDRESS32 *m_ptr; |
| }; |
| |
| class variable_section_t : public id_section |
| { |
| public: |
| // variable_section_t (const char *name, BYTE id, u_int16_t *ptr_low, u_int16_t *ptr_high); |
| variable_section_t (const char *name, BYTE id, ADDRESS32 *ptr); |
| ~variable_section_t (); |
| protected: |
| int m_buffer_size; |
| }; |
| |
| template <class PRODUCT> |
| class hw_section_t : public variable_section_t |
| { |
| public: |
| // hw_section_t (const char *name, BYTE id, u_int16_t *ptr_low, u_int16_t *ptr_high); |
| hw_section_t (const char *name, BYTE id, ADDRESS32 *ptr); |
| public: |
| void handle_ini_section (u_int8_t translation_map_bits, const ini_section_t &ini_section); |
| void init (flash_base *flash); |
| bool operator == (const hw_section_t &r_side) const; |
| void write_to_buffer(BYTE *buffer ) ; |
| ~hw_section_t (); |
| address_value_t <PRODUCT> *m_buffer; |
| u_int16_t *m_length; |
| u_int32_t m_termination [2]; |
| |
| }; |
| |
| template <class PRODUCT> |
| class fw_section_t : public variable_section_t |
| { |
| public: |
| //fw_section_t (const char *name, BYTE id, u_int16_t *ptr_low, u_int16_t *ptr_high); |
| fw_section_t (const char *name, BYTE id, ADDRESS32 *ptr); |
| public: |
| void handle_ini_section (u_int8_t translation_map_bits, const ini_section_t &ini_section); |
| void write_to_buffer(BYTE *buffer ) ; |
| ~fw_section_t (); |
| address_value_mask_t <PRODUCT> *m_buffer; |
| }; |
| |
| template <class PRODUCT> |
| class image_section_t : public variable_section_t |
| { |
| public: |
| //image_section_t (const char *name, BYTE id, u_int16_t *ptr_low, u_int16_t *ptr_high, u_int16_t *length); |
| image_section_t (const char *name, BYTE id, ADDRESS32 *ptr, typename PRODUCT::REG *length); |
| void handle_ini_section (const ini_section_t &ini_section); |
| void write_to_buffer(BYTE *buffer ) ; |
| void set_offset (int offset); |
| ~image_section_t (); |
| public: |
| IMAGE *m_buffer; |
| //u_int16_t *m_length; |
| typename PRODUCT::REG *m_length; |
| }; |
| |
| template <class PRODUCT> |
| class pointer_section_t : public flash_section |
| { |
| public: |
| pointer_section_t (const char *name); |
| void init (flash_base *fl); |
| void write_to_buffer(BYTE *buffer ) ; |
| bool operator == (const pointer_section_t <PRODUCT> &r_side) const; |
| public: |
| pointers_t <PRODUCT> m_pointers; |
| }; |
| |
| template <class PRODUCT> |
| class info_section_t : public variable_section_t |
| { |
| public: |
| typedef vector <tag_base_t*> tag_vector_t; |
| public: |
| // info_section_t (const char *name, BYTE id, u_int16_t *ptr_low, u_int16_t *ptr_high); |
| info_section_t (const char *name, BYTE id, ADDRESS32 *ptr); |
| virtual void handle_ini_section (const ini_section_t &ini_section, |
| const string &name) = 0; |
| virtual void init (flash_base *flash) = 0; |
| void write_to_buffer(BYTE *buffer ) ; |
| ~info_section_t (); |
| void disp() const; |
| |
| public: |
| tag_vector_t m_tags; |
| u_int16_t *m_length; |
| }; |
| |
| template <class PRODUCT> |
| class image_info_section_t : public info_section_t<PRODUCT> |
| { |
| public: |
| //image_info_section_t (const char *name, BYTE id, u_int16_t *ptr_low, u_int16_t *ptr_high); |
| image_info_section_t (const char *name, BYTE id, ADDRESS32 *ptr); |
| void handle_ini_section (const ini_section_t &ini_section, |
| const string &name); |
| void init (flash_base *fl); |
| ~image_info_section_t (); |
| }; |
| |
| template <class PRODUCT> |
| class usb_info_section_t : public info_section_t<PRODUCT> |
| { |
| public: |
| // usb_info_section_t (const char *name, BYTE id, u_int16_t *ptr_low, u_int16_t *ptr_high); |
| usb_info_section_t (const char *name, BYTE id, ADDRESS32 *ptr); |
| void handle_ini_section (const ini_section_t &ini_section, |
| const string &name); |
| void init (flash_base *fl); |
| ~usb_info_section_t (); |
| }; |
| |
| template <class PRODUCT> |
| class system_config_section_t : public flash_section |
| { |
| public: |
| system_config_section_t (const char *name, ADDRESS32 *ptr); |
| void set_offset (int offset); |
| void write_to_buffer(BYTE *buffer ) ; |
| |
| public: |
| ADDRESS32 *m_ptr; |
| }; |
| |
| |
| #pragma pack(push, 1) |
| struct ids_section |
| { |
| BYTE reserved1; |
| BYTE version; |
| BYTE mac_address [6]; |
| BYTE ssid [32]; |
| u_int16_t local; |
| u_int16_t reserved2; |
| u_int16_t ppm; |
| u_int16_t reserved3; |
| u_int32_t board_type; |
| u_int16_t lo_power_xif_gc; |
| u_int16_t lo_power_stg2_bias; |
| u_int16_t vga_bias; |
| u_int16_t vga_stg1_fine_bias; |
| u_int16_t ats_ver; |
| u_int16_t mlt_ver; |
| u_int16_t bl_ver; |
| u_int16_t lo_power_gc_ctrl; |
| u_int16_t production1; |
| u_int16_t production2; |
| u_int16_t production3; |
| u_int16_t production4; |
| u_int16_t production5; |
| u_int16_t production6; |
| u_int16_t production7; |
| u_int16_t production8; |
| u_int16_t production9; |
| u_int16_t production10; |
| u_int16_t production11; |
| u_int16_t production12; |
| u_int16_t production13; |
| u_int16_t production14; |
| u_int16_t production15; |
| u_int16_t production16; |
| }; |
| #pragma pack(pop) |
| |
| template <typename T, class PRODUCT> |
| struct const_section_t: public id_section |
| { |
| public: |
| // const_section_t (const char *name, BYTE id, u_int16_t *ptr_low, u_int16_t* ptr_high); |
| const_section_t (const char *name, BYTE id, ADDRESS32 *ptr); |
| virtual void handle_ini_section (const ini_section_t &ini_section) = 0; |
| void write_to_buffer(BYTE *buffer ) ; |
| virtual void init (flash_base *fl); |
| virtual void initReduced (flash_base *fl, int reductionSize); |
| public: |
| T m_section; |
| }; |
| |
| |
| template <class PRODUCT> |
| struct ids_section_t: public const_section_t <ids_section, PRODUCT> |
| { |
| public: |
| // ids_section_t (const char *name, BYTE id, u_int16_t *ptr_low, u_int16_t* ptr_high); |
| ids_section_t (const char *name, BYTE id, ADDRESS32 *ptr); |
| void handle_ini_section (const ini_section_t &ini_section); |
| void disp() const; |
| void disp_to_file(const char* ids_ini_file) const; |
| }; |
| #endif //#ifndef _FLASH_SECTIONS_H_ |