rename packages/ to recipes/ per earlier agreement

See links below for more details:
http://thread.gmane.org/gmane.comp.handhelds.openembedded/21326
http://thread.gmane.org/gmane.comp.handhelds.openembedded/21816

Signed-off-by: Denys Dmytriyenko <denis@denix.org>
Acked-by: Mike Westerhof <mwester@dls.net>
Acked-by: Philip Balister <philip@balister.org>
Acked-by: Khem Raj <raj.khem@gmail.com>
Acked-by: Marcin Juszkiewicz <hrw@openembedded.org>
Acked-by: Koen Kooi <koen@openembedded.org>
Acked-by: Frans Meulenbroeks <fransmeulenbroeks@gmail.com>

1 files changed, 522 insertions, 0 deletions

diff --git a/recipes/i2c/files/i2c-api.c b/recipes/i2c/files/i2c-api.c
new file mode 100644
index 0000000000..cfc41565a4
--- /dev/null
+++ b/recipes/i2c/files/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
+