recipes/i2c-tools/picodlp-control/i2c-api.c

   1 /****************************************************************************
   2 *
   3 *   Copyright (c) 2006 Dave Hylands     <dhylands@gmail.com>
   4 *
   5 *   This program is free software; you can redistribute it and/or modify
   6 *   it under the terms of the GNU General Public License version 2 as
   7 *   published by the Free Software Foundation.
   8 *
   9 *   Alternatively, this software may be distributed under the terms of BSD
  10 *   license.
  11 *
  12 *   See README and COPYING for more details.
  13 *
  14 ****************************************************************************/
  15 /**
  16 *
  17 *   @file   i2c-api.c
  18 *
  19 *   @brief  This file contains the implementation for performing I2C operations
  20 *           on the gumstix.
  21 *
  22 ****************************************************************************/
  23
  24 // ---- Include Files -------------------------------------------------------
  25
  26 #include <string.h>
  27 #include <errno.h>
  28
  29 #include "i2c.h"
  30 #include "i2c-dev.h"
  31 #include "i2c-api.h"
  32
  33 #include "Crc8.h"
  34 #include "DumpMem.h"
  35 #include "Log.h"
  36
  37 // ---- Public Variables ----------------------------------------------------
  38
  39 // ---- Private Constants and Types -----------------------------------------
  40
  41 // ---- Private Variables ---------------------------------------------------
  42
  43 static  I2C_Addr_t  gI2cAddr;
  44 static  int         gUseCrc;
  45
  46 // ---- Private Function Prototypes -----------------------------------------
  47
  48 // ---- Functions -----------------------------------------------------------
  49
  50 //***************************************************************************
  51 /**
  52 *
  53 *   Sets the I2C address that we'll be communicating with, as well as whether
  54 *   the device uses smbus PEC (CRC).
  55 */
  56
  57 void I2cSetSlaveAddress( int i2cDev, I2C_Addr_t i2cAddr, int useCrc )
  58 {
  59     gI2cAddr = i2cAddr;
  60     gUseCrc  = useCrc;
  61
  62     LogDebug( "----- I2cSetSlaveAddress i2cAddr:0x%02x useCrc:%d -----\n",
  63               i2cAddr, useCrc );
  64
  65     // Indicate which slave we wish to speak to
  66
  67     if ( ioctl( i2cDev, I2C_SLAVE, gI2cAddr ) < 0 )
  68     {
  69         LogError( "I2cSetSlaveAddress: Error trying to set slave address to 0x%02x (%d %s)\n",
  70                   gI2cAddr, errno, strerror( errno ));
  71     }
  72
  73     // We do the CRC calculation ourself, so we don't need to tell the driver
  74     // that we're using it.
  75
  76 #if 0
  77     // Indicate that we use PEC (aka CRCs)
  78
  79     if ( ioctl( i2cDev, I2C_PEC, 1 ) < 0 )
  80     {
  81         LogError( "I2cSetSlaveAddress: Error trying to set PEC mode\n" );
  82     }
  83 #endif
  84
  85 } // I2cSetSlaveAddress
  86
  87 //***************************************************************************
  88 /**
  89 *   Transfer data to/from an i2c device.
  90 *
  91 *   This function implements the equivalent of the smbus functions using
  92 *   I2C_RDWR.
  93 *
  94 *   The PXA driver doesn't support the smbus transfers.
  95 *
  96 *   This function can perform the following SMBUS transactions:
  97 *
  98 *       Write Byte:     wrLen == 1,                 rdLen == 0
  99 *       Read Byte:      wrLen == 0,                 rdLen == 1
 100 *       Write Word:     wrLen == 2,                 rdLen == 0
 101 *       Read Word:      wrLen == 0,                 rdLen == 2
 102 *       Process Call:   wrLen == 2,                 rdLen == 2
 103 *       Write Block:    wrLen == 0x80 + numBytes,   rdLen == 0
 104 *       Read Block:     wrLen == 0,                 rdLen == 0x80 + numBytes
 105 *       Process Block:  wrLen == 0x80 + numBytes,   rdLen == 0x80 + numBytes
 106 */
 107
 108 int I2cTransfer
 109 (
 110     int         i2cDev,        ///< Handle to i2c-dev file
 111     uint8_t     cmd,           ///< Command to send
 112     const void *wrData,        ///< Data to write
 113     uint8_t     wrLen,         ///< Number of bytes to write (or in 0x80 for a block write)
 114     void       *rdData,        ///< Place to store data read
 115     uint8_t     rdLen,         ///< Number of bytes to read  (or in 0x80 for a block read)
 116     uint8_t    *bytesReadp     ///< Place to store number of bytes read
 117 )
 118 {
 119     struct i2c_rdwr_ioctl_data  rdwr;
 120     struct i2c_msg              msg[ 2 ];
 121     uint8_t                     wrBuf[ I2C_MAX_DATA_LEN + 3 ];  // +1 for cmd, +1 for len, +1 for CRC
 122     uint8_t                     rdBuf[ I2C_MAX_DATA_LEN + 2 ];  // +1 for len, +1 for CRC
 123     uint8_t                     crc = 0;
 124     uint8_t                     wrBlock = (( wrLen & 0x80 ) != 0 );
 125     uint8_t                     rdBlock = (( rdLen & 0x80 ) != 0 );
 126     int                         rc = 0;
 127
 128     LogDebug( "----- I2cTransfer: cmd:0x%02x wrLen:0x%02x rdLen:0x%02x wrBlock:%d rdBlock:%d -----\n",
 129               cmd, wrLen, rdLen, wrBlock, rdBlock );
 130     if ( wrData != NULL )
 131     {
 132         LogDebug( "----- wrData:0x%08x *wrData:0x%02x -----\n", wrData, *(const uint8_t *)wrData );
 133     }
 134
 135     rdLen &= 0x7f;
 136     wrLen &= 0x7f;
 137
 138     if ( bytesReadp != NULL )
 139     {
 140         *bytesReadp = 0;
 141     }
 142
 143     if ( wrLen > I2C_MAX_DATA_LEN )
 144     {
 145         LogError( "I2cTransfer: wrLen too big: %d, max is %d\n",
 146                   wrLen, I2C_MAX_DATA_LEN );
 147         errno = ENOBUFS;
 148         return -1;
 149     }
 150
 151     if ( rdLen > I2C_MAX_DATA_LEN )
 152     {
 153         LogError( "I2cTransfer: rdLen too big: %d, max is %d\n",
 154                   rdLen, I2C_MAX_DATA_LEN );
 155         errno = ENOBUFS;
 156         return -1;
 157     }
 158
 159     // Whether we're doing a read or a write, we always send
 160     // the command.
 161
 162     msg[ 0 ].addr  = gI2cAddr;
 163     msg[ 0 ].flags = 0;
 164     msg[ 0 ].len   = wrLen + 1 + wrBlock;    // +1 for cmd
 165     msg[ 0 ].buf   = (char *)&wrBuf[ 0 ];
 166
 167     if ( gUseCrc )
 168     {
 169         crc = Crc8( 0,   gI2cAddr << 1 );
 170         crc = Crc8( crc, cmd );
 171     }
 172
 173     wrBuf[ 0 ] = cmd;
 174
 175     if ( wrLen > 0 )
 176     {
 177         // We have some data to send down to the device
 178
 179         if ( wrBlock )
 180         {
 181             wrBuf[ 1 ] = wrLen;
 182             memcpy( &wrBuf[ 2 ], wrData, wrLen );
 183             wrLen++;    // Add in cmd to the length
 184         }
 185         else
 186         {
 187             memcpy( &wrBuf[ 1 ], wrData, wrLen );
 188         }
 189         if ( gUseCrc )
 190         {
 191             crc = Crc8Block( crc, &wrBuf[ 1 ], wrLen );
 192
 193             if ( rdLen == 0 )
 194             {
 195                 // This is a write-only, so we need to send the CRC
 196
 197                 wrBuf[ wrLen + 1 ] = crc;
 198                 msg[ 0 ].len++;
 199             }
 200         }
 201     }
 202
 203     if ( gDebug )
 204     {
 205         Log( "msg[ 0 ].addr  = 0x%02x\n", msg[ 0 ].addr );
 206         Log( "msg[ 0 ].flags = 0x%04x\n", msg[ 0 ].flags );
 207         Log( "msg[ 0 ].len   = %d\n",     msg[ 0 ].len );
 208         DumpMem( "I2cTransfer W", 0, &wrBuf[ 0 ], msg[ 0 ].len );
 209     }
 210
 211     rdwr.msgs = msg;
 212     rdwr.nmsgs = 1;
 213
 214     if ( rdLen > 0 )
 215     {
 216         // We're expecting some data to come back
 217
 218         msg[ 1 ].addr  = gI2cAddr;
 219         msg[ 1 ].flags = I2C_M_RD;
 220         msg[ 1 ].len   = rdLen + rdBlock + gUseCrc;
 221         msg[ 1 ].buf   = (char *)&rdBuf[ 0 ];
 222
 223         rdwr.nmsgs = 2;
 224
 225         if ( gUseCrc )
 226         {
 227             crc = Crc8( crc, ( gI2cAddr << 1 ) | 1 );
 228         }
 229
 230         if ( gDebug )
 231         {
 232             Log( "msg[ 1 ].addr  = 0x%02x\n", msg[ 1 ].addr );
 233             Log( "msg[ 1 ].flags = 0x%04x\n", msg[ 1 ].flags );
 234             Log( "msg[ 1 ].len   = %d\n",     msg[ 1 ].len );
 235         }
 236     }
 237
 238     if ( ioctl( i2cDev, I2C_RDWR, &rdwr ) < 0 )
 239     {
 240         LogError( "I2cTransfer: ioctl failed: %s (%d)\n", strerror( errno ), errno );
 241         return -1;
 242     }
 243
 244     if ( rdLen > 0 )
 245     {
 246         if ( rdBlock )
 247         {
 248             if ( rdBuf[ 0 ] > rdLen )
 249             {
 250                 LogError( "I2cTransfer: length is too big: %d max: %d\n", rdBuf[ 0 ], rdLen );
 251
 252                 rc = EMSGSIZE;
 253             }
 254             else
 255             {
 256                 rdLen = rdBuf[ 0 ];
 257             }
 258         }
 259
 260         if ( gUseCrc )
 261         {
 262             crc = Crc8Block( crc, &rdBuf[ 0 ], rdLen + rdBlock );
 263
 264             if ( crc != rdBuf[ rdLen + rdBlock ] )
 265             {
 266                 LogError( "I2cTransfer: CRC failed: Rcvd: 0x%02x, expecting: 0x%02x\n",
 267                           rdBuf[ rdLen + rdBlock ], crc );
 268                 rc = EBADMSG;
 269             }
 270         }
 271
 272         if ( gDebug )
 273         {
 274             DumpMem( "I2cTransfer R", 0, &rdBuf[ 0 ], msg[ 1 ].len );
 275         }
 276         memcpy( rdData, &rdBuf[ rdBlock ], rdLen );
 277
 278         if ( bytesReadp != NULL )
 279         {
 280             *bytesReadp = rdLen;
 281         }
 282     }
 283     return rc;
 284
 285 } // I2cTransfer
 286
 287 //***************************************************************************
 288 /**
 289 *   Uses the SMBUS Process-Block protocol to read data from a device.
 290 */
 291
 292 int I2cProcessBlock
 293 (
 294     int         i2cDev,        ///< Handle to i2c-dev file
 295     uint8_t     cmd,           ///< Command to send
 296     const void *wrData,        ///< Data to write
 297     uint8_t     wrLen,         ///< Number of bytes to write
 298     void       *rdData,        ///< Place to store data read
 299     uint8_t     rdLen,         ///< Number of bytes to read
 300     uint8_t    *bytesReadp     ///< Place to store number of bytes read
 301 )
 302 {
 303     LogDebug( "----- I2cProcessBlock cmd: 0x%02x wrLen:0x%02x rdLen:0x%02x -----\n", cmd, wrLen, rdLen );
 304
 305     return I2cTransfer( i2cDev, cmd, wrData, 0x80 | wrLen, rdData, 0x80 | rdLen, bytesReadp );
 306
 307 } // I2cProcessBlock
 308
 309 //***************************************************************************
 310 /**
 311 *   Uses the SMBUS Read-Block protocol to read data from a device.
 312 */
 313
 314 int I2cReadBlock
 315 (
 316     int      i2cDev,        ///< Handle to i2c-dev file
 317     uint8_t  cmd,           ///< Command to send
 318     void    *rdData,        ///< Place to store data read
 319     uint8_t  rdLen,         ///< Number of bytes to read
 320     uint8_t *bytesReadp     ///< Place to store number of bytes read
 321 )
 322 {
 323     LogDebug( "----- I2cReadBlock cmd: 0x%02x rdLen:0x%02x -----\n", cmd, rdLen );
 324
 325     return I2cTransfer( i2cDev, cmd, NULL, 0, rdData, 0x80 | rdLen, bytesReadp );
 326
 327 } // I2cReadBlock
 328
 329 //***************************************************************************
 330 /**
 331 *   Uses the SMBUS Read-Byte protocol to read a byte.
 332 */
 333
 334 int I2cReadByte
 335 (
 336     int      i2cDev,        ///< Handle to i2c-dev file
 337     uint8_t  cmd,           ///< Command to send
 338     uint8_t *rdByte         ///< Place to store byte read
 339 )
 340 {
 341     LogDebug( "----- I2cReadByte cmd: 0x%02x -----\n", cmd );
 342
 343     return I2cTransfer( i2cDev, cmd, NULL, 0, rdByte, 1, NULL );
 344
 345 } // I2cReadByte
 346
 347 //***************************************************************************
 348 /**
 349 *   Reads an array of bytes usinng i2c (not compatible with SMBUS)
 350 */
 351
 352 int I2cReadBytes
 353 (
 354     int         i2cDev,     ///< Handle to i2c-dev file
 355     uint8_t     cmd,        ///< Command to send
 356     void       *rdByte,     ///< Place to store bytes read
 357     uint8_t     rdLen       ///< Number of bytes to read
 358 )
 359 {
 360     LogDebug( "----- I2cReadBytes cmd: 0x%02x rdLen: 0x%02x -----\n", cmd, rdLen );
 361
 362     return I2cTransfer( i2cDev, cmd, NULL, 0, rdByte, rdLen, NULL );
 363
 364 } // I2cReadBytes
 365
 366 //***************************************************************************
 367 /**
 368 *   Uses the SMBUS Write-Block protocol to write data from a device.
 369 */
 370
 371 int I2cWriteBlock
 372 (
 373     int         i2cDev,     ///< Handle to i2c-dev file
 374     uint8_t     cmd,        ///< Command to send
 375     const void *wrData,     ///< Data to write
 376     uint8_t     wrLen       ///< Number of bytes to write
 377 )
 378 {
 379     LogDebug( "----- I2cWriteBlock cmd: 0x%02x wrLen:0x%02x -----\n", cmd, wrLen );
 380
 381     return I2cTransfer( i2cDev, cmd, wrData, 0x80 | wrLen, NULL, 0, NULL );
 382
 383 } // I2cWriteBlock
 384
 385 //***************************************************************************
 386 /**
 387 *   Uses the SMBUS Write-Byte protocol to write a byte.
 388 */
 389
 390 int I2cWriteByte
 391 (
 392     int         i2cDev,     ///< Handle to i2c-dev file
 393     uint8_t     cmd,        ///< Command to send
 394     uint8_t     wrByte      ///< Byte to write
 395 )
 396 {
 397     LogDebug( "----- I2cWriteByte cmd: 0x%02x wrByte:0x%02x -----\n", cmd, wrByte );
 398     LogDebug( "----- &wrByte = 0x%08x wrByte = 0x%02x -----\n", &wrByte, *&wrByte );
 399
 400     return I2cTransfer( i2cDev, cmd, &wrByte, 1, NULL, 0, NULL );
 401
 402 } // I2cWriteByte
 403
 404 //***************************************************************************
 405 /**
 406 *   Writes an array of bytes using i2c (not compatible with SMBUS)
 407 */
 408
 409 int I2cWriteBytes
 410 (
 411     int         i2cDev,     ///< Handle to i2c-dev file
 412     uint8_t     cmd,        ///< Command to send
 413     const void *wrByte,     ///< Bytes to write
 414     uint8_t     wrLen       ///< Number of bytes to write
 415 )
 416 {
 417     LogDebug( "----- I2cWriteBytes cmd: 0x%02x wrLen: 0x%02x -----\n", cmd, wrLen );
 418
 419     return I2cTransfer( i2cDev, cmd, wrByte, wrLen, NULL, 0, NULL );
 420
 421 } // I2cWriteBytes
 422
 423 //***************************************************************************
 424 /**
 425 *   Uses the SMBUS Receive-Byte protocol to read a byte.
 426 */
 427
 428 int I2cReceiveByte
 429 (
 430     int      i2cDev,        ///< Handle to i2c-dev file
 431     uint8_t *rdByte         ///< Place to store byte read
 432 )
 433 {
 434     return I2cReceiveBytes( i2cDev, rdByte, 1 );
 435
 436 } // I2cReceiveByte
 437
 438 //***************************************************************************
 439 /**
 440 *   Uses the SMBUS Receive-Byte protocol to read multiple (or one or zero) bytes.
 441 */
 442
 443 int I2cReceiveBytes
 444 (
 445     int      i2cDev,        ///< Handle to i2c-dev file
 446     uint8_t *rdData,        ///< Place to store data read
 447     uint8_t  rdLen          ///< Number of bytes to read
 448 )
 449 {
 450     struct  i2c_rdwr_ioctl_data rdwr;
 451     struct  i2c_msg             msg;
 452
 453     LogDebug( "----- I2cReceiveBytes -----\n" );
 454
 455     msg.addr    = gI2cAddr;
 456     msg.flags   = I2C_M_RD;
 457     msg.len     = rdLen;
 458     msg.buf     = (char *)rdData;
 459
 460     rdwr.msgs = &msg;
 461     rdwr.nmsgs = 1;
 462
 463     if ( ioctl( i2cDev, I2C_RDWR, &rdwr ) < 0 )
 464     {
 465         LogError( "I2cReceiveBytes: ioctl failed: %s (%d)\n", strerror( errno ), errno );
 466         return -1;
 467     }
 468
 469     return 0;
 470
 471 } // I2cReceiveBytes
 472
 473 //***************************************************************************
 474 /**
 475 *   Uses the SMBUS Send-Byte protocol to write a byte.
 476 */
 477
 478 int I2cSendByte
 479 (
 480     int      i2cDev,        ///< Handle to i2c-dev file
 481     uint8_t  wrByte         ///< Byte to write
 482 )
 483 {
 484     return I2cSendBytes( i2cDev, &wrByte, 1 );
 485
 486 } // I2cSendByte
 487
 488 //***************************************************************************
 489 /**
 490 *   Uses the SMBUS Send-Byte protocol to write multiple (or zero or one) bytes.
 491 */
 492
 493 int I2cSendBytes
 494 (
 495     int      i2cDev,        ///< Handle to i2c-dev file
 496     uint8_t *wrData,        ///< Pointer to data to write
 497     uint8_t  wrLen          ///< NUmber of bytes to write
 498 )
 499 {
 500     struct  i2c_rdwr_ioctl_data rdwr;
 501     struct  i2c_msg             msg;
 502
 503     LogDebug( "----- I2cSendBytes wrLen = 0x%02x -----\n", wrLen );
 504
 505     msg.addr    = gI2cAddr;
 506     msg.flags   = 0;
 507     msg.len     = wrLen;
 508     msg.buf     = (char *)wrData;
 509
 510     rdwr.msgs = &msg;
 511     rdwr.nmsgs = 1;
 512
 513     if ( ioctl( i2cDev, I2C_RDWR, &rdwr ) < 0 )
 514     {
 515         LogError( "I2cSendBytes: ioctl failed: %s (%d)\n", strerror( errno ), errno );
 516         return -1;
 517     }
 518
 519     return 0;
 520
 521 } // I2cSendBytes
 522