گھر > خبریں > مواد

FTDI ماخذ FT_Gpu_Hal.c

May 08, 2019

# Fclude "FT_Platform.h"


/ * API SPI انٹرفیس کو شروعات کرنے کیلئے * /

ft_bool_t Ft_Gpu_Hal_Init (Ft_Gpu_HalInit_t * halinit)

{

#ifdef ARDUINO_PLATFORM_SPI

پن موڈ (FT_ARDUINO_PRO_SPI_CS، آؤٹ پٹ)؛

پن موڈ (FT800_PD_N، آؤٹ پٹ)؛

ڈیجیٹل وائٹ (FT_ARDUINO_PRO_SPI_CS، ہائی)؛

ڈیجیٹل وائٹ (FT800_PD_N، ہائی)؛

#ختم کرو اگر


#ifdef MSVC_PLATFORM_SPI

/ * libmpsse ابتدائی * /

Init_libMPSSE ()؛

SPI_GetNum چینلز (& halinit- کل ChannelNum)؛

/ * پہلے سے طے شدہ طور پر میں یہ سمجھتا ہوں کہ صرف ایک Mpsse کیبل پی سی سے منسلک ہے اور اس مپسس کیبل 0 کے چینل سپی ٹرانزیکشن کے لئے استعمال کیا جاتا ہے * /

اگر (halinit-> کل ChannelNum> 0)

{

FT_DEVICE_LIST_INFO_NODE شیطان

SPI_GetChannelInfo (0، & devList)؛

پرنف ("چینل نمبر٪ d پر معلومات:"، 0)؛

/ * دیو معلومات پرنٹ * /

پرنف ("پرچم = 0x٪ x"، devList.Flags)؛

پرنف ("ٹائپ = 0x٪ X"، devList.Type)؛

پرنف ("ID = 0x٪ x"، devList.ID)؛

پرنف ("LocId = 0x٪ x"، devList.LocId)؛

پرنف ("سیریل نمبر =٪ s"، devList.SerialNumber)؛

پرنف ("تفصیل =٪ s"، devList.Description)؛

پرنف ("فو ہینڈل = 0x٪ x"، devList.ftHandle)؛ / * 0 ہے جب تک کھولیں * /

}

#ختم کرو اگر

درست واپسی؛

}


ft_bool_t Ft_Gpu_Hal_Open (Ft_Gpu_Hal_Context_t * میزبان)

{

#ifdef MSVC_FT800EMU

Ft_GpuEmu_SPII2C_begin ()؛

#ختم کرو اگر

#ifdef ARDUINO_PLATFORM_SPI

SPI.begin ()؛

SPI.setClockDivider (SPI_CLOCK_DIV2)؛

ایس پی آئی.setBitOrder (MSBFIRST)؛

SPI.setDataMode (SPI_MODE0)؛

#ختم کرو اگر

#ifdef MSVC_PLATFORM_SPI

ChannelConfig چینلConf؛ // چینل ترتیب

FT_STATUS کی حیثیت؛

/ * سپائی ترتیبات کو ترتیب دیں * /

channelConf.ClockRate = میزبان> hal_config.spi_clockrate_khz * 1000؛

channelConf.LatencyTimer = 2؛

channelConf.configOptions = SPI_CONFIG_OPTION_MODE0 | SPI_CONFIG_OPTION_CS_DBUS3 | SPI_CONFIG_OPTION_CS_ACTIVELOW؛

channelConf.Pin = 0x00000000؛ / * فائنل - فائن ڈائر - انٹ وول انٹری ڈائر (ڈگری 0 = میں، 1 = باہر کیلئے) * /


/ * پہلا دستیاب چینل کھولیں * /

SPI_OpenChannel (میزبان> hal_config.channel_no، (FT_HANDLE *) اور میزبان> hal_handle)؛

حیثیت = SPI_InitChannel ((FT_HANDLE) میزبان- hal_handle، اور channelConf)؛

پرنف ("ہینڈل = 0x٪ x کی حیثیت = 0x٪ ایکس"، میزبان> ہال_انڈل، حیثیت)؛

#ختم کرو اگر

میزبان - ft_cmd_fifo_wp = میزبان> ft_dl_buff_wp = 0؛

میزبان - حیثیت = FT_GPU_HAL_OPENED؛

درست واپسی؛

}


ft_void_t Ft_Gpu_Hal_Close (Ft_Gpu_Hal_Context_t * میزبان)

{

میزبان - حیثیت = FT_GPU_HAL_CLOSED؛

#ifdef MSVC_PLATFORM_SPI

/ * چینل بند کریں * /

SPI_CloseChannel (میزبان> hal_handle)؛

#ختم کرو اگر

#ifdef ARDUINO_PLATFORM_SPI

SPI.end ()؛

#ختم کرو اگر

#ifdef MSVC_FT800EMU

Ft_GpuEmu_SPII2C_end ()؛

#ختم کرو اگر

}


ft_void_t Ft_Gpu_Hal_DeInit ()

{

#ifdef MSVC_PLATFORM_SPI

// MPSSE لیب کو صاف کریں

Cleanup_libMPSSE ()؛

#ختم کرو اگر

}


/ * صرف چھوٹے بفر کے نظام کے ساتھ مسلسل مسلسل پڑھنے / تحریری لکھنے کے لئے API * /

ft_void_t Ft_Gpu_Hal_StartTransfer (Ft_Gpu_Hal_Context_t * میزبان، FT_GPU_TRANSFERDIR_T RW، ft_uint32_t addr)

{

اگر (FT_GPU_READ == rw) {

#ifdef MSVC_PLATFORM_SPI

ft_uint8_t ٹرانسفر_آریرے [4]؛

ft_uint32_t سائز منتقلی؛


/ * پڑھیں پڑھنے کے پیکٹ * /

Transfer_Array [0] = Addr >> 16؛

Transfer_Array [1] = addr >> 8؛

Transfer_Array [2] = addr؛


Transfer_Array [3] = 0؛ // ڈمی پڑھیں بائٹ

SPI_Write ((FT_HANDLE) میزبان-> hal_handle، Transfer_Array، sizeof (Transfer_Array)، اور سائز منتقلی، SPI_TRANSFER_OPTIONS_SIZE_IN_BYTES | SPI_TRANSFER_OPTIONS_CHIPSELECT_ENABLE)؛

#ختم کرو اگر

#ifdef ARDUINO_PLATFORM_SPI

ڈیجیٹل وائٹ (FT_ARDUINO_PRO_SPI_CS، LOW)؛

ایس پی آئی.transfer (اضافی >> 16)؛

ایس پی آئی.transfer (ہائی بائٹ (اضافی))؛

ایس پی آئی.transfer (lowByte (addr))؛


ایس پی آئی.transfer (0)؛ // ڈمی پڑھیں بائٹ

#ختم کرو اگر

#ifdef MSVC_FT800EMU

Ft_GpuEmu_SPII2C_StartRead (اضافی)؛

#ختم کرو اگر

میزبان - حیثیت = FT_GPU_HAL_READING؛

} else {

#ifdef MSVC_PLATFORM_SPI

ft_uint8_t ٹرانسفر_آریرے [3]؛

ft_uint32_t سائز منتقلی؛


/ * پڑھیں پڑھنے کے پیکٹ * /

Transfer_Array [0] = (0x80 | (اضافی >> 16))؛

Transfer_Array [1] = addr >> 8؛

Transfer_Array [2] = addr؛

SPI_Write ((FT_HANDLE) میزبان-> hal_handle، منتقلی آررا، 3، اور سائز منتقلی، SPI_TRANSFER_OPTIONS_SIZE_IN_BYTES | SPI_TRANSFER_OPTIONS_CHIPSELECT_ENABLE)؛

#ختم کرو اگر

#ifdef ARDUINO_PLATFORM_SPI

ڈیجیٹل وائٹ (FT_ARDUINO_PRO_SPI_CS، LOW)؛

ایس پی آئی.transfer (0x80 | (اضافی >> 16))؛

ایس پی آئی.transfer (ہائی بائٹ (اضافی))؛

ایس پی آئی.transfer (lowByte (addr))؛

#ختم کرو اگر

#ifdef MSVC_FT800EMU

Ft_GpuEmu_SPII2C_StartWrite (addr)؛

#ختم کرو اگر

میزبان - حیثیت = FT_GPU_HAL_WRITING؛

}

}


/ * تحریری منتقلی کیلئے APIs مسلسل صرف * /

ft_void_t Ft_Gpu_Hal_StartCmdTransfer (Ft_Gpu_Hal_Context_t * میزبان، FT_GPU_TRANSFERDIR_T RW، ft_uint16_t شمار)

{

Ft_Gpu_Hal_StartTransfer (میزبان، آر ٹی، میزبان- ft_cmd_fifo_wp + RAM_CMD)؛

}

ft_uint8_t Ft_Gpu_Hal_TransferString (Ft_Gpu_Hal_Context_t * میزبان، const ft_char8_t * سٹرنگ)

{

ft_uint16_t لمبائی = strlen (تار)؛

جبکہ (لمبائی -) {

Ft_Gpu_Hal_Transfer8 (میزبان، * تار)؛

سٹرنگ ++؛

}

// پرچم کو ختم کرنے کے طور پر ایک نیل شامل کریں

Ft_Gpu_Hal_Transfer8 (میزبان، 0)؛

}


ft_uint8_t Ft_Gpu_Hal_Transfer8 (Ft_Gpu_Hal_Context_t * میزبان، ft_uint8_t قیمت)

{

#ifdef ARDUINO_PLATFORM_SPI

واپسی SPI.transfer (قیمت)؛

#ختم کرو اگر

#ifdef MSVC_PLATFORM_SPI

ft_uint32_t سائز منتقلی؛

اگر (میزبان کی حیثیت == FT_GPU_HAL_WRITING) {

SPI_Write (میزبان> hal_handle، اور قیمت، sizeof (قیمت)، اور سائز منتقلی، SPI_TRANSFER_OPTIONS_SIZE_IN_BYTES)؛

} else {

SPI_Read (میزبان - hal_handle، اور قیمت، sizeof (قیمت)، اور سائز منتقلی، SPI_TRANSFER_OPTIONS_SIZE_IN_BYTES)؛

}


اگر (سائز کا منتقلی! = sizeof (قیمت)

میزبان- حیثیت = FT_GPU_HAL_STATUS_ERROR؛

واپسی کی قیمت؛

#ختم کرو اگر

#ifdef MSVC_FT800EMU

واپسی FI_GPUEmu_SPII2C_transfer (قیمت)؛

#ختم کرو اگر

}


ft_uint16_t Ft_Gpu_Hal_Transfer16 (Ft_Gpu_Hal_Context_t * میزبان، ft_uint16_t قیمت)

{

ft_uint16_t retVal = 0؛

اگر (میزبان کی حیثیت == FT_GPU_HAL_WRITING) {

Ft_Gpu_Hal_Transfer8 (میزبان، قدر اور 0xFF)؛ // ایل ایس بی سب سے پہلے

Ft_Gpu_Hal_Transfer8 (میزبان، (قدر >> 8) اور 0xFF)؛

} else {

RetVal = Ft_Gpu_Hal_Transfer8 (میزبان، 0)؛

RetVal | = (ft_uint16_t) Ft_Gpu_Hal_Transfer8 (میزبان، 0) <>

}


واپسی واپس لو

}


ft_uint32_t Ft_Gpu_Hal_Transfer32 (Ft_Gpu_Hal_Context_t * میزبان، ft_uint32_t قیمت)

{

ft_uint32_t retVal = 0؛

اگر (میزبان کی حیثیت == FT_GPU_HAL_WRITING) {

Ft_Gpu_Hal_Transfer16 (میزبان، قدر اور 0xFFFF)؛ // ایل ایس بی سب سے پہلے

Ft_Gpu_Hal_Transfer16 (میزبان، (قدر >> 16) اور 0xFFFF)؛

} else {

RetVal = Ft_Gpu_Hal_Transfer16 (میزبان، 0)؛

RetVal | = (ft_uint32_t) Ft_Gpu_Hal_Transfer16 (میزبان، 0) <>

}

واپسی واپس لو

}


ft_void_t Ft_Gpu_Hal_EndTransfer (Ft_Gpu_Hal_Context_t * میزبان)

{

#ifdef MSVC_PLATFORM_SPI

// صرف CS کو توسیع - سی ایس کے ساتھ 0 بیٹس بھیجیں غیر فعال

SPI_ToggleCS ((FT_HANDLE) میزبان- hal_handle، FALSE)؛

#ختم کرو اگر

#ifdef ARDUINO_PLATFORM_SPI

ڈیجیٹل وائٹ (FT_ARDUINO_PRO_SPI_CS، ہائی)؛

#ختم کرو اگر

#ifdef MSVC_FT800EMU

Ft_GpuEmu_SPII2C_csHigh ()؛

#ختم کرو اگر

میزبان - حیثیت = FT_GPU_HAL_OPENED؛

}


ft_uint8_t Ft_Gpu_Hal_Rd8 (Ft_Gpu_Hal_Context_t * میزبان، ft_uint32_t addr)

{

ft_uint8_t قیمت؛

Ft_Gpu_Hal_StartTransfer (میزبان، FT_GPU_READ، اضافی)؛

قیمت = Ft_Gpu_Hal_Transfer8 (میزبان، 0)؛

Ft_Gpu_Hal_EndTransfer (میزبان)؛

واپسی کی قیمت؛

}

ft_uint16_t Ft_Gpu_Hal_Rd16 (Ft_Gpu_Hal_Context_t * میزبان، ft_uint32_t addr)

{

ft_uint16_t قیمت؛

Ft_Gpu_Hal_StartTransfer (میزبان، FT_GPU_READ، اضافی)؛

قیمت = Ft_Gpu_Hal_Transfer16 (میزبان، 0)؛

Ft_Gpu_Hal_EndTransfer (میزبان)؛

واپسی کی قیمت؛

}

ft_uint32_t Ft_Gpu_Hal_Rd32 (Ft_Gpu_Hal_Context_t * میزبان، ft_uint32_t addr)

{

ft_uint32_t قیمت؛

Ft_Gpu_Hal_StartTransfer (میزبان، FT_GPU_READ، اضافی)؛

قیمت = Ft_Gpu_Hal_Transfer32 (میزبان، 0)؛

Ft_Gpu_Hal_EndTransfer (میزبان)؛

واپسی کی قیمت؛

}

ft_void_t Ft_Gpu_Hal_Wr8 (Ft_Gpu_Hal_Context_t * میزبان، ft_uint32_t addr، ft_uint8_t v)

{

Ft_Gpu_Hal_StartTransfer (میزبان، FT_GPU_WITE، اضافی)؛

Ft_Gpu_Hal_Transfer8 (میزبان، وی)؛

Ft_Gpu_Hal_EndTransfer (میزبان)؛

}

ft_void_t Ft_Gpu_Hal_Wr16 (Ft_Gpu_Hal_Context_t * میزبان، ft_uint32_t addr، ft_uint16_t v)

{

Ft_Gpu_Hal_StartTransfer (میزبان، FT_GPU_WITE، اضافی)؛

Ft_Gpu_Hal_Transfer16 (میزبان، وی)؛

Ft_Gpu_Hal_EndTransfer (میزبان)؛

}

ft_void_t Ft_Gpu_Hal_Wr32 (Ft_Gpu_Hal_Context_t * میزبان، ft_uint32_t addr، ft_uint32_t v)

{

Ft_Gpu_Hal_StartTransfer (میزبان، FT_GPU_WITE، اضافی)؛

Ft_Gpu_Hal_Transfer32 (میزبان، وی)؛

Ft_Gpu_Hal_EndTransfer (میزبان)؛

}



ft_void_t Ft_Gpu_Host کمانڈ (Ft_Gpu_Hal_Context_t * میزبان، ft_uint8_t cmd)

{

#ifdef MSVC_PLATFORM_SPI

ft_uint8_t ٹرانسفر_آریرے [3]؛

ft_uint32_t سائز منتقلی؛


Transfer_Array [0] = cmd؛

Transfer_Array [1] = 0؛

Transfer_Array [2] = 0؛


SPI_Write (میزبان - hal_handle، Transfer_Array، سائزف (ٹرانسفر_آراے)، اور سائز منتقلی، SPI_TRANSFER_OPTIONS_SIZE_IN_BYTES | SPI_TRANSFER_OPTIONS_CHIPSELECT_ENABLE | SPI_TRANSFER_OPTIONS_CHIPSELECT_DISABLE)؛

#ختم کرو اگر

#ifdef ARDUINO_PLATFORM_SPI

ڈیجیٹل وائٹ (FT_ARDUINO_PRO_SPI_CS، LOW)؛

ایس پی آئی.transfer (cmd)؛

ایس پی آئی.transfer (0)؛

ایس پی آئی.transfer (0)؛

ڈیجیٹل وائٹ (FT_ARDUINO_PRO_SPI_CS، ہائی)؛

#ختم کرو اگر

#ifdef MSVC_FT800EMU

// FT800EMU میں لاگو نہیں کیا گیا

#ختم کرو اگر

}


ft_void_t Ft_Gpu_Clock منتخب کریں (Ft_Gpu_Hal_Context_t * میزبان، FT_GPU_PLL_SOURCE_T پلگ ان)

{

Ft_Gpu_Host کمانڈ (میزبان، pllsource)؛

}

ft_void_t Ft_Gpu_PLL_Freq انتخاب (Ft_Gpu_Hal_Context_t * میزبان، FT_GPU_PLL_FREQ_T فریق)

{

Ft_Gpu_Host کمانڈ (میزبانی، freq)؛

}

ft_void_t Ft_Gpu_PowerModeSitch (Ft_Gpu_Hal_Context_t * میزبان، FT_GPU_POWER_MODE_T پیڈموڈ)

{

Ft_Gpu_Host کمانڈ (میزبان، پیرو موڈ)؛

}

ft_void_t Ft_Gpu_CoreReset (Ft_Gpu_Hal_Context_t * میزبان)

{

Ft_Gpu_HostCommand (میزبان، 0x68)؛

}


ft_void_t Ft_Gpu_Hal_Updatecmdfifo (Ft_Gpu_Hal_Context_t * میزبان، ft_uint16_t شمار)

{

میزبان- ft_cmd_fifo_wp = (میزبان> ft_cmd_fifo_wp + شمار) اور 4095؛


// 4 بائٹ سیدھ

میزبان - ft_cmd_fifo_wp = (میزبان> ft_cmd_fifo_wp + 3) & 0xffc؛

Ft_Gpu_Hal_Wr16 (میزبان، REG_CMD_WRITE، میزبان- ft_cmd_fifo_wp)؛

}


ft_uint16_t Ft_Gpu_Cmdfifo_Freespace (Ft_Gpu_Hal_Context_t * میزبان)

{

ft_uint16_t پورٹیبل، ریٹل؛


پورٹیبل = (میزبان - ft_cmd_fifo_wp - Ft_Gpu_Hal_Rd16 (میزبان، REG_CMD_READ)) اور 40 995؛

ریٹال = (FT_CMD_FIFO_SIZE - 4) - مکملی؛

واپسی (ریٹل)؛

}

ft_void_t Ft_Gpu_Hal_WrCmdBuf (Ft_Gpu_Hal_Context_t * میزبان، ft_uint8_t * بفر، ft_uint16_t شمار)

{

ft_uint32_t لمبائی = 0، سائز منتقلی = 0؛

#define MAX_CMD_FIFO_TRANSFER Ft_Gpu_Cmdfifo_Freespace (میزبان)

کیا {

لمبائی = شمار؛

اگر (لمبائی> MAX_CMD_FIFO_TRANSFER) {

لمبائی = MAX_CMD_FIFO_TRANSFER؛

}

Ft_Gpu_Hal_CheckCmdBuffer (میزبان، لمبائی)؛


Ft_Gpu_Hal_StartCmdTransfer (میزبان، FT_GPU_WITE، لمبائی)؛

#if وضاحت (ARDUINO_PLATFORM_SPI) || وضاحت (MSVC_FT800EMU)

سائز منتقل = 0؛

جبکہ (لمبائی -) {

Ft_Gpu_Hal_Transfer8 (میزبان، * بفر)؛

بفر ++؛

سائز منتقلی ++؛

}

لمبائی = سائز منتقلی؛

#ختم کرو اگر


#ifdef MSVC_PLATFORM_SPI

{

SPI_Write (میزبان> hal_handle، بفر، لمبائی، اور سائز منتقلی، SPI_TRANSFER_OPTIONS_SIZE_IN_BYTES)؛

لمبائی = سائز منتقلی؛

بفر + = سائز منتقلی؛

}

#ختم کرو اگر

Ft_Gpu_Hal_EndTransfer (میزبان)؛

Ft_Gpu_Hal_Updatecmdfifo (میزبان، لمبائی)؛


Ft_Gpu_Hal_WaitCmdfifo_empty (میزبان)؛


شمار - = لمبائی؛

} جبکہ (شمار> 0)؛

}

#ifdef ARDUINO_PLATFORM_SPI

ft_void_t Ft_Gpu_Hal_WrCmdBufFromFlash (Ft_Gpu_Hal_Context_t * میزبان، FT_PROGMEM ft_prog_uchar8_t * بفر، ft_uint16_t شمار)

{

ft_uint32_t لمبائی = 0، سائز منتقلی = 0؛

#define MAX_CMD_FIFO_TRANSFER Ft_Gpu_Cmdfifo_Freespace (میزبان)

کیا {

لمبائی = شمار؛

اگر (لمبائی> MAX_CMD_FIFO_TRANSFER) {

لمبائی = MAX_CMD_FIFO_TRANSFER؛

}

Ft_Gpu_Hal_CheckCmdBuffer (میزبان، لمبائی)؛


Ft_Gpu_Hal_StartCmdTransfer (میزبان، FT_GPU_WITE، لمبائی)؛



سائز منتقل = 0؛

جبکہ (لمبائی -) {

Ft_Gpu_Hal_Transfer8 (میزبان، ft_pgm_read_byte_near (بفر))؛

بفر ++؛

سائز منتقلی ++؛

}

لمبائی = سائز منتقلی؛


Ft_Gpu_Hal_EndTransfer (میزبان)؛

Ft_Gpu_Hal_Updatecmdfifo (میزبان، لمبائی)؛


Ft_Gpu_Hal_WaitCmdfifo_empty (میزبان)؛


شمار - = لمبائی؛

} جبکہ (شمار> 0)؛

}

#ختم کرو اگر

ft_void_t Ft_Gpu_Hal_CheckCmdBuffer (Ft_Gpu_Hal_Context_t * میزبان، ft_uint16_t شمار)

{

ft_uint16_t getfreespace؛

کیا{

getfreespace = Ft_Gpu_Cmdfifo_Freespace (میزبان)؛

} جبکہ (getfreespace <>

}

ft_void_t Ft_Gpu_Hal_WaitCmdfifo_empty (Ft_Gpu_Hal_Context_t * میزبان)

{

جبکہ (Ft_Gpu_Hal_Rd16 (میزبان، REG_CMD_READ)! = Ft_Gpu_Hal_Rd16 (میزبان، REG_CMD_WITE))؛

میزبان- ft_cmd_fifo_wp = Ft_Gpu_Hal_Rd16 (میزبان، REG_CMD_WITE)؛

}

ft_void_t Ft_Gpu_Hal_WrCmdBuf_nowait (Ft_Gpu_Hal_Context_t * میزبان، ft_uint8_t * بفر، ft_uint16_t شمار)

{

ft_uint32_t لمبائی = 0، سائز منتقلی = 0؛

#define MAX_CMD_FIFO_TRANSFER Ft_Gpu_Cmdfifo_Freespace (میزبان)

کیا {

لمبائی = شمار؛

اگر (لمبائی> MAX_CMD_FIFO_TRANSFER) {

لمبائی = MAX_CMD_FIFO_TRANSFER؛

}

Ft_Gpu_Hal_CheckCmdBuffer (میزبان، لمبائی)؛


Ft_Gpu_Hal_StartCmdTransfer (میزبان، FT_GPU_WITE، لمبائی)؛


// # ifdef ARDUINO_PLATFORM_SPI

#if وضاحت (ARDUINO_PLATFORM_SPI) || وضاحت (MSVC_FT800EMU)

سائز منتقل = 0؛

جبکہ (لمبائی -) {

Ft_Gpu_Hal_Transfer8 (میزبان، * بفر)؛

بفر ++؛

سائز منتقلی ++؛

}

لمبائی = سائز منتقلی؛

#ختم کرو اگر

#ifdef MSVC_PLATFORM_SPI

{

SPI_Write (میزبان> hal_handle، بفر، لمبائی، اور سائز منتقلی، SPI_TRANSFER_OPTIONS_SIZE_IN_BYTES)؛

لمبائی = سائز منتقلی؛

بفر + = سائز منتقلی؛

}

#ختم کرو اگر


Ft_Gpu_Hal_EndTransfer (میزبان)؛

Ft_Gpu_Hal_Updatecmdfifo (میزبان، لمبائی)؛


// // Ft_Gpu_Hal_WaitCmdfifo_empty (میزبان)؛


شمار - = لمبائی؛

} جبکہ (شمار> 0)؛

}



ft_uint8_t Ft_Gpu_Hal_WaitCmdfifo_empty_status (Ft_Gpu_Hal_Context_t * میزبان)

{

اگر (Ft_Gpu_Hal_Rd16 (میزبان، REG_CMD_READ)! = Ft_Gpu_Hal_Rd16 (میزبان، REG_CMD_WRITE))

{

واپسی 0؛

}

اور

{

میزبان- ft_cmd_fifo_wp = Ft_Gpu_Hal_Rd16 (میزبان، REG_CMD_WITE)؛

واپسی 1؛

}

}


ft_void_t Ft_Gpu_Hal_WaitLogo_Finish (Ft_Gpu_Hal_Context_t * میزبان)

{

ft_int16_t cmdrdptr، سینٹی میٹر ڈرائیو؛


کیا{

cmdrdptr = Ft_Gpu_Hal_Rd16 (میزبان، REG_CMD_READ)؛

cmdwrptr = Ft_Gpu_Hal_Rd16 (میزبان، REG_CMD_WITE)؛

} جبکہ ((سینٹیڈیشنر! = سینٹی ڈی آرڈیٹری) || (سینٹی ڈیڈیٹری! = 0))؛

میزبان - ft_cmd_fifo_wp = 0؛

}


ft_void_t Ft_Gpu_Hal_ResetCmdFifo (Ft_Gpu_Hal_Context_t * میزبان)

{

میزبان - ft_cmd_fifo_wp = 0؛

}


ft_void_t Ft_Gpu_Hal_WrCmd32 (Ft_Gpu_Hal_Context_t * میزبان، ft_uint32_t cmd)

{

Ft_Gpu_Hal_CheckCmdBuffer (میزبان، sizeof (cmd))؛

Ft_Gpu_Hal_Wr32 (میزبان، RAM_CMD + میزبان- ft_cmd_fifo_wp، cmd)؛

Ft_Gpu_Hal_Updatecmdfifo (میزبان، sizeof (cmd))؛

}


ft_void_t Ft_Gpu_Hal_ResetDLBuffer (Ft_Gpu_Hal_Context_t * میزبان)

{

میزبان - ft_dl_buff_wp = 0؛

}

/ * پاور سائیکل کے لئے FT800 بورڈ کے PD_N پن ٹگل * /

ft_void_t Ft_Gpu_Hal_Powercycle (Ft_Gpu_Hal_Context_t * میزبان، ft_bool_t)

{

اگر (اوپر)

{

#ifdef MSVC_PLATFORM

FT_WriteGPIO (میزبان> hal_handle، 0xBB، 0x08)؛ // PDN سیٹ 0، FT800 بورڈ کے PDN # پر MPSSE کے بلیو تار سے رابطہ قائم کریں.

Ft_Gpu_Hal_Sleep (20)؛


FT_WriteGPIO (میزبان> hal_handle، 0xBB، 0x88)؛ // PDN سیٹ 1

Ft_Gpu_Hal_Sleep (20)؛

#ختم کرو اگر

#ifdef ARDUINO_PLATFORM

ڈیجیٹل وائٹ (FT800_PD_N، LOW)؛

Ft_Gpu_Hal_Sleep (50)؛


ڈیجیٹل وائٹ (FT800_PD_N، ہائی)؛

Ft_Gpu_Hal_Sleep (50)؛

#ختم کرو اگر

} اور

{

#ifdef MSVC_PLATFORM

FT_WriteGPIO (میزبان> hal_handle، 0xBB، 0x88)؛ // PDN سیٹ 1

Ft_Gpu_Hal_Sleep (20)؛

FT_WriteGPIO (میزبان> hal_handle، 0xBB، 0x08)؛ // PDN سیٹ 0، FT800 بورڈ کے PDN # پر MPSSE کے بلیو تار سے رابطہ قائم کریں.

Ft_Gpu_Hal_Sleep (20)؛

#ختم کرو اگر

#ifdef ARDUINO_PLATFORM

ڈیجیٹل وائٹ (FT800_PD_N، ہائی)؛

Ft_Gpu_Hal_Sleep (20)؛

ڈیجیٹل وائٹ (FT800_PD_N، LOW)؛

Ft_Gpu_Hal_Sleep (20)؛

#ختم کرو اگر

}

}



ft_void_t Ft_Gpu_Hal_WrMemFromFlash (Ft_Gpu_Hal_Context_t * میزبان، ft_uint32_t addr، const ft_prog_uchar8_t * بفر، ft_uint32_t لمبائی)

{

ft_uint32_t سائز = منتقلی = 0؛


Ft_Gpu_Hal_StartTransfer (میزبان، FT_GPU_WITE، اضافی)؛


#if وضاحت (ARDUINO_PLATFORM_SPI) || وضاحت (MSVC_FT800EMU)

جبکہ (لمبائی -) {

Ft_Gpu_Hal_Transfer8 (میزبان، ft_pgm_read_byte_near (بفر))؛

بفر ++؛

}

#ختم کرو اگر


#ifdef MSVC_PLATFORM_SPI

{

SPI_Write ((FT_HANDLE) میزبان-> hal_handle، بفر، لمبائی، اور سائز منتقلی، SPI_TRANSFER_OPTIONS_SIZE_IN_BYTES)؛

}

#ختم کرو اگر



Ft_Gpu_Hal_EndTransfer (میزبان)؛

}


ft_void_t Ft_Gpu_Hal_WrMem (Ft_Gpu_Hal_Context_t * میزبان، ft_uint32_t addr، const ft_uint8_t * buffer، ft_uint32_t لمبائی)

{

ft_uint32_t سائز = منتقلی = 0؛


Ft_Gpu_Hal_StartTransfer (میزبان، FT_GPU_WITE، اضافی)؛


#if وضاحت (ARDUINO_PLATFORM_SPI) || وضاحت (MSVC_FT800EMU)

جبکہ (لمبائی -) {

Ft_Gpu_Hal_Transfer8 (میزبان، * بفر)؛

بفر ++؛

}

#ختم کرو اگر


#ifdef MSVC_PLATFORM_SPI

{

SPI_Write ((FT_HANDLE) میزبان-> hal_handle، بفر، لمبائی، اور سائز منتقلی، SPI_TRANSFER_OPTIONS_SIZE_IN_BYTES)؛

}

#ختم کرو اگر



Ft_Gpu_Hal_EndTransfer (میزبان)؛

}



ft_void_t Ft_Gpu_Hal_RdMem (Ft_Gpu_Hal_Context_t * میزبان، ft_uint32_t addr، ft_uint8_t * بفر، ft_uint32_t لمبائی)

{

ft_uint32_t سائز = منتقلی = 0؛


Ft_Gpu_Hal_StartTransfer (میزبان، FT_GPU_READ، اضافی)؛


#if وضاحت (ARDUINO_PLATFORM_SPI) || وضاحت (MSVC_FT800EMU)

جبکہ (لمبائی -) {

* بفر = Ft_Gpu_Hal_Transfer8 (میزبان، 0)؛

بفر ++؛

}

#ختم کرو اگر


#ifdef MSVC_PLATFORM_SPI

{

SPI_Read ((FT_HANDLE) میزبان-> hal_handle، بفر، لمبائی، اور سائز منتقلی، SPI_TRANSFER_OPTIONS_SIZE_IN_BYTES)؛

}

#ختم کرو اگر


Ft_Gpu_Hal_EndTransfer (میزبان)؛

}


ft_int32_t Ft_Gpu_Hal_Dec2Asici (ft_char8_t * pSrc، ft_int32_t قیمت)

{

ft_int16_t لمبائی؛

ft_char8_t * pdst، charval؛

ft_int32_t CurrVal = قیمت، tmpval، میں؛

ft_char8_t tmparray [16]، idx = 0؛


لمبائی = strlen (pSrc)؛

pdst = pSrc + لمبائی؛


اگر (0 == قیمت)

{

* pdst ++ = '0'؛

* pdst ++ = ''؛

واپسی 0؛

}


اگر (نصاب <>

{

* pdst ++ = '-'؛

CurrVal = - CurrVal؛

}

/ * قیمت ڈالیں * /

جبکہ (CurrVal> 0) {

tmpval = CurrVal؛

CurrVal = = 10؛

tmpval = tmpval - CurrVal * 10؛

چارول = '0' + tmpval؛

tmparray [idx ++] = charval؛

}


کے لئے (i = 0؛ i

{

* pdst ++ = tmparray [idx - i - 1]؛

}

* pdst ++ = ''؛


واپسی 0؛

}


ft_void_t Ft_Gpu_Hal_Sleep (ft_uint16_t ایس ایس)

{

#if وضاحت (MSVC_PLATFORM) || وضاحت (MSVC_FT800EMU)

نیند (ایم ایس)؛

#ختم کرو اگر

#ifdef ARDUINO_PLATFORM

تاخیر (ایس ایم)؛

#ختم کرو اگر

}