// ============================================================================= // boot_IspiGetData // ----------------------------------------------------------------------------- /// Get one datum. /// /// This functions gets one element of 32 bits from the ISPI Rx Fifo. /// If the Fifo was empty at the time #boot_IspiGetData() is called, 0 /// is returned and \c recData is untainted. Otherwise one datum is get /// from the Fifo and 1 is returned /// /// @param recData Pointer to store the received datum. /// @return Returns the number of received data (1 or 0, if the Fifo is empty). // ============================================================================= PUBLIC UINT32 boot_IspiGetData(UINT32* recData) { UINT32 nbAvailable; // Enter critical section. UINT32 status = hwp_sysIrq->SC; nbAvailable = GET_BITFIELD(hwp_spi3->status, SPI_RX_LEVEL); if (nbAvailable > 0) { *recData = hwp_spi3->rxtx_buffer; // Exit critical section. hwp_sysIrq->SC = status; return 1; } else { // Exit critical section. hwp_sysIrq->SC = status; return 0; } }
static PyObject * b_get(void *ptr, Py_ssize_t size) { signed char val = *(signed char *)ptr; GET_BITFIELD(val, size); return PyInt_FromLong(val); }
// ============================================================================= // boot_IspiRxFifoLevel // ----------------------------------------------------------------------------- /// Get data quantity in the Spi Rx FIFO. /// /// @return The number of 32 bits data items in the Rx FIFO. // ============================================================================= PUBLIC UINT8 boot_IspiRxFifoLevel(VOID) { UINT8 rxLevel; // Get level rxLevel = GET_BITFIELD(hwp_spi3->status, SPI_RX_LEVEL); return rxLevel; }
// ============================================================================= // boot_UartMonitorGet // ----------------------------------------------------------------------------- /// Read some bytes and actualizes the checksum. /// @param data Array where read bytes will be stored /// @param size Number of bytes to receive. /// @param checksum Pointer to the value to XOR the read byte to calculate /// the checksum. // ============================================================================= PROTECTED BOOT_UM_ERR_T boot_UartMonitorGet(UINT8* data, UINT32 size, UINT8* checksum) { UINT32 i; UINT32 offset = 0; UINT32 startTime; BOOL onTime = TRUE; for (i=0; i<size; i++) { startTime = hwp_timer->HWTimer_CurVal; if (startTime > 0x80000000) { offset = 0x80000000; } while ((GET_BITFIELD(hwp_uart->status, UART_RX_FIFO_LEVEL) == 0) && (onTime = ((hwp_timer->HWTimer_CurVal+offset) < (startTime + offset + BOOT_UART_MONITOR_RX_TIME_OUT)))); if (!onTime) { return BOOT_UM_ERR_RX_FAILED; } data[i] = hwp_uart->rxtx_buffer; *checksum ^= data[i]; } return BOOT_UM_ERR_NO; }
static PyObject * B_get(void *ptr, Py_ssize_t size) { unsigned char val = *(unsigned char *)ptr; GET_BITFIELD(val, size); return PyLong_FromLong(val); }
// ============================================================================= // boot_UartMonitorSend // ----------------------------------------------------------------------------- /// Basic sending function. Done on polling, check /// TX fifo availability and wait for room if needed. /// /// @param data Data to send /// @param length Number of byte to send. /// @param checksum Pointer to the UINT8 holding the CRC of the frame /// this transmitting is as part of. /// @return #BOOT_UM_ERR_NO or #BOOT_UM_ERR_RESOURCE_TIMEOUT; // ============================================================================= PROTECTED BOOT_UM_ERR_T boot_UartMonitorSend(UINT8* data, UINT32 length, UINT8* checksum) { UINT32 i; UINT32 offset = 0; UINT32 startTime; BOOL onTime = TRUE; for (i=0 ; i<length ; i++) { startTime = hwp_timer->HWTimer_CurVal; if (startTime > 0x80000000) { offset = 0x80000000; } // Place in the TX Fifo ? while ((GET_BITFIELD(hwp_uart->status, UART_TX_FIFO_SPACE) == 0) && (onTime = (hwp_timer->HWTimer_CurVal+offset < startTime + offset + BOOT_UART_MONITOR_TX_TIME_OUT))); if (!onTime) { return BOOT_UM_ERR_TX_FAILED; } hwp_uart->rxtx_buffer = data[i]; *checksum ^= data[i]; } return BOOT_UM_ERR_NO; }
// ============================================================================= // boot_IspiSendData // ----------------------------------------------------------------------------- /// Send one data. /// This functions sends one data frame. /// The number returned is the number of data frames actually sent. /// /// @param csId The CS to use to send the data. This cs must be activated before /// sending data. /// @param data Frame of data to send. /// @param read \c TRUE if the response of the device to this sent data is /// expected to be read later and thus will be put in the read Fifo. /// @return 1 if the data was sent, 0 otherwise. // ============================================================================= PUBLIC UINT32 boot_IspiSendData(BOOT_ISPI_CS_T csId, UINT32 data, BOOL read) { UINT32 freeRoom; // Clear data upper bit to only keep the data frame. UINT32 reg = data & ~(SPI_CS_MASK | SPI_READ_ENA_MASK); // Add CS and read mode bit reg |= SPI_CS(csId) | (read?SPI_READ_ENA:0); // Enter critical section. UINT32 status = hwp_sysIrq->SC; // Check FIFO availability. freeRoom = GET_BITFIELD(hwp_spi3->status, SPI_TX_SPACE); if (freeRoom > 0) { // Write data. hwp_spi3->rxtx_buffer = reg; // Exit critical section. hwp_sysIrq->SC = status; return 1; } else { // Exit critical section. hwp_sysIrq->SC = status; return 0; } }
static PyObject * Q_get(void *ptr, Py_ssize_t size) { unsigned PY_LONG_LONG val; memcpy(&val, ptr, sizeof(val)); GET_BITFIELD(val, size); return PyLong_FromUnsignedLongLong(val); }
static PyObject * i_get(void *ptr, Py_ssize_t size) { int val; memcpy(&val, ptr, sizeof(val)); GET_BITFIELD(val, size); return PyInt_FromLong(val); }
static PyObject * H_get(void *ptr, Py_ssize_t size) { unsigned short val; memcpy(&val, ptr, sizeof(val)); GET_BITFIELD(val, size); return PyLong_FromLong(val); }
static PyObject * l_get(void *ptr, Py_ssize_t size) { long val; memcpy(&val, ptr, sizeof(val)); GET_BITFIELD(val, size); return PyLong_FromLong(val); }
static PyObject * q_get_sw(void *ptr, Py_ssize_t size) { PY_LONG_LONG val; memcpy(&val, ptr, sizeof(val)); val = SWAP_8(val); GET_BITFIELD(val, size); return PyLong_FromLongLong(val); }
static PyObject * l_get_sw(void *ptr, Py_ssize_t size) { long val; memcpy(&val, ptr, sizeof(val)); val = SWAP_LONG(val); GET_BITFIELD(val, size); return PyInt_FromLong(val); }
// ============================================================================= // boot_IspiTxFifoAvail // ----------------------------------------------------------------------------- /// Get available data spaces in the Spi Tx FIFO. /// This function returns the available space in the Tx FIFO, as a number /// of 32 bits data that can be filled into it. /// /// @return The size of the available space in the Tx FIFO. (In Fifo elements.) // ============================================================================= PUBLIC UINT8 boot_IspiTxFifoAvail(VOID) { UINT8 freeRoom; // Get avail level. freeRoom = GET_BITFIELD(hwp_spi3->status, SPI_TX_SPACE); return freeRoom; }
static PyObject * L_get_sw(void *ptr, Py_ssize_t size) { unsigned long val; memcpy(&val, ptr, sizeof(val)); val = SWAP_LONG(val); GET_BITFIELD(val, size); return PyLong_FromUnsignedLong(val); }
static PyObject * i_get_sw(void *ptr, Py_ssize_t size) { int val; memcpy(&val, ptr, sizeof(val)); val = SWAP_INT(val); GET_BITFIELD(val, size); return PyLong_FromLong(val); }
// ============================================================================= // boot_HstMonitor // ----------------------------------------------------------------------------- /// Main host monitor function. Read the command passed to the platform through /// the Host port and call the host command handler if appropriate. /// It read the H2P register to execute commands /// until the Exit command is received (BOOT_HST_MONITOR_END_CMD). // ============================================================================= PROTECTED BOOT_MONITOR_OP_STATUS_T boot_HstMonitor(VOID) { BOOT_HST_CMD_T hostCommand = 0; // Clear the "enter the monitor" host command // if a host command present if((hostCommand = GET_BITFIELD(hwp_debugHost->h2p_status, DEBUG_HOST_H2P_STATUS)) != 0) { // We received a command: we are not waiting anymore but actually acting // as a monitor. hwp_debugHost->p2h_status = BOOT_HST_STATUS_NONE; switch (hostCommand) { case BOOT_HST_MONITOR_START_CMD: // That command used to be used to enter into the monitor. // We now use a boot mode for that, so this command is // just used to send the BOOT_HST_MONITOR_START event // to acknowledge to the host (eg Remote PC's coolwatcher) // that we actually are in the monitor. mon_Event(BOOT_HST_MONITOR_START); hwp_debugHost->h2p_status = DEBUG_HOST_H2P_STATUS_RST; break; case BOOT_HST_MONITOR_X_CMD: // Execute a command placed in the execution structure. // H2P_Status is cleared in the basic handler boot_HstCmdBasicHandler(); break; case BOOT_HST_MONITOR_END_CMD: // We are required to leave the monitor. mon_Event(BOOT_HST_MONITOR_END); hwp_debugHost->h2p_status = DEBUG_HOST_H2P_STATUS_RST; return BOOT_MONITOR_OP_STATUS_EXIT; default: // unsupported command mon_Event(BOOT_HST_UNSUPPORTED_CMD); hwp_debugHost->h2p_status = DEBUG_HOST_H2P_STATUS_RST; break; } // We received a command, possibly unknown, but different from // BOOT_HST_MONITOR_END_CMD; return BOOT_MONITOR_OP_STATUS_CONTINUE; } else { // No command received. return BOOT_MONITOR_OP_STATUS_NONE; } }
/************************************************ * 函数名称:write_data * 功能说明:LCD写数据函数 * 参数说明:d为数据,为一个BYTE的数据 * 函数返回:无 * 修改时间:2014-1-14 已经测试 *************************************************/ void write_data(unsigned char d) { dcx=1; sdi=(GET_BITFIELD(d))->bit7;scl=0;scl=1; sdi=(GET_BITFIELD(d))->bit6;scl=0;scl=1; sdi=(GET_BITFIELD(d))->bit5;scl=0;scl=1; sdi=(GET_BITFIELD(d))->bit4;scl=0;scl=1; sdi=(GET_BITFIELD(d))->bit3;scl=0;scl=1; sdi=(GET_BITFIELD(d))->bit2;scl=0;scl=1; sdi=(GET_BITFIELD(d))->bit1;scl=0;scl=1; sdi=(GET_BITFIELD(d))->bit0;scl=0;scl=1; }
/************************************************ * 函数名称:write_command * 功能说明:LCD写指令函数 * 参数说明:c为指令 * 函数返回:无 * 修改时间:2014-1-14 已经测试 *************************************************/ void write_command(unsigned char c) { dcx=0; sdi=(GET_BITFIELD(c))->bit7;scl=0;scl=1; sdi=(GET_BITFIELD(c))->bit6;scl=0;scl=1; sdi=(GET_BITFIELD(c))->bit5;scl=0;scl=1; sdi=(GET_BITFIELD(c))->bit4;scl=0;scl=1; sdi=(GET_BITFIELD(c))->bit3;scl=0;scl=1; sdi=(GET_BITFIELD(c))->bit2;scl=0;scl=1; sdi=(GET_BITFIELD(c))->bit1;scl=0;scl=1; sdi=(GET_BITFIELD(c))->bit0;scl=0;scl=1; }
// ============================================================================= // hal_IfcTransferStart // ----------------------------------------------------------------------------- /// Start an IFC transfer /// /// This is a non blocking function that starts the transfer /// and returns the hand. /// /// @param requestId Describe the direction of the tranfer (rx or /// tx) and the module to or from which data are to be moved. /// @param memStartAddr. Start address of the buffer where data /// to be sent are located or where to put the data read, according /// to the request defined by the previous parameter /// @param xferSize Number of bytes to transfer. The maximum size /// is 2^20 - 1 bytes. /// @param ifcMode Mode of the transfer (Autodisable or not, 8 or 32 bits) /// @return Channel got or HAL_UNKNOWN_CHANNEL. // ============================================================================= PROTECTED UINT8 hal_IfcTransferStart(HAL_IFC_REQUEST_ID_T requestId, UINT8* memStartAddr, UINT32 xferSize, HAL_IFC_MODE_T ifcMode) { // Check buffer alignment depending on the mode if (ifcMode != HAL_IFC_SIZE_8_MODE_MANUAL && ifcMode != HAL_IFC_SIZE_8_MODE_AUTO) { // Then ifcMode == HAL_IFC_SIZE_32, check word alignment HAL_ASSERT(((UINT32)memStartAddr%4) == 0, "HAL IFC: 32 bits transfer misaligned 0x@%08X", memStartAddr); } else { // ifcMode == HAL_IFC_SIZE_8, nothing to check } HAL_ASSERT(xferSize < (1<<SYS_IFC_TC_LEN), "HAL IFC: Transfer size too large: %d", xferSize); UINT32 status = hal_SysEnterCriticalSection(); UINT8 channel; UINT8 i; // Check the requested id is not currently already used. for (i = 0; i < SYS_IFC_STD_CHAN_NB ; i++) { if (GET_BITFIELD(hwp_sysIfc->std_ch[i].control, SYS_IFC_REQ_SRC) == requestId) { // This channel is or was used for the requestId request. // Check it is still in use. HAL_ASSERT((hwp_sysIfc->std_ch[i].status & SYS_IFC_ENABLE) == 0, "HAL: Attempt to use the IFC to deal with a %d" " request still active on channel %d", requestId, i); } } channel = SYS_IFC_CH_TO_USE(hwp_sysIfc->get_ch) ; if (channel >= SYS_IFC_STD_CHAN_NB) { hal_SysExitCriticalSection(status); return HAL_UNKNOWN_CHANNEL; } g_halModuleIfcChannelOwner[channel] = requestId; hwp_sysIfc->std_ch[channel].start_addr = (UINT32) memStartAddr; hwp_sysIfc->std_ch[channel].tc = xferSize; hwp_sysIfc->std_ch[channel].control = (SYS_IFC_REQ_SRC(requestId) | ifcMode #if (CHIP_HAS_ASYNC_TCU) | SYS_IFC_CH_RD_HW_EXCH #endif | SYS_IFC_ENABLE); hal_SysExitCriticalSection(status); return channel; }
/** @details -# While there is data in memory that has not been written to disk -# Write out each of the other parameter values to the temporary #writer_buff -# Write #writer_buff to the output file */ int Trick::DRBinary::format_specific_write_data(unsigned int writer_offset) { unsigned long bf; int sbf; unsigned int ii ; unsigned int len = 0 ; char *address = 0 ; /* Write out all parameters */ for (ii = 0; ii < rec_buffer.size() ; ii++) { address = rec_buffer[ii]->buffer + ( writer_offset * rec_buffer[ii]->ref->attr->size ) ; switch (rec_buffer[ii]->ref->attr->type) { case TRICK_CHARACTER: case TRICK_UNSIGNED_CHARACTER: case TRICK_SHORT: case TRICK_UNSIGNED_SHORT: case TRICK_BOOLEAN: case TRICK_ENUMERATED: case TRICK_INTEGER: case TRICK_UNSIGNED_INTEGER: case TRICK_FLOAT: case TRICK_LONG: case TRICK_UNSIGNED_LONG: case TRICK_LONG_LONG: case TRICK_UNSIGNED_LONG_LONG: case TRICK_STRUCTURED: case TRICK_DOUBLE: memcpy(writer_buff + len, address, (size_t)rec_buffer[ii]->ref->attr->size); break; case TRICK_BITFIELD: sbf = GET_BITFIELD(address, rec_buffer[ii]->ref->attr->size, rec_buffer[ii]->ref->attr->index[0].start, rec_buffer[ii]->ref->attr->index[0].size); memcpy(writer_buff + len, &sbf, (size_t)rec_buffer[ii]->ref->attr->size); break; case TRICK_UNSIGNED_BITFIELD: bf = GET_UNSIGNED_BITFIELD(address, rec_buffer[ii]->ref->attr->size, rec_buffer[ii]->ref->attr->index[0].start, rec_buffer[ii]->ref->attr->index[0].size); memcpy(writer_buff + len, &bf, (size_t)rec_buffer[ii]->ref->attr->size); break; default: break; } len += rec_buffer[ii]->ref->attr->size ; } write( fp , writer_buff , len) ; return(0) ; }
// ============================================================================= // boot_IspiSendDataBuffer // ----------------------------------------------------------------------------- /// Send a bunch of data. /// This functions sends \c length data (Number of 32 bits words) starting from /// the address \c start_address. These data have previously been prepared to /// be sent by using the #BOOT_ISPI_CS() and #BOOT_ISPI_REQ_READ macros. /// The number returned is the number of data actually sent. (Number of 32 bits /// items.) /// In DMA mode, this function returns 0 when no DMA channel is available, it /// returns length otherwise. /// /// @param startAddress Pointer on the buffer to send /// @param length number of bytes to send (Up to 4 kB). /// @param mode Mode of the transfer (Direct or DMA). /// @return When in DMA mode, returns 0 if no DMA channel is available. \n /// In direct mode or DMA mode with an available channel, returns the /// number of data (32 bits words) sent. // ============================================================================= PUBLIC UINT32 boot_IspiSendDataBuffer(CONST UINT32* startAddress, UINT32 length, BOOT_ISPI_TRANSFERT_MODE_T mode) { // FIXME Add a kind of semaphore to ensure there is no concurrent access. UINT32 i; UINT32 freeRoom; if (mode == BOOT_ISPI_DIRECT_POLLING) { // ----------------------------- // DIRECT TRANSFER // ----------------------------- // Enter critical section. UINT32 status = hwp_sysIrq->SC; freeRoom = GET_BITFIELD(hwp_spi3->status, SPI_TX_SPACE); if (freeRoom > length) { freeRoom = length; } // Send data byte by byte. for (i = 0; i < freeRoom; i++) { hwp_spi3->rxtx_buffer = *(startAddress + i); } // Exit critical section. hwp_sysIrq->SC = status; return freeRoom; } else { // ----------------------------- // DMA TRANSFER // ----------------------------- // We transfer 32 bits items (4 bytes) g_bootIspiProperties.txIfcCh = boot_IspiIfcTransferStart(BOOT_ISPI_IFC_REQ_TX, (UINT32*)startAddress, length*4); // get IFC channel and start if any available if (g_bootIspiProperties.txIfcCh == BOOT_ISPI_IFC_UNKNOWN_CHANNEL) { // No channel available. // No data received. return 0; } else { // all data will be fetched. return length; } } }
// ============================================================================= // boot_IspiGetDataBuffer // ----------------------------------------------------------------------------- /// Get a bunch of data. /// /// This functions gets \c length 32 bits data from the ISPI and stores them /// starting from the address \c destAddress. The number returned is the number /// of 32-bits data item actually received. In DMA mode, this function returns /// 0 when no DMA channel is available. It returns length otherwise. /// /// @param destAddress Pointer on the buffer to store received data /// @param length Number of byte to receive. /// @param mode Mode of the transfer (Direct or DMA). /// @return When in DMA mode, returns 0 if no DMA channel is available. \n /// In direct mode or DMA mode with an available channel, returns the /// number of received 32 bits data. // ============================================================================= PUBLIC UINT32 boot_IspiGetDataBuffer(UINT32* destAddress, UINT32 length, BOOT_ISPI_TRANSFERT_MODE_T mode) { UINT32 i; UINT32 nbAvailable; if (mode == BOOT_ISPI_DIRECT_POLLING) { // ----------------------------- // DIRECT TRANSFER // ----------------------------- // Enter critical section. UINT32 status = hwp_sysIrq->SC; nbAvailable = GET_BITFIELD(hwp_spi3->status, SPI_RX_LEVEL); if (nbAvailable > length) { nbAvailable = length; } // Get data byte by byte. for (i = 0; i < nbAvailable; i++) { *(destAddress + i) = hwp_spi3->rxtx_buffer; } // Exit critical section. hwp_sysIrq->SC = status; return nbAvailable; } else { // ----------------------------- // DMA TRANSFER // ----------------------------- // We transfer 32 bits items (4 bytes) g_bootIspiProperties.rxIfcCh = boot_IspiIfcTransferStart(BOOT_ISPI_IFC_REQ_RX, destAddress, length*4); // Get IFC channel and start if any available if (g_bootIspiProperties.rxIfcCh == BOOT_ISPI_IFC_UNKNOWN_CHANNEL) { // No channel available. // No data received. return 0; } else { // All data will be fetched. return length; } } }
// ============================================================================= // boot_IspiIfcChannelRelease // ----------------------------------------------------------------------------- /// Force the release of a channel owned by a request. /// /// The channel is only released if the specified request /// owns the channel. /// /// @param requestId Describe the direction of the tranfer (rx or /// tx) and the module to or from which data are to be moved. /// @param channel Channel to release // ============================================================================= PRIVATE VOID boot_IspiIfcChannelRelease(UINT32 requestId, UINT8 channel) { UINT32 status; // Here, we consider the transfer as previously finished. if (channel == BOOT_ISPI_IFC_UNKNOWN_CHANNEL) return; status = hwp_sysIrq->SC; if (GET_BITFIELD(hwp_sysIfc->std_ch[channel].control, SYS_IFC_REQ_SRC) == requestId) { // Disable this channel. hwp_sysIfc->std_ch[channel].control = (SYS_IFC_REQ_SRC(requestId) | SYS_IFC_CH_RD_HW_EXCH | SYS_IFC_DISABLE); hwp_sysIfc->std_ch[channel].tc = 0; } hwp_sysIrq->SC = status; }
// ============================================================================= // boot_IspiTxFinished // ----------------------------------------------------------------------------- /// Check if the last transfer is done. /// This function returns \c TRUE when the transmit FIFO is empty and when the /// last byte is completely sent. It should be called before closing the ISPI if /// the last bytes of the transfer are important.\n /// This function should not be called between transfers, in direct or DMA mode. /// The @link #boot_IspiTxFifoLevel FIFO level @endlink for direct mode and the /// @link #boot_IspiTxDmaDone DMA done indication @endlink for DMA allow /// for a more optimized transmission. /// /// @return \c TRUE if the last tranfer is done and the Tx FIFO empty.\n /// \c FALSE otherwise. // ============================================================================= PUBLIC BOOL boot_IspiTxFinished(VOID) { UINT32 spiStatus; spiStatus = hwp_spi3->status; // If ISPI FSM is active and the TX Fifo is empty // (ie available space == Fifo size), the tf is not done if ((!(hwp_spi3->status & SPI_ACTIVE_STATUS)) && (SPI_TX_FIFO_SIZE == GET_BITFIELD(spiStatus, SPI_TX_SPACE))) { return TRUE; } else { return FALSE; } }
PRIVATE VOID boot_UsbConfig(VOID) { UINT8 i; UINT16 addr; UINT8 dir; // Nb EP g_BootUsbVar.NbEp = GET_BITFIELD(hwp_usbc->GHWCFG2, USBC_NUMDEVEPS); g_BootUsbVar.NbEp++; // Rx Fifo Size hwp_usbc->GRXFSIZ = RXFIFOSIZE; addr = RXFIFOSIZE; // EP direction and Tx fifo configuration hwp_usbc->GNPTXFSIZ = USBC_NPTXFSTADDR(addr) | USBC_NPTXFDEPS(TXFIFOSIZE); addr += TXFIFOSIZE; for(i = 1; i < g_BootUsbVar.NbEp; i++) { dir = EPDIR(i); if(dir == EPIN || dir == EPINOUT) { hwp_usbc->DIEPTXF[i-1].DIEnPTXF = USBC_IENPNTXFSTADDR(addr) | USBC_INEPNTXFDEP(TXFIFOSIZE); addr += TXFIFOSIZE; } } hwp_usbc->GAHBCFG = USBC_DMAEN | USBC_HBSTLEN(INCR4); hwp_usbc->GAHBCFG |= USBC_GLBLINTRMSK; hwp_usbc->GUSBCFG |= USBC_PHYIF | USBC_USBTRDTIM(5); hwp_usbc->DCFG &= ~(USBC_DEVSPD_MASK | USBC_PERFRINT_MASK); // Configure FS USB 1.1 Phy hwp_usbc->DCFG |= USBC_DEVSPD(3); hwp_usbc->GINTMSK |= USBC_USBRST | USBC_ENUMDONE | USBC_ERLYSUSP | USBC_USBSUSP; }
// ============================================================================= // boot_HstUartSend // ----------------------------------------------------------------------------- /// Basic sending function. Done on polling, check /// TX fifo availability and wait for room if needed. /// /// @param data Data to send /// @param length Number of byte to send. /// @param checksum Pointer to the UINT8 holding the CRC of the frame /// this transmitting is as part of. /// @return #BOOT_UM_ERR_NO or #BOOT_UM_ERR_RESOURCE_TIMEOUT; // ============================================================================= PROTECTED BOOT_UM_ERR_T boot_HstUartSend(UINT8* data, UINT32 length, UINT8* checksum) { UINT32 i; UINT32 startTime; BOOL onTime = TRUE; for (i=0 ; i<length ; i++) { startTime = hwp_timer->HWTimer_CurVal; // Place in the TX Fifo ? while ((GET_BITFIELD(hwp_debugUart->status, DEBUG_UART_TX_FIFO_LEVEL) == DEBUG_UART_TX_FIFO_SIZE) && (onTime = ((hwp_timer->HWTimer_CurVal - startTime) < BOOT_UART_MONITOR_TX_TIME_OUT))); if (!onTime) { return BOOT_UM_ERR_TX_FAILED; } hwp_debugUart->rxtx_buffer = data[i]; *checksum ^= data[i]; } return BOOT_UM_ERR_NO; }
PRIVATE UINT8 boot_UsbContinueTransfert(UINT8 ep) { UINT8 epNum; REG32* regSize; REG32* regCtl; epNum = HAL_USB_EP_NUM(ep); if(HAL_USB_IS_EP_DIRECTION_IN(ep)) { if(g_BootUsbVar.InTransfert[epNum].size <= 0) { return(1); } if(!(g_BootUsbVar.EpFlag & (1<<epNum))) { if(g_BootUsbVar.InTransfert[epNum].size >= HAL_USB_MPS) { if(epNum == 0) { regSize = &hwp_usbc->DIEPTSIZ0; regCtl = &hwp_usbc->DIEPCTL0; } else { regSize = &hwp_usbc->DIEPnCONFIG[epNum-1].DIEPTSIZ; regCtl = &hwp_usbc->DIEPnCONFIG[epNum-1].DIEPCTL; } *regSize = USBC_IEPXFERSIZE(g_BootUsbVar.InTransfert[epNum].size % HAL_USB_MPS) | USBC_IEPPKTCNT(1); *regCtl |= USBC_EPENA | USBC_CNAK; g_BootUsbVar.InTransfert[epNum].size = 1; return(0); } } g_BootUsbVar.InTransfert[epNum].size = 0; } else { if(g_BootUsbVar.OutTransfert[epNum].size <= 0) { return(1); } if(epNum == 0) { regSize = &hwp_usbc->DOEPTSIZ0; } else { regSize = &hwp_usbc->DOEPnCONFIG[epNum-1].DOEPTSIZ; } g_BootUsbVar.OutTransfert[epNum].size -= GET_BITFIELD(*regSize, USBC_OEPXFERSIZE); g_BootUsbVar.OutTransfert[epNum].size = -g_BootUsbVar.OutTransfert[epNum].size; if(g_BootUsbVar.OutTransfert[epNum].size > 0) { g_BootUsbVar.OutTransfert[epNum].size = 0; } } return(1); }
int ref_to_value(REF2 * R, V_DATA * V) { char *cp; unsigned char *ucp; char **cpp; #ifndef __Lynx__ wchar_t **wcpp; #endif short *shp; int *ip; long *lp; float *fp; double *dp; long long *llp; int bf; unsigned int ubf; int type; char *address = 0; /* * This function is called from within the YACC parser. * This function relies on the REF data structure to be filled -- * YACC fills part of the REF struct and ref_attributes() fills * the rest. * * This function will get the value of the parameter pointed by REF and * returns the value in param_right_ret. */ /* I'm trying to keep from casting integer values to doubles and back again, esp. for long longs, for they could get changed in all of the conversions */ // if (R->deprecated) { // /* Removed input_processor as a parameter to ref_to_value for simplification but that means we no longer know // what I->print_deprecated is. Heck with it -- always print out this warning here. */ // //send_hs(stderr, "\n[33mWARNING: Deprecated variable referenced:[00m\n" // // "%s\nReturning value = 0.\n", R->reference); // V->type = R->attr->type; // V->value.ll = 0; // return (MM_NO_ERROR); // } type = R->attr->type; /* treat C++ bool reference as an unsigned char */ if (type == TRICK_BOOLEAN) { type = TRICK_UNSIGNED_CHARACTER; } address = R->address; // if ((R->num_index < R->attr->num_index - 1) || ((R->address_req == 0) && (R->num_index < R->attr->num_index))) { // type = VOID_PTR; // } V->type = type; switch (type) { case TRICK_VOID_PTR: //if ((R->num_index < R->attr->num_index - 1) || ((R->address_req == 0) && (R->num_index < R->attr->num_index))) { // V->value.vp = address; //} else { V->value.vp = *(void **) address; // } break; case TRICK_CHARACTER: cp = address; V->value.c = *cp; break; case TRICK_UNSIGNED_CHARACTER: #if ( __linux | __sgi ) case TRICK_BOOLEAN: #endif ucp = (unsigned char *) address; V->value.c = (char) *ucp; break; case TRICK_STRING: cpp = (char **) address; V->value.cp = *cpp; break; case TRICK_WSTRING: #ifndef __Lynx__ wcpp = (wchar_t **) address; V->value.wcp = *wcpp; #endif break; case TRICK_SHORT: case TRICK_UNSIGNED_SHORT: shp = (short *) address; V->value.s = *shp; V->type = TRICK_SHORT; break; case TRICK_INTEGER: case TRICK_ENUMERATED: case TRICK_UNSIGNED_INTEGER: #if ( __sun | __APPLE__ ) case TRICK_BOOLEAN: #endif ip = (int *) address; V->value.i = *ip; break; case TRICK_LONG: case TRICK_UNSIGNED_LONG: lp = (long *) address; V->value.ll = (long long) *lp; break; case TRICK_FLOAT: fp = (float *) address; V->value.f = *fp; break; case TRICK_DOUBLE: dp = (double *) address; V->value.d = *dp; V->type = TRICK_DOUBLE; break; case TRICK_LONG_LONG: case TRICK_UNSIGNED_LONG_LONG: llp = (long long *) address; V->value.ll = *llp; V->type = TRICK_LONG_LONG; break; case TRICK_BITFIELD: bf = GET_BITFIELD(address, R->attr->size, R->attr->index[0].start, R->attr->index[0].size); if (R->attr->size == sizeof(int)) { } else if (R->attr->size == sizeof(short)) { } else if (R->attr->size == sizeof(char)) { } else { // ERROR } // TODO: always integer? or should we return short or char for those types? V->value.i = bf; V->type = TRICK_INTEGER; break; case TRICK_UNSIGNED_BITFIELD: ubf = GET_UNSIGNED_BITFIELD(address, R->attr->size, R->attr->index[0].start, R->attr->index[0].size); // TODO: always integer? or should we return short or char for those types? V->value.i = (int) ubf; V->type = TRICK_UNSIGNED_INTEGER; break; } return (MM_OK); }
int Trick::VariableServerThread::write_binary_data( int Start, char *buf1, int PacketNum ) { int i; int ret ; int HeaderSize, MessageSize; int NumVariablesProcessed; unsigned int msg_type , offset, len ; unsigned int size ; unsigned int swap_int ; char * address = 0 ; char* param_name; //remove warning for unused PacketNum... to be deleted. (void)PacketNum ; /* start the offset 4 bytes into the message, we'll subtract the sizeof offset at the end */ offset = sizeof(msg_type) + sizeof(offset) ; /* if we are here the msg_type is good, so send a 0, swapped or not 0 is still 0 */ msg_type = VS_VAR_LIST ; memcpy(buf1, &msg_type , sizeof(msg_type)) ; HeaderSize = sizeof(msg_type); offset += sizeof(unsigned int) ; HeaderSize += sizeof(unsigned int); for (i = Start; i < (int)vars.size() ; i++) { // data to send was copied to buffer in copy_sim_data address = (char *)vars[i]->buffer_out; size = vars[i]->size ; param_name = vars[i]->ref->reference; len = strlen(param_name) ; // when var_binary_nonames, do not put the variable names into the message to be sent if (binary_data_nonames) { MessageSize = sizeof(int) + sizeof(size) + size ; } else { MessageSize = sizeof(len) + len + sizeof(int) + sizeof(size) + size ; } /* make sure this message will fit in a packet by itself */ if ( (HeaderSize + MessageSize) > MAX_MSG_LEN ) { message_publish(MSG_WARNING, "%p Variable Server buffer[%d] too small (need %d) for symbol %s, SKIPPING IT.\n", &connection, MAX_MSG_LEN, (int)(HeaderSize + MessageSize), vars[i]->ref->reference ); continue; } if ( (offset + MessageSize) < MAX_MSG_LEN ) { if (byteswap) { if (!binary_data_nonames) { swap_int = trick_byteswap_int((int)len) ; memcpy(&buf1[offset] , &swap_int , sizeof(len)) ; offset += sizeof(len) ; memcpy(&buf1[offset] , param_name , (size_t)len) ; offset += len ; } swap_int = trick_byteswap_int(vars[i]->ref->attr->type) ; memcpy(&buf1[offset] , &swap_int , sizeof(int)) ; offset += sizeof(int) ; swap_int = trick_byteswap_int((int)size) ; memcpy(&buf1[offset] , &swap_int , sizeof(size)) ; offset += sizeof(size) ; /* TODO: There is a bug here, this call will want to swap the entire buffer, we may not have the whole buffer */ trick_bswap_buffer(&buf1[offset], address, vars[i]->ref->attr, 1); offset += size ; } else { int temp_i ; unsigned int temp_ui ; if (!binary_data_nonames) { memcpy(&buf1[offset] , &len , sizeof(len)) ; offset += sizeof(len) ; memcpy(&buf1[offset] , param_name , (size_t)len) ; offset += len ; } memcpy(&buf1[offset] , &vars[i]->ref->attr->type , sizeof(int)) ; offset += sizeof(int) ; memcpy(&buf1[offset] , &size , sizeof(size)) ; offset += sizeof(size) ; switch ( vars[i]->ref->attr->type ) { case TRICK_BITFIELD: temp_i = GET_BITFIELD(address , vars[i]->ref->attr->size , vars[i]->ref->attr->index[0].start, vars[i]->ref->attr->index[0].size) ; memcpy(&buf1[offset] , &temp_i , (size_t)size) ; break ; case TRICK_UNSIGNED_BITFIELD: temp_ui = GET_UNSIGNED_BITFIELD(address , vars[i]->ref->attr->size , vars[i]->ref->attr->index[0].start, vars[i]->ref->attr->index[0].size) ; memcpy(&buf1[offset] , &temp_ui , (size_t)size) ; break ; case TRICK_NUMBER_OF_TYPES: // TRICK_NUMBER_OF_TYPES is an error case temp_i = 0 ; memcpy(&buf1[offset] , &temp_i , (size_t)size) ; break ; default: memcpy(&buf1[offset] , address , (size_t)size) ; break ; } offset += size ; } } else { /* indicate that we're over the maximum size */ if (debug >= 2) { message_publish(MSG_DEBUG, "%p tag=<%s> var_server buffer[%d] too small (need %d), sending multiple binary packets.\n", &connection, connection.client_tag, MAX_MSG_LEN, (int)(offset + MessageSize) ); } break ; } } /* adjust the header with the correct information reflecting what has been accomplished */ NumVariablesProcessed = i - Start; offset -= sizeof(offset) ; if (byteswap) { swap_int = trick_byteswap_int((int)offset) ; memcpy(buf1 + sizeof(msg_type) , &swap_int , sizeof(offset)) ; swap_int = trick_byteswap_int( NumVariablesProcessed ) ; memcpy( buf1 + sizeof(msg_type) + sizeof(offset), &swap_int , sizeof(swap_int)) ; } else { memcpy(buf1 + sizeof(msg_type) , &offset , sizeof(offset)) ; memcpy( buf1 + sizeof(msg_type) + sizeof(offset), &NumVariablesProcessed , sizeof( NumVariablesProcessed )) ; } if (debug >= 2) { message_publish(MSG_DEBUG, "%p tag=<%s> var_server sending %u binary bytes containing %d variables.\n", &connection, connection.client_tag, (unsigned int)(offset + sizeof(offset)), NumVariablesProcessed); } len = offset + sizeof(msg_type) ; ret = tc_write(&connection, (char *) buf1, len); if ( ret != (int)len ) { return(-1) ; } /* return the index to the next symbol to send or V->num_vars if all done */ return i; }