//*****************************************************************************
//
// smbus.h - Prototypes for the SMBus driver.
//
// Copyright (c) 2010-2014 Texas Instruments Incorporated. All rights reserved.
// Software License Agreement
//
// Texas Instruments (TI) is supplying this software for use solely and
// exclusively on TI's microcontroller products. The software is owned by
// TI and/or its suppliers, and is protected under applicable copyright
// laws. You may not combine this software with "viral" open-source
// software in order to form a larger program.
//
// THIS SOFTWARE IS PROVIDED "AS IS" AND WITH ALL FAULTS.
// NO WARRANTIES, WHETHER EXPRESS, IMPLIED OR STATUTORY, INCLUDING, BUT
// NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE APPLY TO THIS SOFTWARE. TI SHALL NOT, UNDER ANY
// CIRCUMSTANCES, BE LIABLE FOR SPECIAL, INCIDENTAL, OR CONSEQUENTIAL
// DAMAGES, FOR ANY REASON WHATSOEVER.
//
// This is part of revision 2.1.0.12573 of the Tiva Utility Library.
//
//*****************************************************************************
#ifndef __SMBUS_H__
#define __SMBUS_H__
//*****************************************************************************
//
// If building with a C++ compiler, make all of the definitions in this header
// have a C binding.
//
//*****************************************************************************
#ifdef __cplusplus
extern "C"
{
#endif
//*****************************************************************************
//
//! \addtogroup smbus_api
//! @{
//
//*****************************************************************************
//*****************************************************************************
//
//! This structure holds the SMBus Unique Device ID (UDID). For detailed
//! information, please refer to the SMBus Specification.
//
//*****************************************************************************
typedef struct
{
//
//! Device capabilities field. This 8-bit field reports generic SMBus
//! capabilities such as address type for ARP.
//
uint8_t ui8DeviceCapabilities;
//
//! Version Revision field. This 8-bit field reports UDID revision
//! information as well as some vendor-specific things such as silicon
//! revision.
//
uint8_t ui8Version;
//
//! Vendor ID. This 16-bit field contains the manufacturer's ID as
//! assigned by the SBS Implementers' Forum of the PCI SIG.
//
uint16_t ui16VendorID;
//
//! Device ID. This 16-bit field contains the device ID assigned by the
//! device manufacturer.
//
uint16_t ui16DeviceID;
//
//! Interface. This 16-bit field identifies the protocol layer interfaces
//! supported over the SMBus connection.
//
uint16_t ui16Interface;
//
//! Subsystem Vendor ID. This 16-bit field holds additional information
//! that may be derived from the vendor ID or other information.
//
uint16_t ui16SubSystemVendorID;
//
//! Subsystem Device ID. This 16-bit field holds additional information
//! that may be derived from the device ID or other information.
//
uint16_t ui16SubSystemDeviceID;
//
//! Vendor-specific ID. This 32-bit field contains a unique number that
//! can be assigned per device by the manufacturer.
//
uint32_t ui32VendorSpecificID;
}
tSMBusUDID;
//*****************************************************************************
//
//! This structure contains the state of a single instance of an SMBus module.
//! Master and slave instances require unique configuration structures.
//
//*****************************************************************************
typedef struct
{
//
//! The SMBus Unique Device ID (UDID) for this SMBus instance. If
//! operating as a host, master-only, or on a bus that does not use Address
//! Resolution Protocol (ARP), this is not required. This member can be
//! set via a direct structure access or using the SMBusSlaveInit
//! function. For detailed information about the UDID, refer to the SMBus
//! spec.
//
tSMBusUDID *pUDID;
//
//! The base address of the I2C master peripheral. This member can be set
//! via a direct structure access or using the SMBusMasterInit or
//! SMBusSlaveInit functions.
//
uint32_t ui32I2CBase;
//
//! The address of the data buffer used for transmit operations. For
//! master operations, this member is set by the SMBusMasterxxxx functions
//! that pass a buffer pointer (for example, SMBusMasterBlockWrite). For
//! slave operations, this member can be set via direct structure access or
//! using the SMBusSlaveTxBufferSet function.
//
uint8_t *pui8TxBuffer;
//
//! The address of the data buffer used for receive operations. For master
//! operations, this member is set by the SMBusMasterxxxx functions that
//! pass a buffer pointer (for example, SMBusMasterBlockRead). For slave
//! operations, this member can be set via direct structure access or using
//! the SMBusSlaveRxBufferSet function.
//
uint8_t *pui8RxBuffer;
//
//! The amount of data to transmit from pui8TxBuffer. For master
//! operations this member is set by the SMBusMasterxxxx functions either
//! via an input argument (example SMBusMasterByteWordWrite) or explicitly
//! (example SMBusMasterSendByte). In master mode, this member should not
//! be accessed or modified by the application. For slave operations, this
//! member can be set via direct structure access of using the
//! SMBusSlaveTxBufferSet function.
//
uint8_t ui8TxSize;
//
//! The current index in the transmit buffer. This member should not be
//! accessed or modified by the application.
//
uint8_t ui8TxIndex;
//
//! The amount of data to receive into pui8RxBuffer. For master
//! operations, this member is set by the SMBusMasterxxxx functions either
//! via an input argument (example SMBusMasterByteWordRead), explicitly
//! (example SMBusMasterReceiveByte), or by the slave (example
//! SMBusMasterBlockRead). In master mode, this member should not be
//! accessed or modified by the application. For slave operations, this
//! member can be set via direct structure access of using the
//! SMBusSlaveRxBufferSet function.
//
uint8_t ui8RxSize;
//
//! The current index in the receive buffer. This member should not be
//! accessed or modified by the application.
//
uint8_t ui8RxIndex;
//
//! The active slave address of the I2C peripheral on the device.
//! When using dual address in slave mode, the active address is store
//! here. In master mode, this member is not used. This member is updated
//! as requests come in from the master.
//
uint8_t ui8OwnSlaveAddress;
//
//! The address of the targeted slave device. In master mode, this member
//! is set by the ui8TargetSlaveAddress argument in the SMBusMasterxxxx
//! transfer functions. In slave mode, it is not used. This member should
//! not be modified by the application.
//
uint8_t ui8TargetSlaveAddress;
//
//! The last used command. In master mode, this member is set by the
//! ui8Command argument in the SMBusMasterxxxx transfer functions. In
//! slave mode, the first received byte will always be considered the
//! command. This member should not be modified by the application.
//
uint8_t ui8CurrentCommand;
//
//! The running CRC calculation used for transfers that require Packet
//! Error Checking (PEC). This member is updated by the SMBus software and
//! should not be modified by the application.
//
uint8_t ui8CalculatedCRC;
//
//! The received CRC calculation used for transfers that require Packet
//! Error Checking (PEC). This member is updated by the SMBus software and
//! should not be modified by the application.
//
uint8_t ui8ReceivedCRC;
//
//! The current state of the SMBusMasterISRProcess state machine. This
//! member should not be accessed or modified by the application.
//
uint8_t ui8MasterState;
//
//! The current state of the SMBusSlaveISRProcess state machine. This
//! member should not be accessed or modified by the application.
//
uint8_t ui8SlaveState;
//
//! Flags used for various items in the SMBus state machines for different
//! transaction types and status.
//!
//! FLAG_PEC can be modified via the SMBusPECEnable or SMBusPECDisable
//! functions or via direct structure access.
//!
//! FLAG_BLOCK_TRANSFER can be set via the SMBusSlaveBlockTransferEnable
//! function and is cleared automatically by the SMBusSlaveTransferInit
//! function or manually using the SMBusSlaveBlockTransferDisable function.
//!
//! FLAG_RAW_I2C can be modified via the SMBusSlaveI2CEnable or
//! SMBusSlaveI2CDisable functions or via direct structure access.
//!
//! FLAG_TRANSFER_IN_PROGRESS should not be modified by the application,
//! but can be read via the SMBusStatusGet function.
//!
//! FLAG_PROCESS_CALL can be set via the SMBusSlaveProcessCallEnable
//! function and is cleared automatically by the SMBusSlaveTransferInit
//! function or manually using the SMBusSlaveProcessCallDisable function.
//!
//! FLAG_ADDRESS_RESOLVED is only used by an SMBus Slave that supports ARP.
//! This flag can be modified via the SMBusSlaveARPFlagARSet function and
//! read via SMBusSlaveARPFlagARGet. It can also be modified by direct
//! structure access.
//!
//! FLAG_ADDRESS_VALID is only used by an SMBus Slave that supports ARP.
//! This flag can be modified via the SMBusSlaveARPFlagAVSet function and
//! read via SMBusSlaveARPFlagAVGet. It can also be modified by direct
//! structure access.
//!
//! FLAG_ARP is used to indicate that ARP is currently active. This flag
//! is not used by the SMBus stack and can (optionally) be used by the
//! application to keep track of the ARP session.
//
uint16_t ui16Flags;
}
tSMBus;
//*****************************************************************************
//
// ! Return codes.
//
//*****************************************************************************
typedef enum
{
SMBUS_OK = 0, // General "OK" return code
SMBUS_TIMEOUT, // Master detected bus timeout from slave
SMBUS_PERIPHERAL_BUSY, // The I2C peripheral is currently in use
SMBUS_BUS_BUSY, // The I2C bus is currently in use
SMBUS_ARB_LOST, // Bus arbitration was lost (master mode)
SMBUS_ADDR_ACK_ERROR, // In master mode, the address was NAK'd
SMBUS_DATA_ACK_ERROR, // Data transfer was NAK'd by receiver
SMBUS_PEC_ERROR, // PEC mismatch occurred
SMBUS_DATA_SIZE_ERROR, // Data size error has occurred
SMBUS_MASTER_ERROR, // Error occurred in the master ISR
SMBUS_SLAVE_ERROR, // Error occurred in the slave ISR
SMBUS_SLAVE_QCMD_0, // Slave transaction is Quick Command with
// data value 0.
SMBUS_SLAVE_QCMD_1, // Slave transaction is Quick Command with
// data value 1.
SMBUS_SLAVE_FIRST_BYTE, // The first byte has been received
SMBUS_SLAVE_ADDR_PRIMARY, // Primary address was detected
SMBUS_SLAVE_ADDR_SECONDARY, // Secondary address was detected
SMBUS_TRANSFER_IN_PROGRESS, // A transfer is currently in progress
SMBUS_TRANSFER_COMPLETE, // The last active transfer is complete
SMBUS_SLAVE_NOT_READY, // A slave transmit has been requested, but is
// not ready (TX buffer not set).
SMBUS_FIFO_ERROR, // A master receive operation did not receive
// enough data from the slave.
}
tSMBusStatus;
//*****************************************************************************
//
// Close the Doxygen group.
//! @}
//
//*****************************************************************************
//*****************************************************************************
//
// ARP Commands
//
//*****************************************************************************
#define SMBUS_CMD_PREPARE_TO_ARP 0x01
#define SMBUS_CMD_ARP_RESET_DEVICE 0x02
#define SMBUS_CMD_ARP_GET_UDID 0x03
#define SMBUS_CMD_ARP_ASSIGN_ADDRESS 0x04
//*****************************************************************************
//
// Fixed addresses defined by the SMBus specification.
//
//*****************************************************************************
#define SMBUS_ADR_HOST 0x08
#define SMBUS_ADR_SMART_BATTERY_CHARGER 0x09
#define SMBUS_ADR_SMART_BATTERY_SELECTOR 0x0A
#define SMBUS_ADR_SMART_BATTERY 0x0B
#define SMBUS_ADR_DEFAULT_DEVICE 0x61
//*****************************************************************************
//
// API Function prototypes
//
//*****************************************************************************
extern void SMBusPECEnable(tSMBus *psSMBus);
extern void SMBusPECDisable(tSMBus *psSMBus);
extern void SMBusARPEnable(tSMBus *psSMBus);
extern void SMBusARPDisable(tSMBus *psSMBus);
extern tSMBusStatus SMBusStatusGet(tSMBus *psSMBus);
extern void SMBusARPUDIDPacketEncode(tSMBusUDID *pUDID,
uint8_t ui8Address,
uint8_t *pui8Data);
extern void SMBusARPUDIDPacketDecode(tSMBusUDID *pUDID,
uint8_t *pui8Address,
uint8_t *pui8Data);
extern uint8_t SMBusRxPacketSizeGet(tSMBus *psSMBus);
extern void SMBusUDIDDataGet(tSMBus *psSMBus, tSMBusUDID *pUDID);
extern tSMBusStatus SMBusMasterQuickCommand(tSMBus *psSMBus,
uint8_t ui8TargetAddress,
bool bData);
extern tSMBusStatus SMBusMasterByteSend(tSMBus *psSMBus,
uint8_t ui8TargetAddress,
uint8_t ui8Data);
extern tSMBusStatus SMBusMasterByteReceive(tSMBus *psSMBus,
uint8_t ui8TargetAddress,
uint8_t *pui8Data);
extern tSMBusStatus SMBusMasterByteWordWrite(tSMBus *psSMBus,
uint8_t ui8TargetAddress,
uint8_t ui8Command,
uint8_t *pui8Data,
uint8_t ui8Size);
extern tSMBusStatus SMBusMasterBlockWrite(tSMBus *psSMBus,
uint8_t ui8TargetAddress,
uint8_t ui8Command,
uint8_t *pui8Data,
uint8_t ui8Size);
extern tSMBusStatus SMBusMasterByteWordRead(tSMBus *psSMBus,
uint8_t ui8TargetAddress,
uint8_t ui8Command,
uint8_t *pui8Data,
uint8_t ui8Size);
extern tSMBusStatus SMBusMasterBlockRead(tSMBus *psSMBus,
uint8_t ui8TargetAddress,
uint8_t ui8Command,
uint8_t *pui8Data);
extern tSMBusStatus SMBusMasterProcessCall(tSMBus *psSMBus,
uint8_t ui8TargetAddress,
uint8_t ui8Command,
uint8_t *pui8TxData,
uint8_t *pui8RxData);
extern tSMBusStatus SMBusMasterBlockProcessCall(tSMBus *psSMBus,
uint8_t ui8TargetAddress,
uint8_t ui8Command,
uint8_t *pui8TxData,
uint8_t ui8TxSize,
uint8_t *pui8RxData);
extern tSMBusStatus SMBusMasterHostNotify(tSMBus *psSMBus,
uint8_t ui8OwnSlaveAddress,
uint8_t *pui8Data);
extern tSMBusStatus SMBusMasterI2CWrite(tSMBus *psSMBus,
uint8_t ui8TargetAddress,
uint8_t *pui8Data,
uint8_t ui8Size);
extern tSMBusStatus SMBusMasterI2CRead(tSMBus *psSMBus,
uint8_t ui8TargetAddress,
uint8_t *pui8Data,
uint8_t ui8Size);
extern tSMBusStatus SMBusMasterI2CWriteRead(tSMBus *psSMBus,
uint8_t ui8TargetAddress,
uint8_t *pui8TxData,
uint8_t ui8TxSize,
uint8_t *pui8RxData,
uint8_t ui8RxSize);
extern tSMBusStatus SMBusMasterARPGetUDIDGen(tSMBus *psSMBus,
uint8_t *pui8Data);
extern tSMBusStatus SMBusMasterARPGetUDIDDir(tSMBus *psSMBus,
uint8_t ui8TargetAddress,
uint8_t *pui8Data);
extern tSMBusStatus SMBusMasterARPResetDeviceGen(tSMBus *psSMBus);
extern tSMBusStatus SMBusMasterARPResetDeviceDir(tSMBus *psSMBus,
uint8_t ui8TargetAddress);
extern tSMBusStatus SMBusMasterARPAssignAddress(tSMBus *psSMBus,
uint8_t *pui8Data);
extern tSMBusStatus SMBusMasterARPNotifyMaster(tSMBus *psSMBus,
uint8_t *pui8Data);
extern tSMBusStatus SMBusMasterARPPrepareToARP(tSMBus *psSMBus);
extern tSMBusStatus SMBusMasterIntProcess(tSMBus *psSMBus);
extern void SMBusMasterIntEnable(tSMBus *psSMBus);
extern void SMBusMasterInit(tSMBus *psSMBus, uint32_t ui32I2CBase,
uint32_t ui32SMBusClock);
extern void SMBusSlaveTxBufferSet(tSMBus *psSMBus, uint8_t *pui8Data,
uint8_t ui8Size);
extern void SMBusSlaveRxBufferSet(tSMBus *psSMBus, uint8_t *pui8Data,
uint8_t ui8Size);
extern uint8_t SMBusSlaveCommandGet(tSMBus *psSMBus);
extern void SMBusSlaveProcessCallEnable(tSMBus *psSMBus);
extern void SMBusSlaveProcessCallDisable(tSMBus *psSMBus);
extern void SMBusSlaveBlockTransferEnable(tSMBus *psSMBus);
extern void SMBusSlaveBlockTransferDisable(tSMBus *psSMBus);
extern void SMBusSlaveI2CEnable(tSMBus *psSMBus);
extern void SMBusSlaveI2CDisable(tSMBus *psSMBus);
extern void SMBusSlaveARPFlagARSet(tSMBus *psSMBus, bool bValue);
extern bool SMBusSlaveARPFlagARGet(tSMBus *psSMBus);
extern void SMBusSlaveARPFlagAVSet(tSMBus *psSMBus, bool bValue);
extern bool SMBusSlaveARPFlagAVGet(tSMBus *psSMBus);
extern void SMBusSlaveTransferInit(tSMBus *psSMBus);
extern tSMBusStatus SMBusSlaveIntProcess(tSMBus *psSMBus);
extern tSMBusStatus SMBusSlaveDataSend(tSMBus *psSMBus);
extern void SMBusSlaveACKSend(tSMBus *psSMBus, bool bACK);
extern void SMBusSlaveManualACKEnable(tSMBus *psSMBus);
extern void SMBusSlaveManualACKDisable(tSMBus *psSMBus);
extern bool SMBusSlaveManualACKStatusGet(tSMBus *psSMBus);
extern tSMBusStatus SMBusSlaveIntAddressGet(tSMBus *psSMBus);
extern void SMBusSlaveIntEnable(tSMBus *psSMBus);
extern void SMBusSlaveUDIDSet(tSMBus *psSMBus, tSMBusUDID *pUDID);
extern void SMBusSlaveAddressSet(tSMBus *psSMBus, uint8_t ui8AddressNum,
uint8_t ui8SlaveAddress);
extern void SMBusSlaveInit(tSMBus *psSMBus, uint32_t ui32I2CBase);
//*****************************************************************************
//
// Mark the end of the C bindings section for C++ compilers.
//
//*****************************************************************************
#ifdef __cplusplus
}
#endif
#endif // __SMBUS_H__