play_capture_i2c.h

1. 8623L平台

/*
 *
 * Copyright (c) 2001-2007 Sigma Designs, Inc. 
 * All Rights Reserved. Proprietary and Confidential.
 *
 */

/**
	@file   play_capture_i2c.h
	@brief  i2c apis for capture devices
	
	@author Christian Wolff Sean.Sekwon.Choi
*/

#ifndef __PLAY_CAPTURE_I2C_H__
#define __PLAY_CAPTURE_I2C_H__


/*
 These macros require the following members in the 'instance' struct:
	struct RUA *pRUA;
	RMuint32 I2CModuleID;  // emhwlib Module ID of the I2C bus access
	struct EMhwlibI2CDeviceParameter I2CDevice;
	RMuint8 BaseDevice;  // base device address of the device
 
 When calling these pseudo-functions, 'dev' <= 0 is interpreted as a negative offset to BaseDevice.
 
 Calls to capsam_i2c_write/capsam_i2c_read need to be enclosed by capsam_i2c_open/capsam_i2c_close calls, to set the 
 device address and to allow multiple read/writes to the same device without reconfigurations inbetween.
 
 All other read/write/dump function perform their own capsam_i2c_open/capsam_i2c_close calls.
*/

// multi-thread lock (TODO: needs to be a system-wide emhwlib lock)
extern RMbool capsam_i2c_lock;

// claim I2C bus and set device address
// returns with RM_TIMEOUT if bus is not available within 200 mSec
#define capsam_i2c_open(instance, dev) do { \
	RMstatus err; \
	if (capsam_i2c_lock) { \
		RMuint64 t0, t1; \
		t0 = RMGetTimeInMicroSeconds(); \
		do { \
			t1 = RMGetTimeInMicroSeconds(); \
		} while (capsam_i2c_lock && (RMCyclesElapsed64(t0, t1) < 200000)); \
		if (capsam_i2c_lock) return RM_TIMEOUT; \
	} \
	capsam_i2c_lock = TRUE; \
	if ((dev) <= 0) (instance)->I2CDevice.DevAddr = (instance)->BaseDevice - (dev); \
	else (instance)->I2CDevice.DevAddr = (dev); \
	err = RUASetProperty((instance)->pRUA, (instance)->I2CModuleID, \
		RMI2CPropertyID_DeviceParameter, \
		&((instance)->I2CDevice), sizeof((instance)->I2CDevice), 0); \
	if (RMFAILED(err)) { \
		capsam_i2c_lock = FALSE; \
		return err; \
	} \
} while (0)

// release I2C bus
#define capsam_i2c_close(instance) do { \
	capsam_i2c_lock = FALSE; \
} while (0)

// "quick" single byte write to already set device
#define capsam_i2c_write(instance, addr, data) do { \
	RMstatus err; \
	struct I2C_WriteRMuint8_type i2c_write; \
	i2c_write.SubAddr = (addr); \
	i2c_write.Data = (data); \
	err = RUASetProperty((instance)->pRUA, (instance)->I2CModuleID, \
		RMI2CPropertyID_WriteRMuint8, \
		&i2c_write, sizeof(i2c_write), 0); \
	if (RMFAILED(err)) { \
		capsam_i2c_close(instance); \
		return err; \
	} \
	if (RMFAILED(err)) return err; \
} while (0)

// "quick" single byte read from already set device
#define capsam_i2c_read(instance, addr, data) do { \
	RMstatus err; \
	struct I2C_QueryRMuint8_in_type i2c_param; \
	struct I2C_QueryRMuint8_out_type i2c_res; \
	i2c_param.SubAddr = (addr); \
	err = RUAExchangeProperty((instance)->pRUA, (instance)->I2CModuleID, \
		RMI2CPropertyID_QueryRMuint8, \
		&i2c_param, sizeof(i2c_param), \
		&i2c_res, sizeof(i2c_res)); \
	if (RMFAILED(err)) { \
		capsam_i2c_close(instance); \
		return err; \
	} \
	*(data) = i2c_res.Data; \
} while (0)

// single byte write
#define capsam_i2c_write_dev(instance, dev, addr, data) do { \
	RMstatus err; \
	struct I2C_WriteRMuint8_type i2c_write; \
	i2c_write.SubAddr = (addr); \
	i2c_write.Data = (data); \
	capsam_i2c_open(instance, dev); \
	err = RUASetProperty((instance)->pRUA, (instance)->I2CModuleID, \
		RMI2CPropertyID_WriteRMuint8, \
		&i2c_write, sizeof(i2c_write), 0); \
	capsam_i2c_close(instance); \
	if (RMFAILED(err)) return err; \
} while (0)

// single byte read
#define capsam_i2c_read_dev(instance, dev, addr, data) do { \
	RMstatus err; \
	struct I2C_QueryRMuint8_in_type i2c_param; \
	struct I2C_QueryRMuint8_out_type i2c_res; \
	i2c_param.SubAddr = (addr); \
	capsam_i2c_open(instance, dev); \
	err = RUAExchangeProperty((instance)->pRUA, (instance)->I2CModuleID, \
		RMI2CPropertyID_QueryRMuint8, \
		&i2c_param, sizeof(i2c_param), \
		&i2c_res, sizeof(i2c_res)); \
	capsam_i2c_close(instance); \
	if (RMFAILED(err)) return err; \
	*(data) = i2c_res.Data; \
} while (0)

// multi byte write
#define capsam_i2c_write_data(instance, dev, addr, data, size) do { \
	RMstatus err; \
	struct I2C_WriteData_type i2c_write; \
	i2c_write.UseSubAddr = TRUE; \
	i2c_write.SubAddr = (addr); \
	i2c_write.DataSize = (size); \
	RMMemcpy(i2c_write.Data, (data), (size)); \
	capsam_i2c_open(instance, dev); \
	err = RUASetProperty((instance)->pRUA, (instance)->I2CModuleID, \
		RMI2CPropertyID_WriteData, \
		&i2c_write, sizeof(i2c_write), 0); \
	capsam_i2c_close(instance); \
	if (RMFAILED(err)) return err; \
} while (0)

// multi byte read
#define capsam_i2c_read_data(instance, dev, addr, data, size) do { \
	RMstatus err; \
	struct I2C_QueryData_in_type i2c_param; \
	struct I2C_QueryData_out_type i2c_res; \
	i2c_param.UseSubAddr = TRUE; \
	i2c_param.SubAddr = (addr); \
	i2c_param.DataSize = (size); \
	capsam_i2c_open(instance, dev); \
	err = RUAExchangeProperty((instance)->pRUA, (instance)->I2CModuleID, \
		RMI2CPropertyID_QueryData, \
		&i2c_param, sizeof(i2c_param), \
		&i2c_res, sizeof(i2c_res)); \
	capsam_i2c_close(instance); \
	if (RMFAILED(err)) return err; \
	RMMemcpy((data), i2c_res.Data, (size)); \
} while (0)

// multi byte write without sub address
#define capsam_i2c_write_nosub(instance, dev, data, size) do { \
	RMstatus err; \
	struct I2C_WriteData_type i2c_write; \
	i2c_write.UseSubAddr = FALSE; \
	i2c_write.SubAddr = 0; \
	i2c_write.DataSize = (size); \
	RMMemcpy(i2c_write.Data, (data), (size)); \
	capsam_i2c_open(instance, dev); \
	err = RUASetProperty((instance)->pRUA, (instance)->I2CModuleID, \
		RMI2CPropertyID_WriteData, \
		&i2c_write, sizeof(i2c_write), 0); \
	capsam_i2c_close(instance); \
	if (RMFAILED(err)) return err; \
} while (0)

// multi byte read without sub address
#define capsam_i2c_read_nosub(instance, dev, data, size) do { \
	RMstatus err; \
	struct I2C_QueryData_in_type i2c_param; \
	struct I2C_QueryData_out_type i2c_res; \
	i2c_param.UseSubAddr = FALSE; \
	i2c_param.SubAddr = 0; \
	i2c_param.DataSize = (size); \
	capsam_i2c_open(instance, dev); \
	err = RUAExchangeProperty((instance)->pRUA, (instance)->I2CModuleID, \
		RMI2CPropertyID_QueryData, \
		&i2c_param, sizeof(i2c_param), \
		&i2c_res, sizeof(i2c_res)); \
	capsam_i2c_close(instance); \
	if (RMFAILED(err)) return err; \
	RMMemcpy((data), i2c_res.Data, (size)); \
} while (0)

// write content of data[][2] to dev
#define capsam_i2c_init(instance, dev, data) do { \
	RMuint32 i; \
	capsam_i2c_open(instance, dev); \
	for (i = 0; i < sizeof(data) / sizeof((data)[0]); i++) { \
		capsam_i2c_write(instance, (data)[i][0], (data)[i][1]); \
	} \
	capsam_i2c_close(instance); \
} while (0)

// multi byte read and hex dump
#define capsam_i2c_dump(instance, dev, addr, size) do { \
	RMstatus err; \
	RMuint32 i; \
	struct I2C_QueryRMuint8_in_type i2c_param; \
	struct I2C_QueryRMuint8_out_type i2c_res; \
	capsam_i2c_open(instance, dev); \
	for (i = 0; i < (size); i++) { \
		i2c_param.SubAddr = (addr) + i; \
		err = RUAExchangeProperty((instance)->pRUA, (instance)->I2CModuleID, \
			RMI2CPropertyID_QueryRMuint8, \
			&i2c_param, sizeof(i2c_param), \
			&i2c_res, sizeof(i2c_res)); \
		if (i % 8 == 0) fprintf(stderr, " Data[%02lX:%02lX]: ", (dev), (addr) + i); \
		if (RMFAILED(err)) fprintf(stderr, "XX "); \
		else fprintf(stderr, "%02X ", i2c_res.Data); \
		if (i % 8 == 7) fprintf(stderr, "\n"); \
	} \
	if ((size) % 8 != 0) fprintf(stderr, "\n"); \
	capsam_i2c_close(instance); \
} while (0)


// these are temporary functions to minimize migration from play_capture.c

void set_i2c_module_id(RMuint32 i2c_module_id);

RMuint32 get_i2c_module_id(void);

RMstatus dump_i2c(struct RUA *pInstance, 
		  RMuint32 delay, 
		  RMuint32 dev, 
		  RMuint32 start, 
		  RMuint32 end);


RMstatus read_i2c_data(struct RUA *pInstance, 
		       RMuint8 delay, 
		       RMuint32 dev, 
		       RMuint32 addr, 
		       RMuint8 *data, 
		       RMuint32 data_size);


RMstatus read_i2c(struct RUA *pInstance, 
		  RMuint8 delay, 
		  RMuint32 dev, 
		  RMuint32 addr, 
		  RMuint32 *data);

RMstatus write_i2c(struct RUA *pInstance, 
		   RMuint8 delay, 
		   RMuint32 dev, 
		   RMuint32 addr, 
		   RMuint32 data);

/**
  @delay: uSec delay between bits in i2c
  @dev: raw i2c slave address, 0x00..0x7f
*/
RMstatus init_i2c(struct RUA *pInstance, 
		  RMuint8 delay, 
		  RMuint8 dev, 
		  RMuint8 i2c_data[][2], 
		  RMuint32 data_size);


RMstatus probe_i2c(struct RUA *pInstance, 
		   RMuint32 delay);

#endif // __PLAY_CAPTURE_I2C_H__