diff options
Diffstat (limited to 'recipes/i2c-tools')
19 files changed, 3251 insertions, 0 deletions
diff --git a/recipes/i2c-tools/i2c-tools_3.0.1.bb b/recipes/i2c-tools/i2c-tools_3.0.1.bb new file mode 100644 index 0000000000..c8ea32a5f1 --- /dev/null +++ b/recipes/i2c-tools/i2c-tools_3.0.1.bb @@ -0,0 +1,12 @@ +DESCRIPTION = "Set of i2c tools for linux" +SECTION = "base" +LICENSE = "GPL" + +SRC_URI = "http://dl.lm-sensors.org/i2c-tools/releases/i2c-tools-${PV}.tar.bz2" + +inherit autotools + +do_compile_prepend() { + sed -i 's_/usr/local_/usr_' Makefile + sed -i 's_CC\t:= gcc_CC\t:= ${CC}_' Makefile +} diff --git a/recipes/i2c-tools/i2c-tools_3.0.2.bb b/recipes/i2c-tools/i2c-tools_3.0.2.bb new file mode 100644 index 0000000000..c8ea32a5f1 --- /dev/null +++ b/recipes/i2c-tools/i2c-tools_3.0.2.bb @@ -0,0 +1,12 @@ +DESCRIPTION = "Set of i2c tools for linux" +SECTION = "base" +LICENSE = "GPL" + +SRC_URI = "http://dl.lm-sensors.org/i2c-tools/releases/i2c-tools-${PV}.tar.bz2" + +inherit autotools + +do_compile_prepend() { + sed -i 's_/usr/local_/usr_' Makefile + sed -i 's_CC\t:= gcc_CC\t:= ${CC}_' Makefile +} diff --git a/recipes/i2c-tools/picodlp-control/Config.h b/recipes/i2c-tools/picodlp-control/Config.h new file mode 100644 index 0000000000..83bb46de84 --- /dev/null +++ b/recipes/i2c-tools/picodlp-control/Config.h @@ -0,0 +1,41 @@ +/**************************************************************************** +* +* Copyright (c) 2006 Dave Hylands <dhylands@gmail.com> +* +* This program is free software; you can redistribute it and/or modify +* it under the terms of the GNU General Public License version 2 as +* published by the Free Software Foundation. +* +* Alternatively, this software may be distributed under the terms of BSD +* license. +* +* See README and COPYING for more details. +* +****************************************************************************/ +/** +* +* @file Config.h +* +* @brief Global Configuration information. +* +****************************************************************************/ + +#if !defined( CONFIG_H ) +#define CONFIG_H /**< Include Guard */ + +/* ---- Include Files ---------------------------------------------------- */ + +/* ---- Constants and Types ---------------------------------------------- */ + +/** + * Sets Logging parameters + */ + +#define CFG_LOG_TO_BUFFER 0 + +#define CFG_CRC8BLOCK 1 + +/** @} */ + +#endif // CONFIG_H + diff --git a/recipes/i2c-tools/picodlp-control/Crc8.c b/recipes/i2c-tools/picodlp-control/Crc8.c new file mode 100644 index 0000000000..87dcf5c2f4 --- /dev/null +++ b/recipes/i2c-tools/picodlp-control/Crc8.c @@ -0,0 +1,149 @@ +/**************************************************************************** +* +* Copyright (c) 2006 Dave Hylands <dhylands@gmail.com> +* +* This program is free software; you can redistribute it and/or modify +* it under the terms of the GNU General Public License version 2 as +* published by the Free Software Foundation. +* +* Alternatively, this software may be distributed under the terms of BSD +* license. +* +* See README and COPYING for more details. +* +****************************************************************************/ +/** +* +* @file Crc8.c +* +* @brief This file contains the definition of the CRC-8 algorithim +* used by SMBus +* +* +*****************************************************************************/ + +/* ---- Include Files ----------------------------------------------------- */ + +#include "Config.h" + +#include "Crc8.h" + +#include "Log.h" + +/* ---- Public Variables -------------------------------------------------- */ +/* ---- Private Constants and Types --------------------------------------- */ +/* ---- Private Variables ------------------------------------------------- */ +/* ---- Private Function Prototypes --------------------------------------- */ +/* ---- Functions --------------------------------------------------------- */ + +/****************************************************************************/ +/** +* Calculates the CRC-8 used as part of SMBus. +* +* CRC-8 is defined to be x^8 + x^2 + x + 1 +* +* To use this function use the following template: +* +* crc = Crc8( crc, data ); +*/ + +#if 0 // Traditional implementation + +#define POLYNOMIAL (0x1070U << 3) + +unsigned char Crc8( unsigned char inCrc, unsigned char inData ) +{ + int i; + unsigned short data; + + data = inCrc ^ inData; + data <<= 8; + + for ( i = 0; i < 8; i++ ) + { + if (( data & 0x8000 ) != 0 ) + { + data = data ^ POLYNOMIAL; + } + data = data << 1; + } + +#if 0 +#if defined( LogBuf2 ) + LogBuf2( "Crc8: data:0x%02x crc:0x%02x\n", inData, (unsigned char)( data >> 8 )); +#else + + Log( "Crc8: data:0x%02x crc:0x%02x\n", inData, (unsigned char)( data >> 8 )); +#endif + +#endif + + + return (unsigned char)( data >> 8 ); + +} // Crc8 + +#else // Optimized for 8 bit CPUs (0x22 bytes on ATMega128 versus 0x30 for above version) + +unsigned char Crc8( unsigned char inCrc, unsigned char inData ) +{ + unsigned char i; + unsigned char data; + + data = inCrc ^ inData; + + for ( i = 0; i < 8; i++ ) + { + if (( data & 0x80 ) != 0 ) + { + data <<= 1; + data ^= 0x07; + } + else + { + data <<= 1; + } + } + +#if 0 +#if defined( LogBuf2 ) + LogBuf2( "Crc8: data:0x%02x crc:0x%02x\n", inData, data ); +#else + + Log( "Crc8: data:0x%02x crc:0x%02x\n", inData, data ); +#endif + +#endif + + + return data; + +} // Crc8 + +#endif + + +#if defined( CFG_CRC8BLOCK ) + +/****************************************************************************/ +/** +* Calculates the CRC-8 used as part of SMBus over a block of memory. +*/ + +uint8_t Crc8Block( uint8_t crc, uint8_t *data, uint8_t len ) +{ + while ( len > 0 ) + { + crc = Crc8( crc, *data++ ); + len--; + } + + return crc; + +} // Crc8Block + +#endif // CFG_CRC8BLOCK + +/** @} */ + + diff --git a/recipes/i2c-tools/picodlp-control/Crc8.h b/recipes/i2c-tools/picodlp-control/Crc8.h new file mode 100644 index 0000000000..2d1f74b82c --- /dev/null +++ b/recipes/i2c-tools/picodlp-control/Crc8.h @@ -0,0 +1,54 @@ +/**************************************************************************** +* +* Copyright (c) 2006 Dave Hylands <dhylands@gmail.com> +* +* This program is free software; you can redistribute it and/or modify +* it under the terms of the GNU General Public License version 2 as +* published by the Free Software Foundation. +* +* Alternatively, this software may be distributed under the terms of BSD +* license. +* +* See README and COPYING for more details. +* +****************************************************************************/ +/** +* +* @file Crc8.h +* +* @brief This file contains the definition of the CRC-8 algorithim +* used by SMBus +* +****************************************************************************/ + +#if !defined( CRC8_H ) +#define CRC_H ///< Include Guard + +/* ---- Include Files ----------------------------------------------------- */ + +#include <inttypes.h> + +#if defined( __cplusplus ) +extern "C" +{ +#endif + + +/* ---- Constants and Types ---------------------------------------------- */ +/* ---- Variable Externs ------------------------------------------------- */ +/* ---- Function Prototypes ---------------------------------------------- */ + +uint8_t Crc8( uint8_t crc, uint8_t data ); + +uint8_t Crc8Block( uint8_t crc, uint8_t *data, uint8_t len ); + + +#if defined( __cplusplus ) +} +#endif + + +/** @} */ + +#endif // CRC8_H + diff --git a/recipes/i2c-tools/picodlp-control/DumpMem.c b/recipes/i2c-tools/picodlp-control/DumpMem.c new file mode 100644 index 0000000000..e13e94b0f8 --- /dev/null +++ b/recipes/i2c-tools/picodlp-control/DumpMem.c @@ -0,0 +1,93 @@ +/**************************************************************************** +* +* Copyright (c) 2006 Dave Hylands <dhylands@gmail.com> +* +* This program is free software; you can redistribute it and/or modify +* it under the terms of the GNU General Public License version 2 as +* published by the Free Software Foundation. +* +* Alternatively, this software may be distributed under the terms of BSD +* license. +* +* See README and COPYING for more details. +* +****************************************************************************/ +/** +* +* @file DumpMem.c +* +* @brief Memmory dump routine +* +****************************************************************************/ + +// ---- Include Files ------------------------------------------------------- + +#include <inttypes.h> +#include "DumpMem.h" +#include "Log.h" + +// ---- Public Variables ---------------------------------------------------- +// ---- Private Constants and Types ----------------------------------------- +// ---- Private Variables --------------------------------------------------- +// ---- Private Function Prototypes ----------------------------------------- +// ---- Functions ----------------------------------------------------------- + +/**************************************************************************/ +/** +* Dumps a page of output for debugging purposes. +*/ + +void DumpMem( const char *prefix, unsigned address, const void *inData, unsigned numBytes ) +{ + const uint8_t *data = (const uint8_t *)inData; + unsigned byteOffset; + + if ( numBytes == 0 ) + { + Log( "%s: No data\n", prefix ); + return; + } + +#define LINE_WIDTH 16 + + for ( byteOffset = 0; byteOffset < numBytes; byteOffset += LINE_WIDTH ) + { + unsigned i; + + Log( "%s: %04x: ", prefix, address + byteOffset ); + + for ( i = 0; i < LINE_WIDTH; i++ ) + { + if (( byteOffset + i ) < numBytes ) + { + Log( "%02.2X ", data[ byteOffset + i ] ); + } + else + { + Log( " " ); + } + } + for ( i = 0; i < LINE_WIDTH; i++ ) + { + if (( byteOffset + i ) < numBytes ) + { + unsigned char ch = data[ byteOffset + i ]; + if (( ch < ' ' ) || ( ch > '~' )) + { + Log( "." ); + } + else + { + Log( "%c", ch ); + } + } + else + { + break; + } + } + Log( "\n" ); + } + +} // DumpMem + diff --git a/recipes/i2c-tools/picodlp-control/DumpMem.h b/recipes/i2c-tools/picodlp-control/DumpMem.h new file mode 100644 index 0000000000..5d536f49e8 --- /dev/null +++ b/recipes/i2c-tools/picodlp-control/DumpMem.h @@ -0,0 +1,49 @@ +/**************************************************************************** +* +* Copyright (c) 2006 Dave Hylands <dhylands@gmail.com> +* +* This program is free software; you can redistribute it and/or modify +* it under the terms of the GNU General Public License version 2 as +* published by the Free Software Foundation. +* +* Alternatively, this software may be distributed under the terms of BSD +* license. +* +* See README and COPYING for more details. +* +****************************************************************************/ +/** +* +* @file DumpMem.h +* +* @brief Debug routine for dumping memory +* +****************************************************************************/ + +#if !defined( DUMPMEM_H ) +#define DUMPMEM_H ///< Include Guard + +// ---- Include Files ------------------------------------------------------- + +/** + * @addtogroup Log + * @{ + */ + +#if defined( __cplusplus ) +extern "C" +{ +#endif + + +void DumpMem( const char *prefix, unsigned address, const void *data, unsigned numBytes ); + +#if defined( __cplusplus ) +} +#endif + + +/** @} */ + +#endif // DUMPMEM_H + diff --git a/recipes/i2c-tools/picodlp-control/Log.c b/recipes/i2c-tools/picodlp-control/Log.c new file mode 100644 index 0000000000..e32783391b --- /dev/null +++ b/recipes/i2c-tools/picodlp-control/Log.c @@ -0,0 +1,335 @@ +/**************************************************************************** +* +* Copyright (c) 2006 Dave Hylands <dhylands@gmail.com> +* +* This program is free software; you can redistribute it and/or modify +* it under the terms of the GNU General Public License version 2 as +* published by the Free Software Foundation. +* +* Alternatively, this software may be distributed under the terms of BSD +* license. +* +* See README and COPYING for more details. +* +****************************************************************************/ +/** +* +* @file Log.cpp +* +* @brief This file contains the implementation of the logging functions. +* +****************************************************************************/ + +// ---- Include Files ------------------------------------------------------- + +#include "Log.h" + +#if CFG_LOG_USE_STDIO +# include <stdio.h> +#else + +# include "Str.h" +# include "UART.h" +#endif + + +// ---- Public Variables ---------------------------------------------------- +// ---- Private Constants and Types ----------------------------------------- + +#if defined( AVR ) + +#undef Log +#undef LogError +#undef vLog + +#define Log Log_P +#define LogError LogError_P +#define vLog vLog_P +#define LogBuf LogBuf_P + +#define char prog_char + +#else + + +#define PSTR(str) str + +int gVerbose = 0; +int gDebug = 0; +int gQuiet = 0; + +#endif + + +#if CFG_LOG_TO_BUFFER + +volatile LOG_Buffer_t LOG_gBuffer; + +#endif + + +// ---- Private Variables --------------------------------------------------- + +#if CFG_LOG_USE_STDIO + +FILE *gLogFs = NULL; + +#endif + + +// ---- Private Function Prototypes ----------------------------------------- + +// ---- Functions ----------------------------------------------------------- + +/** + * @addtogroup Log + * @{ + */ + +#if !defined( AVR ) + +void DefaultLogFunc( int logLevel, const char *fmt, va_list args ) +{ + FILE *fs; + + if ( gQuiet && ( logLevel == LOG_LEVEL_NORMAL )) + { + return; + } + + if ( gLogFs == NULL ) + { + fs = stderr; + } + else + { + fs = gLogFs; + } + + if ( logLevel == LOG_LEVEL_ERROR ) + { + fprintf( fs, "ERROR: " ); + } + vfprintf( fs, fmt, args ); + fflush( fs ); + +} // DefaultLogFunc + +static LogFunc_t gLogFunc = DefaultLogFunc; + +void SetLogFunc( LogFunc_t logFunc ) +{ + + gLogFunc = logFunc; + +} // SetLogFunc + +#endif + + +//*************************************************************************** +/** +* Sets the logging stream +*/ + +#if CFG_LOG_USE_STDIO +void LogInit( FILE *logFs ) +{ + gLogFs = logFs; + +} // LogInit + +#else + + +static int LogToUartFunc( void *outParm, int ch ) +{ + UART0_PutChar( ch ); + + return 1; +} +#endif + + +//*************************************************************************** +/** +* Logs a string using printf like semantics +*/ + +void Log +( + const char *fmt, ///< printf style format specifier + ... ///< variable list of arguments +) +{ + va_list args; + + va_start( args, fmt ); + vLog( fmt, args ); + va_end( args ); +} + +//*************************************************************************** +/** +* Logs a string using printf like semantics +*/ + +void vLog +( + const char *fmt, ///< printf style format specified + va_list args ///< variable list of arguments +) +{ + // For now we call printf directly. A better way would be to install + // a callback which does the real work + +#if defined( AVR ) +# if CFG_LOG_USE_STDIO + if ( gLogFs != NULL ) + { + vfprintf_P( gLogFs, fmt, args ); + } +# else + + vStrXPrintf_P( LogToUartFunc, NULL, fmt, args ); +# endif + +#else + + if ( gLogFunc != NULL ) + { + gLogFunc( LOG_LEVEL_NORMAL, fmt, args ); + } +#endif + +} + +#if !defined( AVR ) + +//*************************************************************************** +/** +* Logs an error. +*/ + +void vLogError +( + const char *fmt, ///< printf style format specified + va_list args ///< variable list of arguments +) +{ + if ( gLogFunc != NULL ) + { + gLogFunc( LOG_LEVEL_ERROR, fmt, args ); + } +} + +#endif + + +/***************************************************************************/ +/** +* Logs an error +*/ + +void LogError +( + const char *fmt, ///< printf style format specifier + ... ///< variable list of arguments +) +{ + va_list args; + +#if defined( AVR ) + //Log( "ERROR: " ); + //Log_P( PSTR( "ERROR: " )); + + va_start( args, fmt ); + vLog( fmt, args ); + va_end( args ); +#else + + va_start( args, fmt ); + vLogError( fmt, args ); + va_end( args ); +#endif + + +} // LogError + +/***************************************************************************/ +/** +* Logs an entry to the log buffer +*/ + +#if CFG_LOG_TO_BUFFER + +void LogBuf( const char *fmt, uint8_t arg1, uint8_t arg2 LOG_EXTRA_PARAMS_DECL ) +{ +#if defined( AVR ) + uint8_t sreg = SREG; + cli(); +#endif + + + if ( CBUF_IsFull( LOG_gBuffer )) + { + volatile LOG_Entry_t *entry = CBUF_GetLastEntryPtr( LOG_gBuffer ); + + entry->fmt = PSTR( "*** Lost Messages ***\n" ); + } + else + { + volatile LOG_Entry_t *entry = CBUF_GetPushEntryPtr( LOG_gBuffer ); + + entry->fmt = fmt; + entry->param1 = arg1; + entry->param2 = arg2; + +#if CFG_LOG_EXTRA_PARAMS + entry->param3 = arg3; + entry->param4 = arg4; +#endif + + + CBUF_AdvancePushIdx( LOG_gBuffer ); + } + +#if defined( AVR ) + SREG = sreg; +#endif + + +} // LogBuf + +#endif // CFG_LOG_TO_BUFFER + +/***************************************************************************/ +/** +* Dumps any unlogged entries from the log buffer +*/ + +#if CFG_LOG_TO_BUFFER + +void LogBufDump( void ) +{ + while ( !CBUF_IsEmpty( LOG_gBuffer )) + { + volatile LOG_Entry_t *entry = CBUF_GetPopEntryPtr( LOG_gBuffer ); + +#if CFG_LOG_EXTRA_PARAMS + Log( entry->fmt, entry->param1, entry->param2, entry->param3, entry->param4 ); +#else + + Log( entry->fmt, entry->param1, entry->param2 ); +#endif + + + CBUF_AdvancePopIdx( LOG_gBuffer ); + } + +} // LogBufDump + +#endif // CFG_LOG_TO_BUFFER + +/** @} */ + diff --git a/recipes/i2c-tools/picodlp-control/Log.h b/recipes/i2c-tools/picodlp-control/Log.h new file mode 100644 index 0000000000..d12d482fc6 --- /dev/null +++ b/recipes/i2c-tools/picodlp-control/Log.h @@ -0,0 +1,232 @@ +/**************************************************************************** +* +* Copyright (c) 2006 Dave Hylands <dhylands@gmail.com> +* +* This program is free software; you can redistribute it and/or modify +* it under the terms of the GNU General Public License version 2 as +* published by the Free Software Foundation. +* +* Alternatively, this software may be distributed under the terms of BSD +* license. +* +* See README and COPYING for more details. +* +****************************************************************************/ +/** +* +* @file Log.h +* +* @brief Contains some logging macros. +* +****************************************************************************/ +/** +* @defgroup Log Logging +* +* @brief Provides a common interface for logging. +* +****************************************************************************/ + +#if !defined( LOG_H ) +#define LOG_H ///< Include Guard + +// ---- Include Files ------------------------------------------------------- + +#include <stdarg.h> +#include <stdio.h> + +#if !defined( CONFIG_H ) +# include "Config.h" +#endif + +#if !defined( CFG_LOG_USE_STDIO ) +# define CFG_LOG_USE_STDIO 1 +#endif + + +#if defined( AVR ) +# include <avr/pgmspace.h> +# include <avr/interrupt.h> +#endif + + +#if CFG_LOG_TO_BUFFER +# if !defined( CBUF_H ) +# include "CBUF.h" +# endif + +#endif + + + +/** + * @addtogroup Log + * @{ + */ + +#if !defined( CFG_LOG_ENABLED ) +# define CFG_LOG_ENABLED 1 +#endif + + +#if !CFG_LOG_ENABLED + +#define Log( fmt, args... ) +#define LogError( fmt, args... ) + +#else + + +#if defined( __cplusplus ) +extern "C" +{ +#endif + + +/*************************************************************************** +* +* Log Buffer support +*/ + +#if CFG_LOG_TO_BUFFER + +#if defined( AVR ) + +typedef struct +{ + const prog_char *fmt; + uint8_t param1; + uint8_t param2; +#if CFG_LOG_EXTRA_PARAMS + uint8_t param3; + uint8_t param4; +#endif + + +} LOG_Entry_t; + +#if CFG_LOG_EXTRA_PARAMS +# define LOG_EXTRA_PARAMS_DECL , uint8_t arg3, uint8_t arg4 +# define LOG_EXTRA_PARAMS , 0, 0 +#else + +# define LOG_EXTRA_PARAMS_DECL +# define LOG_EXTRA_PARAMS +#endif + + +void LogBuf_P( const prog_char *fmt, uint8_t arg1, uint8_t arg2 LOG_EXTRA_PARAMS_DECL ); + +#define LogBuf0( fmt ) LogBuf_P( PSTR( fmt ), 0, 0 LOG_EXTRA_PARAMS ) +#define LogBuf1( fmt, arg1 ) LogBuf_P( PSTR( fmt ), arg1, 0 LOG_EXTRA_PARAMS ) +#define LogBuf2( fmt, arg1, arg2 ) LogBuf_P( PSTR( fmt ), arg1, arg2 LOG_EXTRA_PARAMS ) + +#if CFG_LOG_EXTRA_PARAMS +#define LogBuf3( fmt, arg1, arg2, arg3 ) LogBuf_P( PSTR( fmt ), arg1, arg2, arg3, 0 ) +#define LogBuf4( fmt, arg1, arg2, arg3, arg4 ) LogBuf_P( PSTR( fmt ), arg1, arg2, arg3, arg4 ) +#endif + + +#else + + +typedef struct +{ + const char *fmt; + uint8_t param1; + uint8_t param2; + +} LOG_Entry_t; + +void LogBuf( const char *fmt, uint8_t arg1, uint8_t arg2 ); + +#define LogBuf0( fmt, arg1 ) LogBuf( fmt, 0, 0 ) +#define LogBuf1( fmt, arg1 ) LogBuf( fmt, arg1, 0 ) +#define LogBuf2( fmt, arg1, arg2 ) LogBuf( fmt, arg1, arg2 ) + +#endif // AVR + +#if ( CFG_LOG_NUM_BUFFER_ENTRIES > 128 ) +typedef uint16_t LOG_BufferIdx_t; +#else + +typedef uint8_t LOG_BufferIdx_t; +#endif + + +typedef struct +{ + LOG_BufferIdx_t m_getIdx; + LOG_BufferIdx_t m_putIdx; + LOG_Entry_t m_entry[ CFG_LOG_NUM_BUFFER_ENTRIES ]; + +} LOG_Buffer_t; + +extern volatile LOG_Buffer_t LOG_gBuffer; + +#define LOG_gBuffer_SIZE ( sizeof( LOG_gBuffer.m_entry ) / sizeof( LOG_gBuffer.m_entry[ 0 ] )) + +void LogBufDump( void ); + +#endif // CFG_LOG_TO_BUFFER + +/*************************************************************************** +* +* Regular logging support +*/ + +#if CFG_LOG_USE_STDIO +extern FILE *gLogFs; + +void LogInit( FILE *logFs ); +#endif + + +#if defined( AVR ) + +void Log_P( const prog_char *fmt, ... ); +void LogError_P( const prog_char *fmt, ... ); +void vLog_P( const prog_char *fmt, va_list args ); + +#define Log( fmt, args... ) Log_P( PSTR( fmt ), ## args ) +#define LogError( fmt, args... ) LogError_P( PSTR( fmt ), ## args ) +#define vLog( fmt, va_list, args ) vLog_P( PSTR( fmt ), args ) + +#else // AVR + +#define LOG_LEVEL_NORMAL 0 +#define LOG_LEVEL_ERROR 1 + +typedef void (*LogFunc_t)( int logLevel, const char *fmt, va_list args ); + +extern int gVerbose; +extern int gDebug; +extern int gQuiet; + +void Log( const char *fmt, ... ); +void LogError( const char *fmt, ... ); +void vLog( const char *fmt, va_list args ); +void vLogError( const char *fmt, va_list args ); + +#define Log_P( fmt, args... ) Log( fmt, ## args ) +#define LogError_P( fmt, args... ) LogError( fmt, ## args ) +#define vLog_P( fmt, args ) vLog( fmt, args ) + +#define LogDebug( fmt, args... ) do { if ( gDebug ) { Log( fmt, ## args ); }} while (0) +#define LogVerbose( fmt, args... ) do { if ( gVerbose ) { Log( fmt, ## args ); }} while (0) + +void SetLogFunc( LogFunc_t logFunc ); +void DefaultLogFunc( int logLevel, const char *fmt, va_list args ); + +#endif // AVR + +#if defined( __cplusplus ) +} +#endif + + +#endif // CFG_LOG_ENABLED + +/** @} */ + +#endif // LOG_H + diff --git a/recipes/i2c-tools/picodlp-control/i2c-api.c b/recipes/i2c-tools/picodlp-control/i2c-api.c new file mode 100644 index 0000000000..cfc41565a4 --- /dev/null +++ b/recipes/i2c-tools/picodlp-control/i2c-api.c @@ -0,0 +1,522 @@ +/**************************************************************************** +* +* Copyright (c) 2006 Dave Hylands <dhylands@gmail.com> +* +* This program is free software; you can redistribute it and/or modify +* it under the terms of the GNU General Public License version 2 as +* published by the Free Software Foundation. +* +* Alternatively, this software may be distributed under the terms of BSD +* license. +* +* See README and COPYING for more details. +* +****************************************************************************/ +/** +* +* @file i2c-api.c +* +* @brief This file contains the implementation for performing I2C operations +* on the gumstix. +* +****************************************************************************/ + +// ---- Include Files ------------------------------------------------------- + +#include <string.h> +#include <errno.h> + +#include "i2c.h" +#include "i2c-dev.h" +#include "i2c-api.h" + +#include "Crc8.h" +#include "DumpMem.h" +#include "Log.h" + +// ---- Public Variables ---------------------------------------------------- + +// ---- Private Constants and Types ----------------------------------------- + +// ---- Private Variables --------------------------------------------------- + +static I2C_Addr_t gI2cAddr; +static int gUseCrc; + +// ---- Private Function Prototypes ----------------------------------------- + +// ---- Functions ----------------------------------------------------------- + +//*************************************************************************** +/** +* +* Sets the I2C address that we'll be communicating with, as well as whether +* the device uses smbus PEC (CRC). +*/ + +void I2cSetSlaveAddress( int i2cDev, I2C_Addr_t i2cAddr, int useCrc ) +{ + gI2cAddr = i2cAddr; + gUseCrc = useCrc; + + LogDebug( "----- I2cSetSlaveAddress i2cAddr:0x%02x useCrc:%d -----\n", + i2cAddr, useCrc ); + + // Indicate which slave we wish to speak to + + if ( ioctl( i2cDev, I2C_SLAVE, gI2cAddr ) < 0 ) + { + LogError( "I2cSetSlaveAddress: Error trying to set slave address to 0x%02x (%d %s)\n", + gI2cAddr, errno, strerror( errno )); + } + + // We do the CRC calculation ourself, so we don't need to tell the driver + // that we're using it. + +#if 0 + // Indicate that we use PEC (aka CRCs) + + if ( ioctl( i2cDev, I2C_PEC, 1 ) < 0 ) + { + LogError( "I2cSetSlaveAddress: Error trying to set PEC mode\n" ); + } +#endif + +} // I2cSetSlaveAddress + +//*************************************************************************** +/** +* Transfer data to/from an i2c device. +* +* This function implements the equivalent of the smbus functions using +* I2C_RDWR. +* +* The PXA driver doesn't support the smbus transfers. +* +* This function can perform the following SMBUS transactions: +* +* Write Byte: wrLen == 1, rdLen == 0 +* Read Byte: wrLen == 0, rdLen == 1 +* Write Word: wrLen == 2, rdLen == 0 +* Read Word: wrLen == 0, rdLen == 2 +* Process Call: wrLen == 2, rdLen == 2 +* Write Block: wrLen == 0x80 + numBytes, rdLen == 0 +* Read Block: wrLen == 0, rdLen == 0x80 + numBytes +* Process Block: wrLen == 0x80 + numBytes, rdLen == 0x80 + numBytes +*/ + +int I2cTransfer +( + int i2cDev, ///< Handle to i2c-dev file + uint8_t cmd, ///< Command to send + const void *wrData, ///< Data to write + uint8_t wrLen, ///< Number of bytes to write (or in 0x80 for a block write) + void *rdData, ///< Place to store data read + uint8_t rdLen, ///< Number of bytes to read (or in 0x80 for a block read) + uint8_t *bytesReadp ///< Place to store number of bytes read +) +{ + struct i2c_rdwr_ioctl_data rdwr; + struct i2c_msg msg[ 2 ]; + uint8_t wrBuf[ I2C_MAX_DATA_LEN + 3 ]; // +1 for cmd, +1 for len, +1 for CRC + uint8_t rdBuf[ I2C_MAX_DATA_LEN + 2 ]; // +1 for len, +1 for CRC + uint8_t crc = 0; + uint8_t wrBlock = (( wrLen & 0x80 ) != 0 ); + uint8_t rdBlock = (( rdLen & 0x80 ) != 0 ); + int rc = 0; + + LogDebug( "----- I2cTransfer: cmd:0x%02x wrLen:0x%02x rdLen:0x%02x wrBlock:%d rdBlock:%d -----\n", + cmd, wrLen, rdLen, wrBlock, rdBlock ); + if ( wrData != NULL ) + { + LogDebug( "----- wrData:0x%08x *wrData:0x%02x -----\n", wrData, *(const uint8_t *)wrData ); + } + + rdLen &= 0x7f; + wrLen &= 0x7f; + + if ( bytesReadp != NULL ) + { + *bytesReadp = 0; + } + + if ( wrLen > I2C_MAX_DATA_LEN ) + { + LogError( "I2cTransfer: wrLen too big: %d, max is %d\n", + wrLen, I2C_MAX_DATA_LEN ); + errno = ENOBUFS; + return -1; + } + + if ( rdLen > I2C_MAX_DATA_LEN ) + { + LogError( "I2cTransfer: rdLen too big: %d, max is %d\n", + rdLen, I2C_MAX_DATA_LEN ); + errno = ENOBUFS; + return -1; + } + + // Whether we're doing a read or a write, we always send + // the command. + + msg[ 0 ].addr = gI2cAddr; + msg[ 0 ].flags = 0; + msg[ 0 ].len = wrLen + 1 + wrBlock; // +1 for cmd + msg[ 0 ].buf = (char *)&wrBuf[ 0 ]; + + if ( gUseCrc ) + { + crc = Crc8( 0, gI2cAddr << 1 ); + crc = Crc8( crc, cmd ); + } + + wrBuf[ 0 ] = cmd; + + if ( wrLen > 0 ) + { + // We have some data to send down to the device + + if ( wrBlock ) + { + wrBuf[ 1 ] = wrLen; + memcpy( &wrBuf[ 2 ], wrData, wrLen ); + wrLen++; // Add in cmd to the length + } + else + { + memcpy( &wrBuf[ 1 ], wrData, wrLen ); + } + if ( gUseCrc ) + { + crc = Crc8Block( crc, &wrBuf[ 1 ], wrLen ); + + if ( rdLen == 0 ) + { + // This is a write-only, so we need to send the CRC + + wrBuf[ wrLen + 1 ] = crc; + msg[ 0 ].len++; + } + } + } + + if ( gDebug ) + { + Log( "msg[ 0 ].addr = 0x%02x\n", msg[ 0 ].addr ); + Log( "msg[ 0 ].flags = 0x%04x\n", msg[ 0 ].flags ); + Log( "msg[ 0 ].len = %d\n", msg[ 0 ].len ); + DumpMem( "I2cTransfer W", 0, &wrBuf[ 0 ], msg[ 0 ].len ); + } + + rdwr.msgs = msg; + rdwr.nmsgs = 1; + + if ( rdLen > 0 ) + { + // We're expecting some data to come back + + msg[ 1 ].addr = gI2cAddr; + msg[ 1 ].flags = I2C_M_RD; + msg[ 1 ].len = rdLen + rdBlock + gUseCrc; + msg[ 1 ].buf = (char *)&rdBuf[ 0 ]; + + rdwr.nmsgs = 2; + + if ( gUseCrc ) + { + crc = Crc8( crc, ( gI2cAddr << 1 ) | 1 ); + } + + if ( gDebug ) + { + Log( "msg[ 1 ].addr = 0x%02x\n", msg[ 1 ].addr ); + Log( "msg[ 1 ].flags = 0x%04x\n", msg[ 1 ].flags ); + Log( "msg[ 1 ].len = %d\n", msg[ 1 ].len ); + } + } + + if ( ioctl( i2cDev, I2C_RDWR, &rdwr ) < 0 ) + { + LogError( "I2cTransfer: ioctl failed: %s (%d)\n", strerror( errno ), errno ); + return -1; + } + + if ( rdLen > 0 ) + { + if ( rdBlock ) + { + if ( rdBuf[ 0 ] > rdLen ) + { + LogError( "I2cTransfer: length is too big: %d max: %d\n", rdBuf[ 0 ], rdLen ); + + rc = EMSGSIZE; + } + else + { + rdLen = rdBuf[ 0 ]; + } + } + + if ( gUseCrc ) + { + crc = Crc8Block( crc, &rdBuf[ 0 ], rdLen + rdBlock ); + + if ( crc != rdBuf[ rdLen + rdBlock ] ) + { + LogError( "I2cTransfer: CRC failed: Rcvd: 0x%02x, expecting: 0x%02x\n", + rdBuf[ rdLen + rdBlock ], crc ); + rc = EBADMSG; + } + } + + if ( gDebug ) + { + DumpMem( "I2cTransfer R", 0, &rdBuf[ 0 ], msg[ 1 ].len ); + } + memcpy( rdData, &rdBuf[ rdBlock ], rdLen ); + + if ( bytesReadp != NULL ) + { + *bytesReadp = rdLen; + } + } + return rc; + +} // I2cTransfer + +//*************************************************************************** +/** +* Uses the SMBUS Process-Block protocol to read data from a device. +*/ + +int I2cProcessBlock +( + int i2cDev, ///< Handle to i2c-dev file + uint8_t cmd, ///< Command to send + const void *wrData, ///< Data to write + uint8_t wrLen, ///< Number of bytes to write + void *rdData, ///< Place to store data read + uint8_t rdLen, ///< Number of bytes to read + uint8_t *bytesReadp ///< Place to store number of bytes read +) +{ + LogDebug( "----- I2cProcessBlock cmd: 0x%02x wrLen:0x%02x rdLen:0x%02x -----\n", cmd, wrLen, rdLen ); + + return I2cTransfer( i2cDev, cmd, wrData, 0x80 | wrLen, rdData, 0x80 | rdLen, bytesReadp ); + +} // I2cProcessBlock + +//*************************************************************************** +/** +* Uses the SMBUS Read-Block protocol to read data from a device. +*/ + +int I2cReadBlock +( + int i2cDev, ///< Handle to i2c-dev file + uint8_t cmd, ///< Command to send + void *rdData, ///< Place to store data read + uint8_t rdLen, ///< Number of bytes to read + uint8_t *bytesReadp ///< Place to store number of bytes read +) +{ + LogDebug( "----- I2cReadBlock cmd: 0x%02x rdLen:0x%02x -----\n", cmd, rdLen ); + + return I2cTransfer( i2cDev, cmd, NULL, 0, rdData, 0x80 | rdLen, bytesReadp ); + +} // I2cReadBlock + +//*************************************************************************** +/** +* Uses the SMBUS Read-Byte protocol to read a byte. +*/ + +int I2cReadByte +( + int i2cDev, ///< Handle to i2c-dev file + uint8_t cmd, ///< Command to send + uint8_t *rdByte ///< Place to store byte read +) +{ + LogDebug( "----- I2cReadByte cmd: 0x%02x -----\n", cmd ); + + return I2cTransfer( i2cDev, cmd, NULL, 0, rdByte, 1, NULL ); + +} // I2cReadByte + +//*************************************************************************** +/** +* Reads an array of bytes usinng i2c (not compatible with SMBUS) +*/ + +int I2cReadBytes +( + int i2cDev, ///< Handle to i2c-dev file + uint8_t cmd, ///< Command to send + void *rdByte, ///< Place to store bytes read + uint8_t rdLen ///< Number of bytes to read +) +{ + LogDebug( "----- I2cReadBytes cmd: 0x%02x rdLen: 0x%02x -----\n", cmd, rdLen ); + + return I2cTransfer( i2cDev, cmd, NULL, 0, rdByte, rdLen, NULL ); + +} // I2cReadBytes + +//*************************************************************************** +/** +* Uses the SMBUS Write-Block protocol to write data from a device. +*/ + +int I2cWriteBlock +( + int i2cDev, ///< Handle to i2c-dev file + uint8_t cmd, ///< Command to send + const void *wrData, ///< Data to write + uint8_t wrLen ///< Number of bytes to write +) +{ + LogDebug( "----- I2cWriteBlock cmd: 0x%02x wrLen:0x%02x -----\n", cmd, wrLen ); + + return I2cTransfer( i2cDev, cmd, wrData, 0x80 | wrLen, NULL, 0, NULL ); + +} // I2cWriteBlock + +//*************************************************************************** +/** +* Uses the SMBUS Write-Byte protocol to write a byte. +*/ + +int I2cWriteByte +( + int i2cDev, ///< Handle to i2c-dev file + uint8_t cmd, ///< Command to send + uint8_t wrByte ///< Byte to write +) +{ + LogDebug( "----- I2cWriteByte cmd: 0x%02x wrByte:0x%02x -----\n", cmd, wrByte ); + LogDebug( "----- &wrByte = 0x%08x wrByte = 0x%02x -----\n", &wrByte, *&wrByte ); + + return I2cTransfer( i2cDev, cmd, &wrByte, 1, NULL, 0, NULL ); + +} // I2cWriteByte + +//*************************************************************************** +/** +* Writes an array of bytes using i2c (not compatible with SMBUS) +*/ + +int I2cWriteBytes +( + int i2cDev, ///< Handle to i2c-dev file + uint8_t cmd, ///< Command to send + const void *wrByte, ///< Bytes to write + uint8_t wrLen ///< Number of bytes to write +) +{ + LogDebug( "----- I2cWriteBytes cmd: 0x%02x wrLen: 0x%02x -----\n", cmd, wrLen ); + + return I2cTransfer( i2cDev, cmd, wrByte, wrLen, NULL, 0, NULL ); + +} // I2cWriteBytes + +//*************************************************************************** +/** +* Uses the SMBUS Receive-Byte protocol to read a byte. +*/ + +int I2cReceiveByte +( + int i2cDev, ///< Handle to i2c-dev file + uint8_t *rdByte ///< Place to store byte read +) +{ + return I2cReceiveBytes( i2cDev, rdByte, 1 ); + +} // I2cReceiveByte + +//*************************************************************************** +/** +* Uses the SMBUS Receive-Byte protocol to read multiple (or one or zero) bytes. +*/ + +int I2cReceiveBytes +( + int i2cDev, ///< Handle to i2c-dev file + uint8_t *rdData, ///< Place to store data read + uint8_t rdLen ///< Number of bytes to read +) +{ + struct i2c_rdwr_ioctl_data rdwr; + struct i2c_msg msg; + + LogDebug( "----- I2cReceiveBytes -----\n" ); + + msg.addr = gI2cAddr; + msg.flags = I2C_M_RD; + msg.len = rdLen; + msg.buf = (char *)rdData; + + rdwr.msgs = &msg; + rdwr.nmsgs = 1; + + if ( ioctl( i2cDev, I2C_RDWR, &rdwr ) < 0 ) + { + LogError( "I2cReceiveBytes: ioctl failed: %s (%d)\n", strerror( errno ), errno ); + return -1; + } + + return 0; + +} // I2cReceiveBytes + +//*************************************************************************** +/** +* Uses the SMBUS Send-Byte protocol to write a byte. +*/ + +int I2cSendByte +( + int i2cDev, ///< Handle to i2c-dev file + uint8_t wrByte ///< Byte to write +) +{ + return I2cSendBytes( i2cDev, &wrByte, 1 ); + +} // I2cSendByte + +//*************************************************************************** +/** +* Uses the SMBUS Send-Byte protocol to write multiple (or zero or one) bytes. +*/ + +int I2cSendBytes +( + int i2cDev, ///< Handle to i2c-dev file + uint8_t *wrData, ///< Pointer to data to write + uint8_t wrLen ///< NUmber of bytes to write +) +{ + struct i2c_rdwr_ioctl_data rdwr; + struct i2c_msg msg; + + LogDebug( "----- I2cSendBytes wrLen = 0x%02x -----\n", wrLen ); + + msg.addr = gI2cAddr; + msg.flags = 0; + msg.len = wrLen; + msg.buf = (char *)wrData; + + rdwr.msgs = &msg; + rdwr.nmsgs = 1; + + if ( ioctl( i2cDev, I2C_RDWR, &rdwr ) < 0 ) + { + LogError( "I2cSendBytes: ioctl failed: %s (%d)\n", strerror( errno ), errno ); + return -1; + } + + return 0; + +} // I2cSendBytes + diff --git a/recipes/i2c-tools/picodlp-control/i2c-api.h b/recipes/i2c-tools/picodlp-control/i2c-api.h new file mode 100644 index 0000000000..73f9f20990 --- /dev/null +++ b/recipes/i2c-tools/picodlp-control/i2c-api.h @@ -0,0 +1,143 @@ +/**************************************************************************** +* +* Copyright (c) 2006 Dave Hylands <dhylands@gmail.com> +* +* This program is free software; you can redistribute it and/or modify +* it under the terms of the GNU General Public License version 2 as +* published by the Free Software Foundation. +* +* Alternatively, this software may be distributed under the terms of BSD +* license. +* +* See README and COPYING for more details. +* +****************************************************************************/ +/** +* +* @file i2c-api.h +* +* @brief This file contains definitions for performing i2c operations +* on the gumstix. +* +****************************************************************************/ + +#if !defined( I2C_API_H ) +#define I2C_API_H + +// ---- Include Files ------------------------------------------------------- + +#include <inttypes.h> +#include "i2c.h" + +// ---- Constants and Types ------------------------------------------------- + +#define I2C_USE_CRC 1 +#define I2C_NO_CRC 0 + +// ---- Variable Externs ---------------------------------------------------- + +// ---- Function Prototypes ------------------------------------------------- + +void I2cSetSlaveAddress +( + int i2cDev, ///< Handle to i2c-dev file + I2C_Addr_t i2cAddr, ///< 7 bit i2c address to use + int useCrc ); ///< Should CRC's be used? + +int I2cTransfer +( + int i2cDev, ///< Handle to i2c-dev file + uint8_t cmd, ///< Command to send + const void *wrData, ///< Data to write + uint8_t wrLen, ///< Number of bytes to write (or in 0x80 for a block write) + void *rdData, ///< Place to store data read + uint8_t rdLen, ///< Number of bytes to read (or in 0x80 for a block read) + uint8_t *bytesReadp ///< Place to store number of bytes read +); + +int I2cProcessBlock +( + int i2cDev, ///< Handle to i2c-dev file + uint8_t cmd, ///< Command to send + const void *wrData, ///< Data to write + uint8_t wrLen, ///< Number of bytes to write + void *rdData, ///< Place to store data read + uint8_t rdLen, ///< Number of bytes to read + uint8_t *bytesReadp ///< Place to store number of bytes read +); + +int I2cReadBlock +( + int i2cDev, ///< Handle to i2c-dev file + uint8_t cmd, ///< Command to send + void *rdData, ///< Place to store data read + uint8_t rdLen, ///< Number of bytes to read + uint8_t *bytesReadp ///< Place to store number of bytes read +); + +int I2cReadByte +( + int i2cDev, ///< Handle to i2c-dev file + uint8_t cmd, ///< Command to send + uint8_t *rdByte ///< Place to store byte to read +); + +int I2cReadBytes +( + int i2cDev, ///< Handle to i2c-dev file + uint8_t cmd, ///< Command to send + void *rdByte, ///< Place to store bytes read + uint8_t rdLen ///< Number of bytes to read +); + +int I2cWriteBlock +( + int i2cDev, ///< Handle to i2c-dev file + uint8_t cmd, ///< Command to send + const void *wrData, ///< Data to write + uint8_t wrLen ///< Number of bytes to write +); + +int I2cWriteByte +( + int i2cDev, ///< Handle to i2c-dev file + uint8_t cmd, ///< Command to send + uint8_t wrByte ///< Byte to write +); + +int I2cWriteBytes +( + int i2cDev, ///< Handle to i2c-dev file + uint8_t cmd, ///< Command to send + const void *wrByte, ///< Bytes to write + uint8_t wrLen ///< Number of bytes to write +); + +int I2cReceiveByte +( + int i2cDev, ///< Handle to i2c-dev file + uint8_t *rdByte ///< Place to store byte read +); + +int I2cReceiveBytes +( + int i2cDev, ///< Handle to i2c-dev file + uint8_t *rdData, ///< Place to store byte read + uint8_t rdLen ///< Number of bytes to read +); + +int I2cSendByte +( + int i2cDev, ///< Handle to i2c-dev file + uint8_t wrByte ///< Byte to write +); + +int I2cSendBytes +( + int i2cDev, ///< Handle to i2c-dev file + uint8_t *wrData, ///< Pointer to data to write. + uint8_t wrLen ///< Number of bytes to write. +); + +#endif // I2C_API_H + diff --git a/recipes/i2c-tools/picodlp-control/i2c-dev.h b/recipes/i2c-tools/picodlp-control/i2c-dev.h new file mode 100644 index 0000000000..cd20965ede --- /dev/null +++ b/recipes/i2c-tools/picodlp-control/i2c-dev.h @@ -0,0 +1,365 @@ +/* + i2c-dev.h - i2c-bus driver, char device interface + + Copyright (C) 1995-97 Simon G. Vogl + Copyright (C) 1998-99 Frodo Looijaard <frodol@dds.nl> + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. +*/ + +/* $Id: i2c-dev.h,v 1.4 2003/11/27 23:08:06 tat Exp $ */ + +#ifndef LIB_I2CDEV_H +#define LIB_I2CDEV_H + +#include <linux/types.h> +#include <sys/ioctl.h> + + +/* -- i2c.h -- */ + + +/* + * I2C Message - used for pure i2c transaction, also from /dev interface + */ +struct i2c_msg { + __u16 addr; /* slave address */ + unsigned short flags; +#define I2C_M_TEN 0x10 /* we have a ten bit chip address */ +#define I2C_M_RD 0x01 +#define I2C_M_NOSTART 0x4000 +#define I2C_M_REV_DIR_ADDR 0x2000 +#define I2C_M_IGNORE_NAK 0x1000 +#define I2C_M_NO_RD_ACK 0x0800 + short len; /* msg length */ + char *buf; /* pointer to msg data */ +}; + +/* To determine what functionality is present */ + +#define I2C_FUNC_I2C 0x00000001 +#define I2C_FUNC_10BIT_ADDR 0x00000002 +#define I2C_FUNC_PROTOCOL_MANGLING 0x00000004 /* I2C_M_{REV_DIR_ADDR,NOSTART,..} */ +#define I2C_FUNC_SMBUS_HWPEC_CALC 0x00000008 /* SMBus 2.0 */ +#define I2C_FUNC_SMBUS_READ_WORD_DATA_PEC 0x00000800 /* SMBus 2.0 */ +#define I2C_FUNC_SMBUS_WRITE_WORD_DATA_PEC 0x00001000 /* SMBus 2.0 */ +#define I2C_FUNC_SMBUS_PROC_CALL_PEC 0x00002000 /* SMBus 2.0 */ +#define I2C_FUNC_SMBUS_BLOCK_PROC_CALL_PEC 0x00004000 /* SMBus 2.0 */ +#define I2C_FUNC_SMBUS_BLOCK_PROC_CALL 0x00008000 /* SMBus 2.0 */ +#define I2C_FUNC_SMBUS_QUICK 0x00010000 +#define I2C_FUNC_SMBUS_READ_BYTE 0x00020000 +#define I2C_FUNC_SMBUS_WRITE_BYTE 0x00040000 +#define I2C_FUNC_SMBUS_READ_BYTE_DATA 0x00080000 +#define I2C_FUNC_SMBUS_WRITE_BYTE_DATA 0x00100000 +#define I2C_FUNC_SMBUS_READ_WORD_DATA 0x00200000 +#define I2C_FUNC_SMBUS_WRITE_WORD_DATA 0x00400000 +#define I2C_FUNC_SMBUS_PROC_CALL 0x00800000 +#define I2C_FUNC_SMBUS_READ_BLOCK_DATA 0x01000000 +#define I2C_FUNC_SMBUS_WRITE_BLOCK_DATA 0x02000000 +#define I2C_FUNC_SMBUS_READ_I2C_BLOCK 0x04000000 /* I2C-like block xfer */ +#define I2C_FUNC_SMBUS_WRITE_I2C_BLOCK 0x08000000 /* w/ 1-byte reg. addr. */ +#define I2C_FUNC_SMBUS_READ_I2C_BLOCK_2 0x10000000 /* I2C-like block xfer */ +#define I2C_FUNC_SMBUS_WRITE_I2C_BLOCK_2 0x20000000 /* w/ 2-byte reg. addr. */ +#define I2C_FUNC_SMBUS_READ_BLOCK_DATA_PEC 0x40000000 /* SMBus 2.0 */ +#define I2C_FUNC_SMBUS_WRITE_BLOCK_DATA_PEC 0x80000000 /* SMBus 2.0 */ + +#define I2C_FUNC_SMBUS_BYTE I2C_FUNC_SMBUS_READ_BYTE | \ + I2C_FUNC_SMBUS_WRITE_BYTE +#define I2C_FUNC_SMBUS_BYTE_DATA I2C_FUNC_SMBUS_READ_BYTE_DATA | \ + I2C_FUNC_SMBUS_WRITE_BYTE_DATA +#define I2C_FUNC_SMBUS_WORD_DATA I2C_FUNC_SMBUS_READ_WORD_DATA | \ + I2C_FUNC_SMBUS_WRITE_WORD_DATA +#define I2C_FUNC_SMBUS_BLOCK_DATA I2C_FUNC_SMBUS_READ_BLOCK_DATA | \ + I2C_FUNC_SMBUS_WRITE_BLOCK_DATA +#define I2C_FUNC_SMBUS_I2C_BLOCK I2C_FUNC_SMBUS_READ_I2C_BLOCK | \ + I2C_FUNC_SMBUS_WRITE_I2C_BLOCK +#define I2C_FUNC_SMBUS_I2C_BLOCK_2 I2C_FUNC_SMBUS_READ_I2C_BLOCK_2 | \ + I2C_FUNC_SMBUS_WRITE_I2C_BLOCK_2 +#define I2C_FUNC_SMBUS_BLOCK_DATA_PEC I2C_FUNC_SMBUS_READ_BLOCK_DATA_PEC | \ + I2C_FUNC_SMBUS_WRITE_BLOCK_DATA_PEC +#define I2C_FUNC_SMBUS_WORD_DATA_PEC I2C_FUNC_SMBUS_READ_WORD_DATA_PEC | \ + I2C_FUNC_SMBUS_WRITE_WORD_DATA_PEC + +#define I2C_FUNC_SMBUS_READ_BYTE_PEC I2C_FUNC_SMBUS_READ_BYTE_DATA +#define I2C_FUNC_SMBUS_WRITE_BYTE_PEC I2C_FUNC_SMBUS_WRITE_BYTE_DATA +#define I2C_FUNC_SMBUS_READ_BYTE_DATA_PEC I2C_FUNC_SMBUS_READ_WORD_DATA +#define I2C_FUNC_SMBUS_WRITE_BYTE_DATA_PEC I2C_FUNC_SMBUS_WRITE_WORD_DATA +#define I2C_FUNC_SMBUS_BYTE_PEC I2C_FUNC_SMBUS_BYTE_DATA +#define I2C_FUNC_SMBUS_BYTE_DATA_PEC I2C_FUNC_SMBUS_WORD_DATA + +#define I2C_FUNC_SMBUS_EMUL I2C_FUNC_SMBUS_QUICK | \ + I2C_FUNC_SMBUS_BYTE | \ + I2C_FUNC_SMBUS_BYTE_DATA | \ + I2C_FUNC_SMBUS_WORD_DATA | \ + I2C_FUNC_SMBUS_PROC_CALL | \ + I2C_FUNC_SMBUS_WRITE_BLOCK_DATA | \ + I2C_FUNC_SMBUS_WRITE_BLOCK_DATA_PEC | \ + I2C_FUNC_SMBUS_I2C_BLOCK + +/* + * Data for SMBus Messages + */ +#define I2C_SMBUS_BLOCK_MAX 32 /* As specified in SMBus standard */ +#define I2C_SMBUS_I2C_BLOCK_MAX 32 /* Not specified but we use same structure */ +union i2c_smbus_data { + __u8 byte; + __u16 word; + __u8 block[I2C_SMBUS_BLOCK_MAX + 3]; /* block[0] is used for length */ + /* one more for read length in block process call */ + /* and one more for PEC */ +}; + +/* smbus_access read or write markers */ +#define I2C_SMBUS_READ 1 +#define I2C_SMBUS_WRITE 0 + +/* SMBus transaction types (size parameter in the above functions) + Note: these no longer correspond to the (arbitrary) PIIX4 internal codes! */ +#define I2C_SMBUS_QUICK 0 +#define I2C_SMBUS_BYTE 1 +#define I2C_SMBUS_BYTE_DATA 2 +#define I2C_SMBUS_WORD_DATA 3 +#define I2C_SMBUS_PROC_CALL 4 +#define I2C_SMBUS_BLOCK_DATA 5 +#define I2C_SMBUS_I2C_BLOCK_DATA 6 +#define I2C_SMBUS_BLOCK_PROC_CALL 7 /* SMBus 2.0 */ +#define I2C_SMBUS_BLOCK_DATA_PEC 8 /* SMBus 2.0 */ +#define I2C_SMBUS_PROC_CALL_PEC 9 /* SMBus 2.0 */ +#define I2C_SMBUS_BLOCK_PROC_CALL_PEC 10 /* SMBus 2.0 */ +#define I2C_SMBUS_WORD_DATA_PEC 11 /* SMBus 2.0 */ + + +/* ----- commands for the ioctl like i2c_command call: + * note that additional calls are defined in the algorithm and hw + * dependent layers - these can be listed here, or see the + * corresponding header files. + */ + /* -> bit-adapter specific ioctls */ +#define I2C_RETRIES 0x0701 /* number of times a device address */ + /* should be polled when not */ + /* acknowledging */ +#define I2C_TIMEOUT 0x0702 /* set timeout - call with int */ + + +/* this is for i2c-dev.c */ +#define I2C_SLAVE 0x0703 /* Change slave address */ + /* Attn.: Slave address is 7 or 10 bits */ +#define I2C_SLAVE_FORCE 0x0706 /* Change slave address */ + /* Attn.: Slave address is 7 or 10 bits */ + /* This changes the address, even if it */ + /* is already taken! */ +#define I2C_TENBIT 0x0704 /* 0 for 7 bit addrs, != 0 for 10 bit */ + +#define I2C_FUNCS 0x0705 /* Get the adapter functionality */ +#define I2C_RDWR 0x0707 /* Combined R/W transfer (one stop only)*/ +#define I2C_PEC 0x0708 /* != 0 for SMBus PEC */ +#if 0 +#define I2C_ACK_TEST 0x0710 /* See if a slave is at a specific address */ +#endif + +#define I2C_SMBUS 0x0720 /* SMBus-level access */ + +/* -- i2c.h -- */ + + +/* Note: 10-bit addresses are NOT supported! */ + +/* This is the structure as used in the I2C_SMBUS ioctl call */ +struct i2c_smbus_ioctl_data { + char read_write; + __u8 command; + int size; + union i2c_smbus_data *data; +}; + +/* This is the structure as used in the I2C_RDWR ioctl call */ +struct i2c_rdwr_ioctl_data { + struct i2c_msg *msgs; /* pointers to i2c_msgs */ + int nmsgs; /* number of i2c_msgs */ +}; + + +static inline __s32 i2c_smbus_access(int file, char read_write, __u8 command, + int size, union i2c_smbus_data *data) +{ + struct i2c_smbus_ioctl_data args; + int rc; + + args.read_write = read_write; + args.command = command; + args.size = size; + args.data = data; + + rc = ioctl(file,I2C_SMBUS,&args); + + return rc; +} + + +static inline __s32 i2c_smbus_write_quick(int file, __u8 value) +{ + return i2c_smbus_access(file,value,0,I2C_SMBUS_QUICK,NULL); +} + +static inline __s32 i2c_smbus_read_byte(int file) +{ + union i2c_smbus_data data; + if (i2c_smbus_access(file,I2C_SMBUS_READ,0,I2C_SMBUS_BYTE,&data)) + return -1; + else + return 0x0FF & data.byte; +} + +static inline __s32 i2c_smbus_write_byte(int file, __u8 value) +{ + return i2c_smbus_access(file,I2C_SMBUS_WRITE,value, + I2C_SMBUS_BYTE,NULL); +} + +static inline __s32 i2c_smbus_read_byte_data(int file, __u8 command) +{ + union i2c_smbus_data data; + if (i2c_smbus_access(file,I2C_SMBUS_READ,command, + I2C_SMBUS_BYTE_DATA,&data)) + return -1; + else + return 0x0FF & data.byte; +} + +static inline __s32 i2c_smbus_write_byte_data(int file, __u8 command, + __u8 value) +{ + union i2c_smbus_data data; + data.byte = value; + return i2c_smbus_access(file,I2C_SMBUS_WRITE,command, + I2C_SMBUS_BYTE_DATA, &data); +} + +static inline __s32 i2c_smbus_read_word_data(int file, __u8 command) +{ + union i2c_smbus_data data; + if (i2c_smbus_access(file,I2C_SMBUS_READ,command, + I2C_SMBUS_WORD_DATA,&data)) + return -1; + else + return 0x0FFFF & data.word; +} + +static inline __s32 i2c_smbus_write_word_data(int file, __u8 command, + __u16 value) +{ + union i2c_smbus_data data; + data.word = value; + return i2c_smbus_access(file,I2C_SMBUS_WRITE,command, + I2C_SMBUS_WORD_DATA, &data); +} + +static inline __s32 i2c_smbus_process_call(int file, __u8 command, __u16 value) +{ + union i2c_smbus_data data; + data.word = value; + if (i2c_smbus_access(file,I2C_SMBUS_WRITE,command, + I2C_SMBUS_PROC_CALL,&data)) + return -1; + else + return 0x0FFFF & data.word; +} + + +/* Returns the number of read bytes */ +static inline __s32 i2c_smbus_read_block_data(int file, __u8 command, + __u8 *values) +{ + union i2c_smbus_data data; + int i; + if (i2c_smbus_access(file,I2C_SMBUS_READ,command, + I2C_SMBUS_BLOCK_DATA,&data)) + return -1; + else { + for (i = 1; i <= data.block[0]; i++) + values[i-1] = data.block[i]; + return data.block[0]; + } +} + +static inline __s32 i2c_smbus_write_block_data(int file, __u8 command, + __u8 length, __u8 *values) +{ + union i2c_smbus_data data; + int i; + if (length > 32) + length = 32; + for (i = 1; i <= length; i++) + data.block[i] = values[i-1]; + data.block[0] = length; + return i2c_smbus_access(file,I2C_SMBUS_WRITE,command, + I2C_SMBUS_BLOCK_DATA, &data); +} + +/* Returns the number of read bytes */ +static inline __s32 i2c_smbus_read_i2c_block_data(int file, __u8 command, + __u8 *values) +{ + union i2c_smbus_data data; + int i; + if (i2c_smbus_access(file,I2C_SMBUS_READ,command, + I2C_SMBUS_I2C_BLOCK_DATA,&data)) + return -1; + else { + for (i = 1; i <= data.block[0]; i++) + values[i-1] = data.block[i]; + return data.block[0]; + } +} + +static inline __s32 i2c_smbus_write_i2c_block_data(int file, __u8 command, + __u8 length, __u8 *values) +{ + union i2c_smbus_data data; + int i; + if (length > 32) + length = 32; + for (i = 1; i <= length; i++) + data.block[i] = values[i-1]; + data.block[0] = length; + return i2c_smbus_access(file,I2C_SMBUS_WRITE,command, + I2C_SMBUS_I2C_BLOCK_DATA, &data); +} + +/* Returns the number of read bytes */ +static inline __s32 i2c_smbus_block_process_call(int file, __u8 command, + __u8 length, __u8 *values) +{ + union i2c_smbus_data data; + int i; + if (length > 32) + length = 32; + for (i = 1; i <= length; i++) + data.block[i] = values[i-1]; + data.block[0] = length; + i = i2c_smbus_access(file,I2C_SMBUS_WRITE,command, + I2C_SMBUS_BLOCK_PROC_CALL,&data); + if ( i ) + return -1; + else { + for (i = 1; i <= data.block[0]; i++) + values[i-1] = data.block[i]; + return data.block[0]; + } +} + + +#endif /* LIB_I2CDEV_H */ + diff --git a/recipes/i2c-tools/picodlp-control/i2c-io-api.h b/recipes/i2c-tools/picodlp-control/i2c-io-api.h new file mode 100644 index 0000000000..35ab45865c --- /dev/null +++ b/recipes/i2c-tools/picodlp-control/i2c-io-api.h @@ -0,0 +1,52 @@ +/**************************************************************************** +* +* Copyright (c) 2006 Dave Hylands <dhylands@gmail.com> +* +* This program is free software; you can redistribute it and/or modify +* it under the terms of the GNU General Public License version 2 as +* published by the Free Software Foundation. +* +* Alternatively, this software may be distributed under the terms of BSD +* license. +* +* See README and COPYING for more details. +* +****************************************************************************/ +/** +* +* @file i2c-io-api.h +* +* @brief This file contains definitions for performing i2c-io operations +* on the gumstix. +* +****************************************************************************/ + +#if !defined( I2C_IO_API_H ) +#define I2C_IO_API_H + +// ---- Include Files ------------------------------------------------------- + +#include <inttypes.h> +#include "i2c-io.h" + +// ---- Constants and Types ------------------------------------------------- + +// ---- Variable Externs ---------------------------------------------------- + +// ---- Function Prototypes ------------------------------------------------- + +int I2C_IO_CheckVersion( const I2C_IO_Info_t *info ); + +int I2C_IO_GetInfo( int i2cDev, I2C_IO_Info_t *info ); +int I2C_IO_GetGPIO( int i2cDev, uint8_t portNum, uint8_t *pinVal ); +int I2C_IO_SetGPIO( int i2cDev, uint8_t portNum, uint8_t pinMask, uint8_t pinVal ); +int I2C_IO_GetGPIODir( int i2cDev, uint8_t portNum, uint8_t *pinVal ); +int I2C_IO_SetGPIODir( int i2cDev, uint8_t portNum, uint8_t pinMask, uint8_t pinVal ); +int I2C_IO_GetADC( int i2cDev, uint8_t mux, uint16_t *adcVal ); +int I2C_IO_ReadReg8( int i2cDev, uint8_t reg, uint8_t *regVal ); +int I2C_IO_ReadReg16( int i2cDev, uint8_t reg, uint16_t *regVal ); +int I2C_IO_WriteReg8( int i2cDev, uint8_t reg, uint8_t regVal ); +int I2C_IO_WriteReg16( int i2cDev, uint8_t reg, uint16_t regVal ); + +#endif // I2C_IO_API_H + diff --git a/recipes/i2c-tools/picodlp-control/i2c-io.h b/recipes/i2c-tools/picodlp-control/i2c-io.h new file mode 100644 index 0000000000..3ffb5e9c0e --- /dev/null +++ b/recipes/i2c-tools/picodlp-control/i2c-io.h @@ -0,0 +1,220 @@ +/**************************************************************************** +* +* Copyright (c) 2006 Dave Hylands <dhylands@gmail.com> +* +* This program is free software; you can redistribute it and/or modify +* it under the terms of the GNU General Public License version 2 as +* published by the Free Software Foundation. +* +* Alternatively, this software may be distributed under the terms of BSD +* license. +* +* See README and COPYING for more details. +* +****************************************************************************/ +/** +* +* @file i2c-io.h +* +* @brief This file defines the interface to the i2c-io program which +* runs on the robostix. +* +*****************************************************************************/ + +#if !defined( I2C_IO_H ) +#define I2C_IO_H /**< Include Guard */ + +/* ---- Include Files ---------------------------------------------------- */ + +/* ---- Constants and Types ---------------------------------------------- */ + +//--------------------------------------------------------------------------- +/** + * Defines the version of this API. This includes the layout of the + * various structures, along with the semantics associated with the + * protocol. Any changes require the version number to be incremented. + * + * Version 2 - Introduced READ/WRITE_REG_8/16 + */ + +#define I2C_IO_API_VERSION 2 + +//--------------------------------------------------------------------------- +/** + * The min version, determines the minimum version that this API is + * compatable with. This allows old host side programs to determine + * that they're not compatible. + */ + +#define I2C_IO_API_MIN_VERSION 1 + + +//--------------------------------------------------------------------------- +/** +* The I2C_IO_GET_INFO command retrieves information about the i2c-io +* program running on the robostix. +*/ + +#define I2C_IO_GET_INFO 0x01 + +typedef struct +{ + uint8_t version; + uint8_t minVersion; + uint16_t svnRevision; + +} I2C_IO_Info_t; + +//--------------------------------------------------------------------------- +/** +* The I2C_IO_GET_GPIO command retrieves the values of the pins indicated +* by portNum. +* +* The portNum is set such that 0 = A, 1 = B, etc. +* +* A block-reply with a single 8 bit value is returned. +*/ + +typedef struct +{ + uint8_t portNum; + +} I2C_IO_Get_GPIO_t; + +#define I2C_IO_GET_GPIO 0x02 + +//--------------------------------------------------------------------------- +/** +* The I2C_IO_SET_GPIO command sets the values of the pins specified +* by pinMask to the correponding bits in ponVal. +* +* Note: Setting a pin that's configured for input will enable a pullup +* resistor. +* +* The portNum is set such that 0 = A, 1 = B, etc. +*/ + +typedef struct +{ + uint8_t portNum; + uint8_t pinMask; + uint8_t pinVal; + +} I2C_IO_Set_GPIO_t; + +#define I2C_IO_SET_GPIO 0x03 + +//--------------------------------------------------------------------------- +/** +* The I2C_IO_GET_GPIO_DIR command retrieves the data direction +* register (DDR) for the indicated portNum. +* +* The I2C_IO_Get_GPIO_t structure is used for this command. +* +* Note: It's ok to read the values of pins which are set for output. +* +* The portNum is set such that 0 = A, 1 = B, etc. +* +* A block-reply with a single 8 bit value is returned. +* A 1 bit means that the pin is set for output and a 0 bit means that +* the pin is set for input. +*/ + +#define I2C_IO_GET_GPIO_DIR 0x04 + +//--------------------------------------------------------------------------- +/** +* The I2C_IO_SET_GPIO_DIR command sets the data direction +* register (DDR) for the indicated portNum. +* +* The I2C_IO_Set_GPIO_t structure is used for this command. +* +* The portNum is set such that 0 = A, 1 = B, etc. +*/ + +#define I2C_IO_SET_GPIO_DIR 0x05 + +//--------------------------------------------------------------------------- +/** +* The I2C_IO_GET_ADC command performs an ADC sample and returns the result. +* +* mux values 0 thru 7 read singled ended ADC values. Values 8 thru 31 +* return a variety of values. See the data sheet for specifics. +* +* A block-reply with a 16 bit value is returned, although only the +* lower 10 bits are significant. +*/ + +typedef struct +{ + uint8_t mux; + +} I2C_IO_Get_ADC_t; + +#define I2C_IO_GET_ADC 0x06 + +//--------------------------------------------------------------------------- +/** +* The I2C_IO_READ_REG_8 command reads a 8-bit register. +* +* A block reply with an 8 bit value is returned. +*/ + +typedef struct +{ + uint8_t reg; ///< Index of the register to be read. + +} I2C_IO_ReadReg8_t; + +#define I2C_IO_READ_REG_8 0x07 + +//--------------------------------------------------------------------------- +/** +* The I2C_IO_READ_REG_16 command reads a 16-bit register. +* +* A block reply with a 16 bit value is returned. +*/ + +typedef struct +{ + uint8_t reg; ///< Index of the register to be read. + +} I2C_IO_ReadReg16_t; + +#define I2C_IO_READ_REG_16 0x08 + +//--------------------------------------------------------------------------- +/** +* The I2C_IO_WRITE_REG_8 command writes an 8-bit register. +*/ + +typedef struct +{ + uint8_t reg; ///< Index of the register to be read. + uint8_t val; ///< Value to write into the register + +} I2C_IO_WriteReg8_t; + +#define I2C_IO_WRITE_REG_8 0x09 + +//--------------------------------------------------------------------------- +/** +* The I2C_IO_WRITE_REG_16 command writes a 16-bit register. +*/ + +typedef struct +{ + uint8_t reg; ///< Index of the register to be read. + uint8_t pad; ///< Pad for alignment on the host. + uint16_t val; ///< Value to write + +} I2C_IO_WriteReg16_t; + +#define I2C_IO_WRITE_REG_16 0x0A + +/* ---- Variable Externs ------------------------------------------------- */ + +/* ---- Function Prototypes ---------------------------------------------- */ + +#endif /* I2C_IO_H */ + diff --git a/recipes/i2c-tools/picodlp-control/i2c.c b/recipes/i2c-tools/picodlp-control/i2c.c new file mode 100644 index 0000000000..6c752b3bee --- /dev/null +++ b/recipes/i2c-tools/picodlp-control/i2c.c @@ -0,0 +1,710 @@ +/**************************************************************************** +* +* Copyright (c) 2006 Dave Hylands <dhylands@gmail.com> +* +* This program is free software; you can redistribute it and/or modify +* it under the terms of the GNU General Public License version 2 as +* published by the Free Software Foundation. +* +* Alternatively, this software may be distributed under the terms of BSD +* license. +* +* See README and COPYING for more details. +* +****************************************************************************/ +/** +* +* @file i2c.c +* +* @brief This program allows basic i2c commands to be sent out the i2c +* bus, +* +****************************************************************************/ + +// ---- Include Files ------------------------------------------------------- + +#include <stdio.h> +#include <stdlib.h> +#include <getopt.h> +#include <fcntl.h> +#include <errno.h> +#include <string.h> +#include <signal.h> +#include <unistd.h> +#include <sys/timeb.h> + +#include "i2c-dev.h" +#include "i2c-api.h" +#include "i2c-io-api.h" +#include "Log.h" + +// #include "svn-version.h" + +// ---- Public Variables ---------------------------------------------------- +// ---- Private Constants and Types ----------------------------------------- + +// ---- Private Variables --------------------------------------------------- + +enum +{ + OPT_MEM_DEFAULT = 0, + + // Options assigned a single character code can use that charater code + // as a short option. + + OPT_COUNT = 'c', + + // Options from this point onwards don't have any short option equivalents + + OPT_FIRST_LONG_OPT = 0x80, + + OPT_HELP, + OPT_VERSION, +}; + +enum +{ + CMD_DEFAULT, + + CMD_READ_BYTE, + CMD_READ_BYTE_2, + CMD_READ_BYTE_4, + + CMD_WRITE_BYTE, + CMD_WRITE_BYTE_2, + CMD_WRITE_BYTE_4, + + CMD_RECV_BYTE, + CMD_RECV_BYTE_2, + CMD_RECV_BYTE_4, + + CMD_SEND_BYTE, + CMD_SEND_BYTE_2, + CMD_SEND_BYTE_4, +}; + +struct +{ + int cmd; + const char *cmdStr; + +} gCmdMap[] = +{ + { CMD_READ_BYTE, "ReadByte" }, + { CMD_READ_BYTE, "rb" }, + { CMD_READ_BYTE_2, "ReadByte2" }, + { CMD_READ_BYTE_2, "rb2" }, + { CMD_READ_BYTE_4, "ReadByte4" }, + { CMD_READ_BYTE_4, "rb4" }, + + { CMD_WRITE_BYTE, "WriteByte" }, + { CMD_WRITE_BYTE, "wb" }, + { CMD_WRITE_BYTE_2, "WriteByte2" }, + { CMD_WRITE_BYTE_2, "wb2" }, + { CMD_WRITE_BYTE_4, "WriteByte4" }, + { CMD_WRITE_BYTE_4, "wb4" }, + + { CMD_RECV_BYTE, "RecvByte" }, + { CMD_RECV_BYTE, "vb" }, + { CMD_RECV_BYTE_2, "RecvByte2" }, + { CMD_RECV_BYTE_2, "vb2" }, + { CMD_RECV_BYTE_4, "RecvByte4" }, + { CMD_RECV_BYTE_4, "vb4" }, + + { CMD_SEND_BYTE, "SendByte" }, + { CMD_SEND_BYTE, "sb" }, + { CMD_SEND_BYTE_2, "SendByte2" }, + { CMD_SEND_BYTE_2, "sb2" }, + { CMD_SEND_BYTE_4, "SendByte4" }, + { CMD_SEND_BYTE_4, "sb4" }, +}; + +int gNumCmds = sizeof( gCmdMap ) / sizeof( gCmdMap[ 0 ]); + +int gI2cAddr = -1; +int gByteCount = 1; + +const char *gCmdStr; +int gCmd = CMD_DEFAULT; +const char *gAddrStr = NULL; +const char *gDataStr = NULL; + +struct option gOption[] = +{ + { "count", required_argument, NULL, OPT_COUNT }, + { "version", no_argument, NULL, OPT_VERSION }, + { "verbose", no_argument, &gVerbose, 1 }, + { "debug", no_argument, &gDebug, 1 }, + { "help", no_argument, NULL, OPT_HELP }, + { NULL } +}; + +#define TRUE 1 +#define FALSE 0 + +typedef enum +{ + NoADC, + AllowADC, + +} AllowADC_t; + +#define ADC_PORT 8 + +// ---- Private Function Prototypes ----------------------------------------- + +static int ParseByte( const char *byteStr, uint8_t *byte ); +static int ParseBytes( const char *byteStr, uint8_t *byte, uint8_t maxBytes, uint8_t *bytesParsed ); + +static void ProcessReadByteCommand( int i2cDev, const char *addrStr ); +static void ProcessWriteByteCommand( int i2cDev, const char *addrStr, const char *dataStr ); +static void ProcessRecvByteCommand( int i2cDev ); +static void ProcessSendByteCommand( int i2cDev, const char *dataStr ); +static void Usage( void ); + +// ---- Functions ----------------------------------------------------------- + +//*************************************************************************** +/** +* Main entry point +*/ + +int main( int argc, char **argv ) +{ + char shortOptsStr[ sizeof( gOption ) / sizeof( gOption[ 0 ] ) + 1 ]; + char *shortOpts = shortOptsStr; + struct option *scanOpt; + int opt; + const char *i2cDevName = "/dev/i2c-3"; + int i2cDev; + int cmdIdx; + + LogInit( stdout ); + + // Figure out the short options from our options structure + + for ( scanOpt = gOption; scanOpt->name != NULL; scanOpt++ ) + { + if (( scanOpt->flag == NULL ) && ( scanOpt->val < OPT_FIRST_LONG_OPT )) + { + *shortOpts++ = (char)scanOpt->val; + + if ( scanOpt->has_arg != no_argument ) + { + *shortOpts++ = ':'; + } + } + } + *shortOpts++ = '\0'; + + // Parse the command line options + + while (( opt = getopt_long( argc, argv, shortOptsStr, gOption, NULL )) != -1 ) + { + switch ( opt ) + { + case 0: + { + // getopt_long returns 0 for entries where flag is non-NULL + + break; + } + + case OPT_COUNT: + { + gByteCount = (int)strtol( optarg, NULL, 0 ); + if ( gByteCount <= 0 ) + { + LogError( "Expecting byte count >= 0, found: '%s'\n", optarg ); + Usage(); + exit( 1 ); + } + if ( gByteCount > I2C_MAX_DATA_LEN ) + { + LogError( "Max byte count supported: %d, found %d\n", I2C_MAX_DATA_LEN, gByteCount ); + Usage(); + exit( 1 ); + } + break; + } + +// case OPT_VERSION: +// { +// Log( "i2c SVN Revision: %d\n", SVN_REVISION ); +// exit( 0 ); +// break; +// } + + case '?': + case OPT_HELP: + default: + { + LogError( "opt:%d\n", opt ); + Usage(); + exit( 1 ); + } + } + } + argc -= optind; + argv += optind; + + // Verify that an i2c-address was specified + + if ( argc < 1 ) + { + LogError( "Must specify an i2c address\n\n" ); + Usage(); + exit( 1 ); + } + gI2cAddr = strtol( argv[ 0 ], NULL, 0 ); + if (( gI2cAddr <= 0 ) || ( gI2cAddr > 127 )) + { + LogError( "Expecting i2c address in the range of 1-127, Found: %d\n", gI2cAddr ); + Usage(); + exit( 1 ); + } + + // Verify that a command has been specified + + if ( argc < 2 ) + { + LogError( "Must specify a command\n" ); + Usage(); + exit( 1 ); + } + gCmdStr = argv[ 1 ]; + for ( cmdIdx = 0; cmdIdx < gNumCmds; cmdIdx++ ) + { + if ( strcasecmp( gCmdStr, gCmdMap[ cmdIdx ].cmdStr ) == 0 ) + { + gCmd = gCmdMap[ cmdIdx ].cmd; + break; + } + } + if ( gCmd == CMD_DEFAULT ) + { + LogError( "Unrecognized command '%s'\n", gCmdStr ); + exit( 1 ); + } + + // Process command specific arguments + + if (( gCmd == CMD_READ_BYTE_2 ) + || ( gCmd == CMD_WRITE_BYTE_2 ) + || ( gCmd == CMD_RECV_BYTE_2 ) + || ( gCmd == CMD_SEND_BYTE_2 )) + { + gByteCount = 2; + } + else + if (( gCmd == CMD_READ_BYTE_4 ) + || ( gCmd == CMD_WRITE_BYTE_4 ) + || ( gCmd == CMD_RECV_BYTE_4 ) + || ( gCmd == CMD_SEND_BYTE_4 )) + { + gByteCount = 4; + } + + if (( gCmd == CMD_READ_BYTE ) + || ( gCmd == CMD_READ_BYTE_2 ) + || ( gCmd == CMD_READ_BYTE_4 )) + { + if ( argc < 3 ) + { + LogError( "Expecting address\n" ); + Usage(); + exit( 1 ); + } + if ( argc > 3 ) + { + LogError( "Unexpected extra parameters\n" ); + Usage(); + exit( 1 ); + } + + gAddrStr = argv[ 2 ]; + } + else + if (( gCmd == CMD_WRITE_BYTE ) + || ( gCmd == CMD_WRITE_BYTE_2 ) + || ( gCmd == CMD_WRITE_BYTE_4 )) + { + if ( argc < 4 ) + { + LogError( "Expecting address and data\n" ); + Usage(); + exit( 1 ); + } + if ( argc > 4 ) + { + LogError( "Unexpected extra parameters\n" ); + Usage(); + exit( 1 ); + } + + gAddrStr = argv[ 2 ]; + gDataStr = argv[ 3 ]; + } + else + if (( gCmd == CMD_RECV_BYTE ) + || ( gCmd == CMD_RECV_BYTE_2 ) + || ( gCmd == CMD_RECV_BYTE_4 )) + { + if ( argc > 2 ) + { + LogError( "Unexpected extra parameters\n" ); + Usage(); + exit( 1 ); + } + } + else + if (( gCmd == CMD_SEND_BYTE ) + || ( gCmd == CMD_SEND_BYTE_2 ) + || ( gCmd == CMD_SEND_BYTE_4 )) + { + if ( argc < 3 ) + { + LogError( "Expecting data\n" ); + Usage(); + exit( 1 ); + } + if ( argc > 3 ) + { + LogError( "Unexpected extra parameters\n" ); + Usage(); + exit( 1 ); + } + gDataStr = argv[ 2 ]; + } + + if ( gDebug ) + { + Log( "i2cAddr:0x%02x Cmd: %s (%d)", gI2cAddr, gCmdStr, gCmd ); + if ( gAddrStr != NULL ) + { + Log( " Addr: %s", gAddrStr ); + } + if ( gDataStr != NULL ) + { + Log( " Data: %s", gDataStr ); + } + Log( "\n" ); + } + + // Try to open the i2c device + + if (( i2cDev = open( i2cDevName, O_RDWR )) < 0 ) + { + LogError( "Error opening '%s': %s\n", i2cDevName, strerror( errno )); + exit( 1 ); + } + + // Indicate which slave we wish to speak to + + I2cSetSlaveAddress( i2cDev, gI2cAddr, I2C_NO_CRC ); + + switch ( gCmd ) + { + case CMD_READ_BYTE: + case CMD_READ_BYTE_2: + case CMD_READ_BYTE_4: + { + ProcessReadByteCommand( i2cDev, gAddrStr ); + break; + } + + case CMD_WRITE_BYTE: + case CMD_WRITE_BYTE_2: + case CMD_WRITE_BYTE_4: + { + ProcessWriteByteCommand( i2cDev, gAddrStr, gDataStr ); + break; + } + + case CMD_RECV_BYTE: + case CMD_RECV_BYTE_2: + case CMD_RECV_BYTE_4: + { + ProcessRecvByteCommand( i2cDev ); + break; + } + + case CMD_SEND_BYTE: + case CMD_SEND_BYTE_2: + case CMD_SEND_BYTE_4: + { + ProcessSendByteCommand( i2cDev, gDataStr ); + break; + } + } + + close( i2cDev ); + + return 0; + +} // main + +//*************************************************************************** +/** +* Parse a string looking for a single byte. +*/ + +int ParseByte( const char *byteStr, uint8_t *byte ) +{ + char *endPtr; + + *byte = (uint8_t)strtol( byteStr, &endPtr, 0 ); + + if ( *endPtr != '\0' ) + { + LogError( "Expecting numeric value, found '%s'\n", byteStr ); + return FALSE; + } + + return TRUE; + +} // ParseByte + +//*************************************************************************** +/** +* Parse a string looking for an array of bytes. +*/ + +int ParseBytes( const char *byteStr, uint8_t *byte, uint8_t maxBytes, uint8_t *bytesParsed ) +{ + char *endPtr; + + if (( byteStr[ 0 ] == '0' ) && ( byteStr[ 1 ] == 'x' )) + { + const char *s = &byteStr[ 2 ]; + *bytesParsed = 0; + + // Could be a multi-byte hex string + + while ( *s != '\0' ) + { + if ( *bytesParsed >= maxBytes ) + { + LogError( "Too many bytes, max: %d\n", maxBytes ); + return FALSE; + } + + (*bytesParsed)++; + *byte = 0; + + if (( *s >= 'A' ) && ( *s <= 'F' )) + { + *byte = *s - 'A' + 10; + } + else + if (( *s >= 'a' ) && ( *s <= 'f' )) + { + *byte = *s - 'a' + 10; + } + else + if (( *s >= '0' ) && ( *s <= '9' )) + { + *byte = *s - '0'; + } + else + { + LogError( "Expecting hex digit, found '%c'\n", *s ); + return FALSE; + } + s++; + + if ( *s == '\0' ) + { + break; + } + + *byte <<= 4; + if (( *s >= 'A' ) && ( *s <= 'F' )) + { + *byte |= *s - 'A' + 10; + } + else + if (( *s >= 'a' ) && ( *s <= 'f' )) + { + *byte |= *s - 'a' + 10; + } + else + if (( *s >= '0' ) && ( *s <= '9' )) + { + *byte |= *s - '0'; + } + else + { + LogError( "Expecting hex digit, found '%c'\n", *s ); + return FALSE; + } + s++; + byte++; + } + } + else + { + // It's decimal or octal - only a single byte + + *byte = (uint8_t)strtol( byteStr, &endPtr, 0 ); + + if ( *endPtr != '\0' ) + { + LogError( "Expecting numeric value, found '%s'\n", byteStr ); + return FALSE; + } + *bytesParsed = 1; + } + + return TRUE; + +} // ParseBytes + +//*************************************************************************** +/** +* Issues a read byte command to read a byte from a particular address. +*/ + +void ProcessReadByteCommand( int i2cDev, const char *addrStr ) +{ + uint8_t addr; + uint8_t dataByte[ I2C_MAX_DATA_LEN ]; + int rc; + int i; + + if ( !ParseByte( addrStr, &addr )) + { + return; + } + + if (( rc = I2cReadBytes( i2cDev, addr, dataByte, gByteCount )) != 0 ) + { + LogError( "I2cReadByte failed: %d\n", rc ); + return; + } + + Log( "0x", dataByte[0] ); + + for ( i = 0; i < gByteCount; i++ ) + { + Log( "%02x", dataByte[i] ); + } + Log( "\n" ); + +} // ProcessReadByteCommand + +//*************************************************************************** +/** +* Issues a recv byte command to read bytes with no address. +*/ + +void ProcessRecvByteCommand( int i2cDev ) +{ + uint8_t dataByte[ I2C_MAX_DATA_LEN ]; + int rc; + int i; + + if (( rc = I2cReceiveBytes( i2cDev, dataByte, gByteCount )) != 0 ) + { + LogError( "I2cRecvBytes failed: %d\n", rc ); + return; + } + + Log( "0x", dataByte[0] ); + + for ( i = 0; i < gByteCount; i++ ) + { + Log( "%02x", dataByte[i] ); + } + Log( "\n" ); + +} // ProcessRecvByteCommand + +//*************************************************************************** +/** +* Issues a write byte command to write a byte to a particular address. +*/ + +void ProcessWriteByteCommand( int i2cDev, const char *addrStr, const char *dataStr ) +{ + uint8_t addr; + uint8_t dataByte[ I2C_MAX_DATA_LEN ]; + uint8_t bytesParsed; + int rc; + + if ( !ParseByte( addrStr, &addr )) + { + return; + } + + if ( !ParseBytes( dataStr, dataByte, sizeof( dataByte ), &bytesParsed )) + { + return; + } + + if (( rc = I2cWriteBytes( i2cDev, addr, dataByte, bytesParsed )) != 0 ) + { + LogError( "I2cWriteBytes failed: %d\n", rc ); + return; + } + +} // ProcessWriteByteCommand + +//*************************************************************************** +/** +* Issues a send byte command to write bytes with no address specified. +*/ + +void ProcessSendByteCommand( int i2cDev, const char *dataStr ) +{ + uint8_t dataByte[ I2C_MAX_DATA_LEN ]; + uint8_t bytesParsed; + int rc; + + if ( !ParseBytes( dataStr, dataByte, sizeof( dataByte ), &bytesParsed )) + { + return; + } + + if (( rc = I2cSendBytes( i2cDev, dataByte, bytesParsed )) != 0 ) + { + LogError( "I2cSendBytes failed: %d\n", rc ); + return; + } + +} // ProcessSendByteCommand + +//*************************************************************************** +/** +* Usage +*/ + +void Usage( void ) +{ + fprintf( stderr, "Usage: i2c [options] i2c-addr cmd [cmd-arguments]\n" ); + fprintf( stderr, "Send I2C commands\n" ); + fprintf( stderr, "\n" ); + fprintf( stderr, "The following commands are supported:\n" ); + fprintf( stderr, "ReadByte addr Retrieves byte(s) starting at the indicated address\n" ); + fprintf( stderr, "WriteByte addr data Write byte(s) starting at the indicated address\n" ); + fprintf( stderr, "ReadByte2 addr Retrieves two bytes from the indicated address\n" ); + fprintf( stderr, "WriteByte2 addr data Writes two bytes into the indicated address\n" ); + fprintf( stderr, "ReadByte4 addr Retrieves four bytes from the indicated address\n" ); + fprintf( stderr, "WriteByte4 addr data Writes four bytes into the indicated address\n" ); + fprintf( stderr, "RecvByte Retrieves byte(s)(no address specified)\n" ); + fprintf( stderr, "SendByte data Writes byte(s)(no address specified)\n" ); + fprintf( stderr, "RecvByte2 Retrieves 2 bytes (no address specified)\n" ); + fprintf( stderr, "SendByte2 data Writes 2 bytes(no address specified)\n" ); + fprintf( stderr, "RecvByte4 Retrieves 4 bytes (no address specified)\n" ); + fprintf( stderr, "SendByte4 data Writes 4 bytes(no address specified)\n" ); + fprintf( stderr, "\n" ); + fprintf( stderr, "The above commands can be shortened to rb, wb, rb2, wb2, rb4, wb4, vb, sd, vb2 sb2 vb4, and sb4 \n" ); + fprintf( stderr, "respectively.\n" ); + fprintf( stderr, "\n" ); + fprintf( stderr, "The following options may be used:\n" ); + fprintf( stderr, "--count=n Specifies how many bytes to read for ReadByte or RecvByte\n" ); + fprintf( stderr, "--version Prints the SVN version of this program\n" ); + fprintf( stderr, "--verbose Print additional information\n" ); + fprintf( stderr, "--help Prints this information\n" ); +} + diff --git a/recipes/i2c-tools/picodlp-control/i2c.h b/recipes/i2c-tools/picodlp-control/i2c.h new file mode 100644 index 0000000000..bbfd276cec --- /dev/null +++ b/recipes/i2c-tools/picodlp-control/i2c.h @@ -0,0 +1,135 @@ +/**************************************************************************** +* +* Copyright (c) 2006 Dave Hylands <dhylands@gmail.com> +* +* This program is free software; you can redistribute it and/or modify +* it under the terms of the GNU General Public License version 2 as +* published by the Free Software Foundation. +* +* Alternatively, this software may be distributed under the terms of BSD +* license. +* +* See README and COPYING for more details. +* +****************************************************************************/ +/** +* +* @file i2c.h +* +* @brief Global definitions for interfacing with the AVR TWI (aka I2C) +* hardware +* +****************************************************************************/ +/** +* @defgroup xxx Readable version of xxx. +* +* @brief Brief description of what xxx does. +* +* Longer description of what xxx does. +* +****************************************************************************/ + +#if !defined( I2C_H ) +#define I2C_H /**< Include Guard */ + +/* ---- Include Files ---------------------------------------------------- */ + +#include <inttypes.h> + +#if !defined( CONFIG_H ) +# include "Config.h" +#endif + + +/** + * @addtogroup I2C + * @{ + */ + +/* ---- Constants and Types ---------------------------------------------- */ + +/** + * Error Codes + */ + +#define I2C_ERROR_NONE 0 // No Error +#define I2C_ERROR_ADDR_NACK -1 // No response to SLA+R/W +#define I2C_ERROR_DATA_NACK -2 // NACK during data transmission +#define I2C_ERROR_ARBITRATION_LOST -3 // Lost arbitration +#define I2C_ERROR_BAD_LEN -4 // Length is wonky +#define I2C_ERROR_BAD_CRC -5 // CRC failed +#define I2C_ERROR_BUS_ERROR -6 // Someting weird on the i2c bus + +typedef int8_t I2C_Error_t; + +/** + * Since we're loosely following the SMBus spec, we restrict the amount + * of data in each transaction to 32 bytes. + */ + +#define I2C_MAX_DATA_LEN 32 + +/** + * I2C_Addr_t can contain the address of any device on the bus. This + * module only supports 7 bit addressing. + */ + +typedef uint8_t I2C_Addr_t; + +/** + * The I2C_CRC macro can be used to remove all CRC support at compile time. + */ + +#if CFG_I2C_USE_CRC +# define I2C_CRC(x) x +#else + +# define I2C_CRC(x) +#endif + + +/** + * I2C_Data_t encapsulates the data being read or written on the i2c bus. + * This module follows the SMBus spec, whihch specifies a maximum payload + * of 32 bytes. + */ + +typedef struct +{ +#if CFG_I2C_USE_CRC + uint8_t m_crc; +#endif + + + // For reads, m_len is the number of bytes actually read (doesn't include + // the CRC - if present). If a block transfer was performed which has a + // length byte, this length will include the length byte. + + uint8_t m_len; + + // Note: Under SMBus, a block write can consist of a command, a length, + // 32 bytes of payload, and a CRC. + // + // A read response can consist of a length, 32 bytes of data, and a CRC. + + uint8_t m_data[ I2C_MAX_DATA_LEN + 2]; // +1 for the command, +1 for length + +} I2C_Data_t; + +/* ---- Variable Externs ------------------------------------------------- */ + +/** + * Description of variable. + */ + +/* ---- Function Prototypes ---------------------------------------------- */ + +/* + * Just include prototypes here. Put full descriptions in the .c files. + */ + +/** @} */ + +#endif /* I2C_H */ + + diff --git a/recipes/i2c-tools/picodlp-control/picodlp-control b/recipes/i2c-tools/picodlp-control/picodlp-control new file mode 100755 index 0000000000..3c3cd5acbb --- /dev/null +++ b/recipes/i2c-tools/picodlp-control/picodlp-control @@ -0,0 +1,88 @@ +#!/bin/sh + +I2C_APP="/usr/bin/bus3-i2c" +WORD_ON="0xf0000000" +WORD_OFF="0x00000001" +PICO_ADDRESS="0x1b" + +PICO_OPTION="$1" +PICO_OPTION_VALUE="$2" + +# Reading a register needs something like: +# bus3-i2c 0x1b wb 0x15 0x08 +# bus3-i2c 0x1b vb4 + +case ${PICO_OPTION_VALUE} in +"0") + ;; +"1") + ;; +*) + echo "Invalid value" ; PICO_OPTION="invalid-as-well";; +esac + +case ${PICO_OPTION} in +"hflip") + if [ $2 -gt 0 ] ; then + ${I2C_APP} ${PICO_ADDRESS} wb4 0x08 ${WORD_ON} + else + ${I2C_APP} ${PICO_ADDRESS} wb4 0x08 ${WORD_OFF} + fi;; + +"vflip") + if [ $2 -gt 0 ] ; then + ${I2C_APP} ${PICO_ADDRESS} wb4 0x09 ${WORD_ON} + else + ${I2C_APP} ${PICO_ADDRESS} wb4 0x09 ${WORD_OFF} + fi;; + +"temporal-enhance") + if [ $2 -gt 0 ] ; then + ${I2C_APP} ${PICO_ADDRESS} wb4 0x26 ${WORD_ON} + else + ${I2C_APP} ${PICO_ADDRESS} wb4 0x26 ${WORD_OFF} + fi;; + +"rled") + if [ $2 -gt 0 ] ; then + ${I2C_APP} ${PICO_ADDRESS} wb4 0x11 ${WORD_ON} + else + ${I2C_APP} ${PICO_ADDRESS} wb4 0x11 ${WORD_OFF} + fi;; + +"gled") + if [ $2 -gt 0 ] ; then + ${I2C_APP} ${PICO_ADDRESS} wb4 0x12 ${WORD_ON} + else + ${I2C_APP} ${PICO_ADDRESS} wb4 0x12 ${WORD_OFF} + fi;; + +"bled") + if [ $2 -gt 0 ] ; then + ${I2C_APP} ${PICO_ADDRESS} wb4 0x13 ${WORD_ON} + else + ${I2C_APP} ${PICO_ADDRESS} wb4 0x13 ${WORD_OFF} + fi;; + +"itp") + if [ $2 -gt 0 ] ; then + ${I2C_APP} ${PICO_ADDRESS} wb4 0x0B ${WORD_OFF} + ${I2C_APP} ${PICO_ADDRESS} wb4 0x04 ${WORD_ON} + #Parallel RGB Setting + else + ${I2C_APP} ${PICO_ADDRESS} wb4 0x0B $3 + ${I2C_APP} ${PICO_ADDRESS} wb4 0x04 ${WORD_OFF} + #Test Pattern + fi;; +"ledc") + ${I2C_APP} ${PICO_ADDRESS} wb4 0x0E $4 + ${I2C_APP} ${PICO_ADDRESS} wb4 0x0F $5 + ${I2C_APP} ${PICO_ADDRESS} wb4 0x10 $6 + ;; + +*) + echo "Usage: $0 vflip|hflip|temporal-enhance|rled|gled|bled|itp|ledc 0/1 0x";; +esac + + + diff --git a/recipes/i2c-tools/picodlp-control_0.1.bb b/recipes/i2c-tools/picodlp-control_0.1.bb new file mode 100644 index 0000000000..5fb5630d87 --- /dev/null +++ b/recipes/i2c-tools/picodlp-control_0.1.bb @@ -0,0 +1,20 @@ +DESCRIPTION = "Small application to control the pico DLP over I2C" +LICENSE = "GPLv3" +PR = "r3" + +SRC_URI = "file://*.c file://*.h file://${PN}" + +do_configure() { + cp ${WORKDIR}/*.[ch] ${WORKDIR}/${PN} ${S} +} + +do_compile() { + ${CC} -o bus3-i2c *.c ${CFLAGS} ${LDFLAGS} +} + +do_install() { + install -d ${D}/${bindir} + install -m 0755 ${S}/${PN} ${D}/${bindir} + install -m 0755 ${S}/bus3-i2c ${D}/${bindir} +} + diff --git a/recipes/i2c-tools/read-edid_1.4.1.bb b/recipes/i2c-tools/read-edid_1.4.1.bb new file mode 100644 index 0000000000..e1f10ca48d --- /dev/null +++ b/recipes/i2c-tools/read-edid_1.4.1.bb @@ -0,0 +1,19 @@ +DESCRIPTION = "read-edid elucidates various very useful informations from a conforming PnP monitor" +LICENSE = "GPL" + +SRC_URI = "http://john.fremlin.de/programs/linux/read-edid/read-edid-${PV}.tar.gz \ + http://ftp.de.debian.org/debian/pool/main/r/read-edid/read-edid_1.4.1-2.1.diff.gz;patch=1 " + +inherit autotools + +do_compile() { + oe_runmake parse-edid +} + +do_install() { + install -d ${D}/${sbindir} + install -m 0755 parse-edid ${D}/${sbindir}/ +} + +PACKAGES =+ "parse-edid" +FILES_parse-edid = "${sbindir}/parse-edid" |