| /* |
| * 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. |
| */ |
| |
| #pragma once |
| |
| #include <string> |
| #include "WlctPciAcss.h" |
| #include "flashacss.h" |
| |
| #ifdef _WINDOWS |
| #ifdef FLSHACSS_EXPORTS |
| #define FLSHACSS_CPP_API __declspec(dllexport) |
| #else |
| #define FLSHACSS_CPP_API __declspec(dllimport) |
| #endif |
| #else //#ifdef _WINDOWS |
| #define FLSHACSS_CPP_API |
| #endif //#ifdef _WINDOWS |
| |
| #define BUFFER_NOT_READY -1 |
| #define BUFFER_OK 0 |
| |
| extern "C" |
| { |
| class FLSHACSS_CPP_API flash_base |
| { |
| public: |
| enum { |
| //FLASH_SIZE_SWIFT = 256*1024, |
| FLASH_SIZE_SPARROW = 1024*512, |
| //FLASH_SIZE_MARLON = 1024*1024, |
| FLASH_SIZE_MARLON = 1024*512, |
| FLASH_SIZE_TALYN = 1024*512*4 |
| }; |
| flash_base(DType device_type) |
| : m_bExit(false) |
| , deviceType(device_type) |
| , m_size(0) |
| { |
| if (device_type == MST_SPARROW) |
| m_size = FLASH_SIZE_SPARROW; |
| if (device_type == MST_MARLON) |
| m_size = FLASH_SIZE_MARLON; |
| if (device_type == MST_TALYN) |
| m_size = FLASH_SIZE_TALYN; |
| else |
| m_size = FLASH_SIZE_TALYN; |
| }; |
| virtual ~flash_base(void) {}; |
| virtual int open (const char *device_name, DType dtype, bool ignore_lock) = 0; |
| virtual int open (void *m_pDeviceAccss, DType dtype, bool ignore_lock) = 0; |
| virtual void close () = 0; |
| virtual int read( const u_int32_t address, const u_int32_t length, BYTE *buffer ) const = 0; |
| virtual int write( const u_int32_t address, const u_int32_t length, const BYTE *buffer, bool verify ) = 0; |
| virtual int program( const u_int32_t address, const u_int32_t length, const BYTE *buffer, bool verify ) = 0; |
| virtual int erase (void) = 0; |
| virtual void clear_erased( u_int32_t page_offset ) = 0; |
| |
| void set_exit_flag(bool bExit); |
| DType GetDeviceType() |
| { |
| return deviceType; |
| } |
| |
| protected: |
| bool m_bExit; |
| DType deviceType; |
| u_int32_t m_size; |
| }; |
| |
| class FLSHACSS_CPP_API flash: public flash_base |
| { |
| public: |
| flash(DType device_type); |
| virtual ~flash(void); |
| virtual int open (const char *device_name, DType dtype, bool ignore_lock); |
| virtual int open (void *m_pDeviceAccss, DType dtype, bool ignore_lock); |
| virtual void close (); |
| virtual int read( const u_int32_t address, const u_int32_t length, BYTE *buffer ) const; |
| virtual int read_async( const u_int32_t address, const u_int32_t length); |
| int write( const u_int32_t address, const u_int32_t length, const BYTE *buffer, bool verify ); |
| int program( const u_int32_t address, const u_int32_t length, const BYTE *buffer, bool verify ); |
| virtual int erase (void); |
| bool get_flag_reading_not_done () {return flag_reading_not_done; }; |
| void set_flag_reading_not_done (bool new_val) {flag_reading_not_done = new_val;}; |
| void* get_buffer_ptr () {return m_buffer; }; |
| void free_buffer (); |
| |
| u_int32_t get_address () {return m_address; }; |
| u_int32_t get_length () {return m_length; }; |
| |
| |
| public: |
| enum { |
| FLASH_PAGE_SIZE = 256, |
| PAGES_PER_SUB_SECTOR = 16, |
| SUB_SECTOR_SIZE = PAGES_PER_SUB_SECTOR * FLASH_PAGE_SIZE, |
| SUB_SECTORS_PER_SECTOR = 16, |
| SECTOR_SIZE = SUB_SECTORS_PER_SECTOR * SUB_SECTOR_SIZE, |
| #ifdef FLASH_256KB |
| SECTORS_PER_FLASH = 4, // support 1MB flash |
| #else |
| //SECTORS_PER_FLASH = 16, // support 1MB flash |
| SECTORS_PER_FLASH = 8, // support 0.5MB flash |
| #endif |
| }; |
| |
| public: |
| struct { |
| BYTE manufacturer_id; |
| BYTE device_id1; |
| BYTE device_id2; |
| BYTE extended_string_length; |
| char extended_string [256]; // maximal size |
| } m_info; // according to JEDEC standard |
| |
| protected: |
| int page_erase(u_int32_t offset); |
| int sector_erase(u_int32_t address); |
| virtual int sub_sector_erase(u_int32_t address); |
| virtual int page_write_program( const u_int32_t address, const u_int16_t length, const BYTE *buffer, u_int8_t type ); |
| int wait_wip (void) const; |
| int write_wen (void) const; |
| u_int8_t get_status(void) const; |
| void update_erased_page (u_int32_t offset, bool erased ); |
| void update_erased_sub_sector (u_int32_t offset, bool erased ); |
| void update_erased_sector (u_int32_t offset, bool erased ); |
| void update_erased_flash ( bool erased ); |
| bool is_erased( u_int32_t page_offset ) const; |
| void clear_erased( u_int32_t page_offset ); |
| int retrive_info(); |
| |
| protected: |
| bool *m_page_erased; |
| u_int32_t m_hw_read_chunk_size; |
| u_int32_t m_hw_write_chunk_size; |
| |
| #if _WINDOWS |
| HANDLE m_thread; |
| #else |
| pthread_t m_thread; |
| #endif |
| |
| protected: |
| // string m_device_name; |
| |
| protected: |
| enum FlashCommand { |
| FC_WREN = 0x06, |
| FC_WRDI = 0x04, |
| FC_RDID = 0x9F, |
| FC_RDSR = 0x05, |
| FC_WRLR = 0xE5, |
| FC_WRSR = 0x01, |
| FC_RDLR = 0xE8, |
| FC_READ = 0x03, |
| FC_FAST_READ = 0x0B, |
| FC_PW = 0x0A, |
| FC_PP = 0x02, |
| FC_PE = 0xDB, |
| FC_SSE = 0x20, |
| FC_SE = 0xD8, |
| FC_BE = 0xC7, |
| FC_DP = 0xB9, |
| FC_RDP = 0xAB |
| }; |
| private: |
| // flash_gateway* m_flash_gateway; |
| void* m_pDeviceAccss; |
| void* m_pFlashAccss; |
| |
| bool flag_reading_not_done; |
| u_int32_t m_address; |
| u_int32_t m_length; |
| BYTE* m_buffer; |
| }; |
| |
| |
| class FLSHACSS_CPP_API flash_file: public flash |
| { |
| public: |
| flash_file(DType device_type); |
| ~flash_file(void); |
| virtual int read( const u_int32_t address, const u_int32_t length, BYTE *buffer ) const; |
| virtual int erase (); |
| virtual int open (const char *device_name, DType dtype, bool ignore_lock); |
| virtual int open (void *m_pDeviceAccss, DType dtype, bool ignore_lock) |
| { |
| //do something with params |
| (void)m_pDeviceAccss; |
| (void)dtype; |
| (void)ignore_lock; |
| return -1; |
| } |
| virtual void close (); |
| |
| private: |
| virtual int page_write_program( const u_int32_t address, const u_int16_t length, const BYTE *buffer, u_int8_t type ); |
| virtual int sub_sector_erase(u_int32_t address); |
| private: |
| mutable char *m_buffer; |
| void *m_handler; |
| }; |
| }; |