LPCUSBSIO_API int32_t I2C_Init(LPC_HANDLE handle, I2C_PORTCONFIG_T *config)
{
LPCUSBSIO_I2C_Ctrl_t *dev = (LPCUSBSIO_I2C_Ctrl_t *) handle;
uint8_t outPacket[HID_I2C_PACKET_SZ + 1];
uint8_t inPacket[HID_I2C_PACKET_SZ + 1];
int32_t res;
HID_I2C_IN_REPORT_T *pIn;
if ((validHandle(handle) == 0) || (config == NULL))
{
return LPCUSBSIO_ERR_BAD_HANDLE;
}
memcpy(outPacket, config, sizeof(I2C_PORTCONFIG_T));
res = I2C_SendRequest(dev, HID_I2C_REQ_INIT_PORT, outPacket, sizeof(I2C_PORTCONFIG_T), inPacket, sizeof(inPacket));
if (res == LPCUSBSIO_OK)
{
/* parse response */
pIn = (HID_I2C_IN_REPORT_T *) &inPacket[0];
res = pIn->length - HID_I2C_HEADER_SZ;
/* copy data back to user buffer */
memcpy(&dev->fwVersion[0], &pIn->data[0], res);
}
return res;
}
SQLRETURN SQL_API SQLParamOptions(
SQLHSTMT hstmt,
UDWORD crow,
UDWORD * pirow)
{
RETCODE rc, traceRet = 1;
pSTMT pstmt = (pSTMT)hstmt;
ODBC_TRACE_ENTRY(ODBC_TR_TRACE, IITraceSQLParamOptions (hstmt, crow, pirow),
traceRet);
if (validHandle(hstmt, SQL_HANDLE_STMT) != SQL_SUCCESS)
{
ODBC_TRACE(ODBC_TR_TRACE, IITraceReturn(traceRet, SQL_INVALID_HANDLE));
return SQL_INVALID_HANDLE;
}
resetErrorBuff(hstmt, SQL_HANDLE_STMT);
rc = IIParamOptions(
pstmt->hdr.driverHandle,
crow,
pirow);
applyLock(SQL_HANDLE_STMT, pstmt);
if (rc != SQL_SUCCESS)
{
pstmt->hdr.driverError = TRUE;
pstmt->errHdr.rc = rc;
}
releaseLock(SQL_HANDLE_STMT, pstmt);
ODBC_TRACE(ODBC_TR_TRACE, IITraceReturn(traceRet, rc));
return rc;
}
SQLRETURN SQL_API SQLSetParam(
SQLHSTMT StatementHandle,
SQLUSMALLINT ParameterNumber,
SQLSMALLINT ValueType,
SQLSMALLINT ParameterType,
SQLUINTEGER LengthPrecision,
SQLSMALLINT ParameterScale,
SQLPOINTER ParameterValue,
SQLINTEGER *StrLen_or_Ind)
{
pSTMT pstmt = (pSTMT)StatementHandle;
RETCODE traceRet = 1;
ODBC_TRACE_ENTRY(ODBC_TR_TRACE, IITraceSQLSetParam(StatementHandle,
ParameterNumber, ValueType, ParameterType, LengthPrecision,
ParameterScale, ParameterValue, StrLen_or_Ind), traceRet);
if (validHandle((SQLHANDLE)pstmt, SQL_HANDLE_STMT) != SQL_SUCCESS)
{
ODBC_TRACE(ODBC_TR_TRACE, IITraceReturn(traceRet, SQL_INVALID_HANDLE));
return SQL_INVALID_HANDLE;
}
resetErrorBuff((SQLHANDLE)pstmt, SQL_HANDLE_STMT);
insertErrorMsg((SQLHANDLE)pstmt, SQL_HANDLE_STMT,
SQL_IM001, SQL_ERROR, NULL, 0);
ODBC_TRACE(ODBC_TR_TRACE, IITraceReturn(traceRet, SQL_ERROR));
return SQL_ERROR;
}
SQLRETURN SQL_API SQLPrepare(
SQLHSTMT hstmt,
UCHAR * szSqlStr,
SDWORD cbSqlStr)
{
RETCODE rc, traceRet = 1;
pSTMT pstmt = (pSTMT)hstmt;
pDBC pdbc;
ODBC_TRACE_ENTRY(ODBC_TR_TRACE, IITraceSQLPrepare(hstmt, szSqlStr,
cbSqlStr), traceRet);
if (validHandle((SQLHANDLE)pstmt, SQL_HANDLE_STMT) != SQL_SUCCESS)
{
ODBC_TRACE(ODBC_TR_TRACE, IITraceReturn(traceRet, SQL_INVALID_HANDLE));
return SQL_INVALID_HANDLE;
}
resetErrorBuff((SQLHANDLE)pstmt, SQL_HANDLE_STMT);
pdbc = pstmt->pdbc;
if (!szSqlStr)
{
insertErrorMsg((SQLHANDLE)pstmt, SQL_HANDLE_STMT, SQL_HY009,
SQL_ERROR, NULL, 0);
ODBC_TRACE(ODBC_TR_TRACE, IITraceReturn(traceRet, SQL_ERROR));
return SQL_ERROR;
}
rc = IIPrepare( pstmt->hdr.driverHandle,
szSqlStr,
cbSqlStr);
applyLock(SQL_HANDLE_STMT, pstmt);
if (rc != SQL_SUCCESS)
{
pstmt->hdr.driverError = TRUE;
pstmt->errHdr.rc = rc;
}
if (SQL_SUCCEEDED(rc))
{
if (!pdbc->autocommit)
pdbc->hdr.state = C6;
if (pstmt->hdr.state == S1)
if (pstmt->select || pstmt->execproc)
pstmt->hdr.state = S3;
else
pstmt->hdr.state = S2;
}
else
pstmt->hdr.state = S1;
releaseLock(SQL_HANDLE_STMT, pstmt);
ODBC_TRACE(ODBC_TR_TRACE, IITraceReturn(traceRet, rc));
return rc;
}
LPCUSBSIO_API int32_t I2C_FastXfer(LPC_HANDLE handle, I2C_FAST_XFER_T *xfer)
{
LPCUSBSIO_I2C_Ctrl_t *dev = (LPCUSBSIO_I2C_Ctrl_t *) handle;
uint8_t outPacket[HID_I2C_PACKET_SZ + 1];
uint8_t inPacket[HID_I2C_PACKET_SZ + 1];
int32_t res;
HID_I2C_XFER_PARAMS_T param;
HID_I2C_IN_REPORT_T *pIn;
uint8_t *desBuff;
if (validHandle(handle) == 0)
{
return LPCUSBSIO_ERR_BAD_HANDLE;
}
/* do parameter check */
if ((xfer->txSz > MAX_XFER_TX_LENGTH) || (xfer->rxSz > MAX_XFER_RX_LENGTH) ||
((xfer->txSz > 0) && (xfer->txBuff == NULL)) ||
((xfer->rxSz > 0) && (xfer->rxBuff == NULL)) ||
(xfer->slaveAddr > 127) )
{
return LPCUSBSIO_ERR_INVALID_PARAM;
}
param.txLength = xfer->txSz;
param.rxLength = xfer->rxSz;
param.options = xfer->options;
param.slaveAddr = xfer->slaveAddr;
desBuff = outPacket;
/* copy params */
memcpy(desBuff, ¶m, sizeof(HID_I2C_XFER_PARAMS_T));
desBuff += sizeof(HID_I2C_XFER_PARAMS_T);
/* copy data buffer now */
memcpy(desBuff, &xfer->txBuff[0], xfer->txSz);
res = I2C_SendRequest(dev, HID_I2C_REQ_DEVICE_XFER, outPacket, sizeof(HID_I2C_XFER_PARAMS_T) + xfer->txSz, inPacket, sizeof(inPacket));
if (res == LPCUSBSIO_OK)
{
/* parse response */
pIn = (HID_I2C_IN_REPORT_T *) &inPacket[0];
res = pIn->length - HID_I2C_HEADER_SZ;
if (res != 0)
{
/* copy data back to user buffer */
memcpy(&xfer->rxBuff[0], &pIn->data[0], res);
}
else
{
/* else it should be Tx only transfer. Update transferred size. */
res = xfer->txSz;
}
}
return res;
}
/**************************************************************************//**
* \fn CAENComm_ErrorCode STDCALL CAENComm_CloseDevice(int handle);
* \brief Close the device
*
* \param [IN] handle: device handler
* \return 0 = Success; negative numbers are error codes
******************************************************************************/
CAENComm_ErrorCode STDCALL CAENComm_CloseDevice(int handle)
{
if(!validHandle(handle)) {
return CAENComm_InvalidHandler;
}
delete handles[handle].s_pDevice;
handles[handle].s_pDevice=0; // Make referencing it a disaster.
return CAENComm_Success;
}
RETCODE SQL_API SQLSetStmtAttr(
SQLHSTMT hstmt,
SQLINTEGER fOption,
SQLPOINTER ValuePtr,
SQLINTEGER StringLength)
{
RETCODE rc, traceRet = 1;
pSTMT pstmt = (pSTMT)hstmt;
ODBC_TRACE_ENTRY(ODBC_TR_TRACE, IITraceSQLSetStmtAttr(hstmt, fOption,
ValuePtr, StringLength), traceRet);
if (validHandle(pstmt, SQL_HANDLE_STMT) != SQL_SUCCESS)
{
ODBC_TRACE(ODBC_TR_TRACE, IITraceReturn(traceRet, SQL_INVALID_HANDLE));
return SQL_INVALID_HANDLE;
}
else
resetErrorBuff(hstmt, SQL_HANDLE_STMT);
switch (fOption)
{
case SQL_ATTR_USE_BOOKMARKS:
case SQL_ATTR_CONCURRENCY:
case SQL_ATTR_CURSOR_TYPE:
case SQL_ATTR_SIMULATE_CURSOR:
if (pstmt->hdr.state >= S3)
{
rc = SQL_ERROR;
{
ODBC_TRACE(ODBC_TR_TRACE, IITraceReturn(traceRet, rc));
return rc;
}
}
break;
}
rc = IISetStmtAttr(
pstmt->hdr.driverHandle,
fOption,
ValuePtr,
StringLength);
applyLock(SQL_HANDLE_STMT, pstmt);
if (rc != SQL_SUCCESS)
{
pstmt->hdr.driverError = TRUE;
pstmt->errHdr.rc = rc;
}
releaseLock(SQL_HANDLE_STMT, pstmt);
ODBC_TRACE(ODBC_TR_TRACE, IITraceReturn(traceRet, rc));
return rc;
}
/**************************************************************************//**
* \fn CAENComm_ErrorCode STDCALL CAENComm_Read16(int handle, uint32_t Address, uint16_t *Data)
* \brief Read a 16 bit data from the specified register.
*
* \param [IN] handle: device handler
* \param [IN] Address: register address offset
* \param [OUT] Data: The data read from the device
* \return 0 = Success; negative numbers are error codes
******************************************************************************/
CAENComm_ErrorCode STDCALL CAENComm_Read16(
int handle, uint32_t Address, uint16_t *Data)
{
if (!validHandle(handle)) {
return CAENComm_InvalidHandler;
}
CVMUSB* pController = handles[handle].s_pDevice;
int status = pController->vmeRead16(Address + handles[handle].s_base,
Amod, Data);
return VMUSBStatusToCaenStatus(status);
}
LPCUSBSIO_API int32_t I2C_Reset(LPC_HANDLE handle)
{
LPCUSBSIO_I2C_Ctrl_t *dev = (LPCUSBSIO_I2C_Ctrl_t *) handle;
uint8_t inPacket[HID_I2C_PACKET_SZ + 1];
int32_t res;
if (validHandle(handle) == 0)
{
return LPCUSBSIO_ERR_BAD_HANDLE;
}
res = I2C_SendRequest(dev, HID_I2C_REQ_RESET, NULL, 0, inPacket, sizeof(inPacket));
return res;
}
/**************************************************************************//**
* \fn CAENComm_ErrorCode STDCALL CAENComm_BLTRead(int handle, uint32_t Address, uint32_t *Buff, int BltSize, int *nw)
* \brief Read a block of data from the device using a BLT (32 bit) cycle
*
* \param [IN] handle: device handler
* \param [IN] Address: data space starting address
* \param [IN] BltSize: size of the Block Read Cycle (in bytes)
* \param [OUT] buff: pointer to the data buffer
* \param [OUT] nw: number of longwords (32 bit) actually read from the device
* \return 0 = Success; negative numbers are error codes
******************************************************************************/
CAENComm_ErrorCode STDCALL CAENComm_BLTRead(
int handle, uint32_t Address, uint32_t *Buff, int BltSize, int *nw)
{
if (!validHandle(handle)) {
return CAENComm_InvalidHandler;
}
CVMUSB* pController = handles[handle].s_pDevice;
size_t actualTransferCount;
int status = pController->vmeBlockRead(Address + handles[handle].s_base,
Amod, Buff,
static_cast<size_t>(BltSize),
&actualTransferCount);
*nw = actualTransferCount;
return VMUSBStatusToCaenStatus(status);
}
/**************************************************************************//**
* \fn CAENComm_ErrorCode STDCALL CAENComm_Write32(int handle, uint32_t Address, uint32_t *Data)
* \brief Write a 32 bit register of the device
*
* \param [IN] handle: device handler
* \param [IN] Address: register address offset
* \param [IN] Data: new register content to write into the device
* \return 0 = Success; negative numbers are error codes
******************************************************************************/
CAENComm_ErrorCode STDCALL CAENComm_Write32(int handle, uint32_t Address, uint32_t Data)
{
// Retrieve the handle:
if (!validHandle(handle)) {
return CAENComm_InvalidHandler;
}
CVMUSB* pController = handles[handle].s_pDevice;
// Attempt the operation and analyze the result.
int status = pController->vmeWrite32(Address + handles[handle].s_base,
Amod, Data);
return VMUSBStatusToCaenStatus(status);
}
LPCUSBSIO_API int32_t I2C_DeviceWrite(LPC_HANDLE handle,
uint8_t deviceAddress,
uint8_t *buffer,
uint16_t sizeToTransfer,
uint8_t options)
{
LPCUSBSIO_I2C_Ctrl_t *dev = (LPCUSBSIO_I2C_Ctrl_t *) handle;
uint8_t outPacket[0xFFFF];
uint8_t inPacket[HID_I2C_PACKET_SZ + 1];
int32_t res;
HID_I2C_RW_PARAMS_T param;
uint8_t *desBuff;
if (validHandle(handle) == 0)
{
return LPCUSBSIO_ERR_BAD_HANDLE;
}
/* do parameter check */
if ((sizeToTransfer > MAX_WRITE_LENGTH) ||
((sizeToTransfer > 0) && (buffer == NULL)) ||
(deviceAddress > 127))
{
return LPCUSBSIO_ERR_INVALID_PARAM;
}
param.length = sizeToTransfer;
param.options = options;
param.slaveAddr = deviceAddress;
desBuff = outPacket;
/* copy params */
memcpy(desBuff, ¶m, sizeof(HID_I2C_RW_PARAMS_T));
desBuff += sizeof(HID_I2C_RW_PARAMS_T);
/* copy data buffer now */
memcpy(desBuff, buffer, sizeToTransfer);
res = I2C_SendRequest(dev, HID_I2C_REQ_DEVICE_WRITE, outPacket, sizeof(HID_I2C_RW_PARAMS_T) + sizeToTransfer, inPacket, sizeof(inPacket));
if (res == LPCUSBSIO_OK)
{
/* update user on transfered size */
res = sizeToTransfer;
}
return res;
}
SQLRETURN SQL_API SQLNativeSql(
SQLHDBC hdbc,
SQLCHAR * InStatementText,
SQLINTEGER TextLength1,
SQLCHAR * OutStatementText,
SQLINTEGER BufferLength,
SQLINTEGER* pcbValue)
{
RETCODE rc, traceRet = 1;
pDBC pdbc = (pDBC)hdbc;
ODBC_TRACE_ENTRY(ODBC_TR_TRACE, IITraceSQLNativeSql(hdbc, InStatementText,
TextLength1, OutStatementText, BufferLength, pcbValue), traceRet);
if (!BufferLength)
BufferLength = SQL_MAX_MESSAGE_LENGTH;
if (validHandle(hdbc, SQL_HANDLE_DBC) != SQL_SUCCESS)
{
ODBC_TRACE(ODBC_TR_TRACE, IITraceReturn(traceRet, SQL_INVALID_HANDLE));
return SQL_INVALID_HANDLE;
}
resetErrorBuff(hdbc, SQL_HANDLE_DBC);
rc = IINativeSql(
pdbc->hdr.driverHandle,
InStatementText,
TextLength1,
OutStatementText,
BufferLength,
pcbValue);
applyLock(SQL_HANDLE_DBC, pdbc);
if (rc != SQL_SUCCESS)
{
pdbc->hdr.driverError = TRUE;
pdbc->errHdr.rc = rc;
}
releaseLock(SQL_HANDLE_DBC, pdbc);
ODBC_TRACE(ODBC_TR_TRACE, IITraceReturn(traceRet, rc));
return rc;
}
LPCUSBSIO_API int32_t I2C_Close(LPC_HANDLE handle)
{
LPCUSBSIO_I2C_Ctrl_t *dev = (LPCUSBSIO_I2C_Ctrl_t *) handle;
uint8_t inPacket[HID_I2C_PACKET_SZ + 1];
if (validHandle(handle) == 0)
{
return LPCUSBSIO_ERR_BAD_HANDLE;
}
I2C_SendRequest(dev, HID_I2C_REQ_DEINIT_PORT, NULL, 0, inPacket, sizeof(inPacket));
/*Shutdown reader thread*/
dev->thread_exit = 0x01;
/*Close remote dev handle : all pending request are canceled*/
hid_close(dev->hidDev);
/*Wait End of reader thread & clean up*/
framework_JoinThread(dev->ResponsethreadHandle);
framework_DeleteThread(dev->ResponsethreadHandle);
dev->ResponsethreadHandle = NULL;
/*redaer thread is not running so we notify all pending request*/
I2C_CancelAllRequest(handle);
g_Ctrl.devInfoList = NULL;
ReleaseNotifier(dev);
framework_DeleteMutex(dev->NotifierContainerLock);
dev->NotifierContainerLock = NULL;
framework_LockMutex(dev->RequestMapLock);
map_destroy(dev->request_map);
dev->request_map = NULL;
framework_UnlockMutex(dev->RequestMapLock);
framework_DeleteMutex(dev->RequestMapLock);
dev->RequestMapLock = NULL;
framework_DeleteMutex(dev->SendLock);
dev->SendLock = NULL;
freeDevice(dev);
return LPCUSBSIO_OK;
}
/**
* @brief Close the specified file.
*/
static int32 RIPCALL progress_close_common (DEVICELIST* dev,
DEVICE_FILEDESCRIPTOR descriptor,
int32 fAbort)
{
uint8 type = progressHandleType (descriptor);
intptr_t depth = progressHandleDepth (descriptor);
UNUSED_PARAM (DEVICELIST*, dev);
UNUSED_PARAM (int32, fAbort);
progress_noerror (dev);
if (! validHandle (type, depth))
return progress_ioerror (dev);
--openCount[type];
return 0;
}
/**
* @brief Called to report human-readable information from progress text files.
*/
static int32 RIPCALL progress_write_file (DEVICELIST* dev, DEVICE_FILEDESCRIPTOR descriptor,
uint8* buff, int32 len)
{
ProgressDeviceState* pState = (ProgressDeviceState*) dev->private_data;
uint8 type = progressHandleType (descriptor);
intptr_t depth = progressHandleDepth (descriptor);
progress_noerror (dev);
if (! validHandle (type, depth))
return progress_ioerror (dev);
PKWaitOnSemaphore (pState->pSema);
if ( type >= PROGRESS_TYPE_DIAL_TOTAL
&& (type != PROGRESS_TYPE_TEXT_JOB_LOG || fCaptureTextStreamOutput ))
SkinMonitorl (len, buff);
PKSignalSemaphore (pState->pSema);
return len;
}
SQLRETURN SQL_API SQLSetCursorName(
SQLHSTMT hstmt,
UCHAR * szCursorParameter,
SWORD cbCursor)
{
RETCODE rc, traceRet = 1;
pSTMT pstmt = (pSTMT)hstmt;
ODBC_TRACE_ENTRY(ODBC_TR_TRACE, IITraceSQLSetCursorName(hstmt,
szCursorParameter, cbCursor), traceRet);
if (validHandle(hstmt, SQL_HANDLE_STMT) != SQL_SUCCESS)
{
ODBC_TRACE(ODBC_TR_TRACE, IITraceReturn(traceRet, SQL_INVALID_HANDLE));
return SQL_INVALID_HANDLE;
}
resetErrorBuff(hstmt, SQL_HANDLE_STMT);
rc = IISetCursorName(
pstmt->hdr.driverHandle,
szCursorParameter,
cbCursor);
applyLock(SQL_HANDLE_STMT, pstmt);
if (rc != SQL_SUCCESS)
{
pstmt->hdr.driverError = TRUE;
pstmt->errHdr.rc = rc;
}
else if (SQL_SUCCEEDED(rc))
{
pstmt->prepared = TRUE;
}
releaseLock(SQL_HANDLE_STMT, pstmt);
ODBC_TRACE(ODBC_TR_TRACE, IITraceReturn(traceRet, rc));
return rc;
}
/*
** Name: SQLCloseCursor - Close a cursor.
**
** Description:
** SQLCloseCursor closes a cursor that has been opened on a
** statement and discards pending results.
**
** Inputs:
** StatementHandle.
**
** Outputs:
** None.
**
** Returns:
** SQL_SUCCESS
** SQL_SUCCESS_WITH_INFO
** SQL_ERROR
** SQL_INVALID_HANDLE
**
** Exceptions:
**
** N/A
**
** Side Effects:
**
** None.
**
** History:
** 14-jun-04 (loera01)
** Created.
*/
SQLRETURN SQL_API SQLCloseCursor (
SQLHSTMT StatementHandle)
{
RETCODE rc, traceRet = 1;
pSTMT pstmt = (pSTMT)StatementHandle;
ODBC_TRACE_ENTRY(ODBC_TR_TRACE, IITraceSQLCloseCursor(StatementHandle),
traceRet);
if (validHandle((SQLHANDLE)pstmt, SQL_HANDLE_STMT) != SQL_SUCCESS)
{
ODBC_TRACE(ODBC_TR_TRACE, IITraceReturn(traceRet, SQL_INVALID_HANDLE));
return SQL_INVALID_HANDLE;
}
resetErrorBuff((SQLHANDLE)pstmt, SQL_HANDLE_STMT);
rc = IICloseCursor(
pstmt->hdr.driverHandle);
applyLock(SQL_HANDLE_STMT, pstmt);
if (rc != SQL_SUCCESS)
{
pstmt->hdr.driverError = TRUE;
pstmt->errHdr.rc = rc;
}
else if (SQL_SUCCEEDED(rc))
{
if (pstmt->prepared)
pstmt->hdr.state = S3;
else
pstmt->hdr.state = S1;
}
releaseLock(SQL_HANDLE_STMT, pstmt);
ODBC_TRACE(ODBC_TR_TRACE, IITraceReturn(traceRet, rc));
return rc;
}
LPCUSBSIO_API const wchar_t *I2C_Error(LPC_HANDLE handle, int32_t status)
{
LPCUSBSIO_I2C_Ctrl_t *dev = (LPCUSBSIO_I2C_Ctrl_t *) handle;
const wchar_t *retStr = NULL;
if (validHandle(handle) != 0)
{
if ((status == LPCUSBSIO_OK) || (LPCUSBSIO_ERR_HID_LIB == status))
{
retStr = hid_error(dev->hidDev);
}
else
{
retStr = GetErrorString(status);
}
}
else
{
retStr = hid_error(NULL);
}
return retStr;
}
RETCODE SQL_API SQLSetStmtOption(
SQLHSTMT hstmt,
SQLUSMALLINT fOption,
SQLUINTEGER vParam)
{
RETCODE rc, traceRet = 1;
pSTMT pstmt = (pSTMT)hstmt;
ODBC_TRACE_ENTRY(ODBC_TR_TRACE, IITraceSQLSetStmtOption( hstmt, fOption,
vParam), traceRet);
if (validHandle(pstmt, SQL_HANDLE_STMT) != SQL_SUCCESS)
{
ODBC_TRACE(ODBC_TR_TRACE, IITraceReturn(traceRet, SQL_INVALID_HANDLE));
return SQL_INVALID_HANDLE;
}
else
{
resetErrorBuff(hstmt, SQL_HANDLE_STMT);
rc = IISetStmtOption(
pstmt->hdr.driverHandle,
fOption,
vParam);
applyLock(SQL_HANDLE_STMT, pstmt);
if (rc != SQL_SUCCESS)
{
pstmt->hdr.driverError = TRUE;
pstmt->errHdr.rc = rc;
}
releaseLock(SQL_HANDLE_STMT, pstmt);
}
ODBC_TRACE(ODBC_TR_TRACE, IITraceReturn(traceRet, rc));
return rc;
}
LPCUSBSIO_API LPCUSBSIO_ERR_T GPIO_SetDWLValue(LPC_HANDLE handle, uint8_t newValue)
{
LPCUSBSIO_I2C_Ctrl_t *dev = (LPCUSBSIO_I2C_Ctrl_t *) handle;
LPCUSBSIO_ERR_T res = LPCUSBSIO_OK;
uint8_t outPacket[HID_I2C_PACKET_SZ + 1];
uint8_t inPacket[HID_I2C_PACKET_SZ + 1];
if (validHandle(handle) == 0)
{
return LPCUSBSIO_ERR_BAD_HANDLE;
}
/* do parameter check */
if ( 0 != newValue && 1 != newValue)
{
return LPCUSBSIO_ERR_INVALID_PARAM;
}
outPacket[0] = newValue;
res = I2C_SendRequest(dev, HID_GPIO_REQ_SET_DWL, outPacket, sizeof(uint8_t), inPacket, sizeof(inPacket));
return res;
}
LPCUSBSIO_API int32_t I2C_DeviceRead(LPC_HANDLE handle,
uint8_t deviceAddress,
uint8_t *buffer,
uint16_t sizeToTransfer,
uint8_t options)
{
LPCUSBSIO_I2C_Ctrl_t *dev = (LPCUSBSIO_I2C_Ctrl_t *) handle;
uint8_t outPacket[HID_I2C_PACKET_SZ + 1];
uint8_t inPacket[0xFFFF];
int32_t res;
HID_I2C_RW_PARAMS_T param;
HID_I2C_IN_REPORT_T *pIn;
if (validHandle(handle) == 0)
{
return LPCUSBSIO_ERR_BAD_HANDLE;
}
/* do parameter check */
//if ((sizeToTransfer > MAX_READ_LENGTH) ||
// ((sizeToTransfer > 0) && (buffer == NULL)) ||
// (deviceAddress > 127))
//{
// return LPCUSBSIO_ERR_INVALID_PARAM;
//}
param.length = sizeToTransfer;
param.options = options;
param.slaveAddr = deviceAddress;
memcpy(outPacket, ¶m, sizeof(HID_I2C_RW_PARAMS_T));
res = I2C_SendRequest(dev, HID_I2C_REQ_DEVICE_READ, outPacket, sizeof(HID_I2C_RW_PARAMS_T), inPacket, sizeof(inPacket));
if (res == LPCUSBSIO_OK)
{
/* parse response */
pIn = (HID_I2C_IN_REPORT_T *) &inPacket[0];
res = pIn->length - HID_I2C_HEADER_SZ;
if (pIn->length <= HID_I2C_PACKET_SZ)
{
/* copy data back to user buffer */
memcpy(buffer, &pIn->data[0], res);
}
else
{
uint8_t ptr = HID_I2C_HEADER_SZ;
uint8_t temp, i=0;
while(res > 0)
{
temp = (res > HID_I2C_PACKET_SZ-HID_I2C_HEADER_SZ) ? (HID_I2C_PACKET_SZ-HID_I2C_HEADER_SZ) : res;
memcpy(&buffer[i], &inPacket[ptr], temp);
i += temp;
res -= temp;
ptr += temp + HID_I2C_HEADER_SZ;
}
res = i;
}
}
return res;
}
/*
** Name: SQLFreeStmt - Free a statement handle
**
** Description:
** SQLFreeStmt stops processing associated with a specific
** statement, closes any open cursors associated with the
** statement, discards pending results, or, optionally, frees
** all resources associated with the statement handle.
**
** Inputs:
** hstmt - Statement handle.
** fOption - Operation to be performed.
**
** Outputs:
** None.
**
** Returns:
** SQL_SUCCESS
** SQL_SUCCESS_WITH_INFO
** SQL_ERROR
** SQL_INVALID_HANDLE
**
** Exceptions:
**
** N/A
**
** Side Effects:
**
** None.
**
** History:
** 14-jun-04 (loera01)
** Created.
*/
SQLRETURN SQL_API SQLFreeStmt(
SQLHSTMT hstmt,
UWORD fOption)
{
RETCODE rc, traceRet = 1;
pSTMT pstmt = (pSTMT)hstmt;
pDBC pdbc = pstmt->pdbc;
ODBC_TRACE_ENTRY(ODBC_TR_TRACE, IITraceSQLFreeStmt(hstmt, fOption), traceRet);
if (validHandle(hstmt, SQL_HANDLE_STMT) != SQL_SUCCESS)
{
rc = SQL_INVALID_HANDLE;
goto exit_routine;
}
resetErrorBuff(hstmt, SQL_HANDLE_STMT);
if (fOption == SQL_DROP)
{
rc = IIFreeHandle(
SQL_HANDLE_STMT,
pstmt->hdr.driverHandle);
}
else
rc = IIFreeStmt(
pstmt->hdr.driverHandle,
fOption);
applyLock(SQL_HANDLE_STMT, pstmt);
if (rc != SQL_SUCCESS)
{
pstmt->hdr.driverError = TRUE;
pstmt->errHdr.rc = rc;
goto exit_routine;
}
if (pstmt->hdr.state >= S4 &&
pstmt->hdr.state <= S7)
if (pstmt->prepared)
pstmt->hdr.state = S2;
else
pstmt->hdr.state = S1;
releaseLock(SQL_HANDLE_STMT, pstmt);
if (fOption == SQL_DROP)
{
if (!IIodbc_freeHandle(SQL_HANDLE_STMT, (void *)pstmt))
rc = SQL_INVALID_HANDLE;
else
{
applyLock(SQL_HANDLE_DBC, pdbc);
if (!pdbc->stmt_count && pdbc->hdr.state != C6)
pdbc->hdr.state = C4;
releaseLock(SQL_HANDLE_DBC, pdbc);
rc = SQL_SUCCESS;
}
}
exit_routine:
ODBC_TRACE(ODBC_TR_TRACE, IITraceReturn(traceRet, rc));
return rc;
}
