[media] drx-j: Don't use CamelCase (57afe2f0) · Commits · github.com / kvm-riscv / linux

drivers/media/dvb-frontends/drx39xyj/bsp_i2c.h

+32 −32

Original line number	Diff line number	Diff line
		@@ -48,13 +48,13 @@
		#include "bsp_types.h"

		/*
		* This structure contains the I2C address, the device ID and a userData pointer.
		* The userData pointer can be used for application specific purposes.
		* This structure contains the I2C address, the device ID and a user_data pointer.
		* The user_data pointer can be used for application specific purposes.
		*/
		struct i2c_device_addr {
		u16 i2cAddr; /* The I2C address of the device. */
		u16 i2cDevId; /* The device identifier. */
		void userData; / User data pointer */
		u16 i2c_addr; /* The I2C address of the device. */
		u16 i2c_dev_id; /* The device identifier. */
		void user_data; / User data pointer */
		};


		@@ -74,44 +74,44 @@ Exported FUNCTIONS
		------------------------------------------------------------------------------*/

		/**
		* \fn DRXBSP_I2C_Init()
		* \fn drxbsp_i2c_init()
		* \brief Initialize I2C communication module.
		* \return DRXStatus_t Return status.
		* \return drx_status_t Return status.
		* \retval DRX_STS_OK Initialization successful.
		* \retval DRX_STS_ERROR Initialization failed.
		*/
		DRXStatus_t DRXBSP_I2C_Init(void);
		drx_status_t drxbsp_i2c_init(void);

		/**
		* \fn DRXBSP_I2C_Term()
		* \fn drxbsp_i2c_term()
		* \brief Terminate I2C communication module.
		* \return DRXStatus_t Return status.
		* \return drx_status_t Return status.
		* \retval DRX_STS_OK Termination successful.
		* \retval DRX_STS_ERROR Termination failed.
		*/
		DRXStatus_t DRXBSP_I2C_Term(void);
		drx_status_t drxbsp_i2c_term(void);

		/**
		* \fn DRXStatus_t DRXBSP_I2C_WriteRead( struct i2c_device_addr *wDevAddr,
		* u16 wCount,
		* \fn drx_status_t drxbsp_i2c_write_read( struct i2c_device_addr *w_dev_addr,
		* u16 w_count,
		* u8 *wData,
		* struct i2c_device_addr *rDevAddr,
		* u16 rCount,
		* u8 *rData)
		* struct i2c_device_addr *r_dev_addr,
		* u16 r_count,
		* u8 *r_data)
		* \brief Read and/or write count bytes from I2C bus, store them in data[].
		* \param wDevAddr The device i2c address and the device ID to write to
		* \param wCount The number of bytes to write
		* \param w_dev_addr The device i2c address and the device ID to write to
		* \param w_count The number of bytes to write
		* \param wData The array to write the data to
		* \param rDevAddr The device i2c address and the device ID to read from
		* \param rCount The number of bytes to read
		* \param rData The array to read the data from
		* \return DRXStatus_t Return status.
		* \param r_dev_addr The device i2c address and the device ID to read from
		* \param r_count The number of bytes to read
		* \param r_data The array to read the data from
		* \return drx_status_t Return status.
		* \retval DRX_STS_OK Succes.
		* \retval DRX_STS_ERROR Failure.
		* \retval DRX_STS_INVALID_ARG Parameter 'wcount' is not zero but parameter
		* 'wdata' contains NULL.
		* Idem for 'rcount' and 'rdata'.
		* Both wDevAddr and rDevAddr are NULL.
		* Both w_dev_addr and r_dev_addr are NULL.
		*
		* This function must implement an atomic write and/or read action on the I2C bus
		* No other process may use the I2C bus when this function is executing.
		@@ -121,25 +121,25 @@ Exported FUNCTIONS
		* The device ID can be useful if several devices share an I2C address.
		* It can be used to control a "switch" on the I2C bus to the correct device.
		*/
		DRXStatus_t DRXBSP_I2C_WriteRead(struct i2c_device_addr *wDevAddr,
		u16 wCount,
		drx_status_t drxbsp_i2c_write_read(struct i2c_device_addr *w_dev_addr,
		u16 w_count,
		u8 *wData,
		struct i2c_device_addr *rDevAddr,
		u16 rCount, u8 *rData);
		struct i2c_device_addr *r_dev_addr,
		u16 r_count, u8 *r_data);

		/**
		* \fn DRXBSP_I2C_ErrorText()
		* \fn drxbsp_i2c_error_text()
		* \brief Returns a human readable error.
		* Counter part of numerical DRX_I2C_Error_g.
		* Counter part of numerical drx_i2c_error_g.
		*
		* \return char* Pointer to human readable error text.
		*/
		char *DRXBSP_I2C_ErrorText(void);
		char *drxbsp_i2c_error_text(void);

		/**
		* \var DRX_I2C_Error_g;
		* \var drx_i2c_error_g;
		* \brief I2C specific error codes, platform dependent.
		*/
		extern int DRX_I2C_Error_g;
		extern int drx_i2c_error_g;

		#endif /* __BSPI2C_H__ */

drivers/media/dvb-frontends/drx39xyj/bsp_tuner.h

+61 −61

Original line number	Diff line number	Diff line
		@@ -79,90 +79,90 @@ DEFINES
		TYPEDEFS
		------------------------------------------------------------------------------*/

		typedef u32 TUNERMode_t;
		typedef u32 *pTUNERMode_t;
		typedef u32 tuner_mode_t;
		typedef u32 *ptuner_mode_t;

		typedef char TUNERSubMode_t; / description of submode */
		typedef TUNERSubMode_t *pTUNERSubMode_t;
		typedef char tuner_sub_mode_t; / description of submode */
		typedef tuner_sub_mode_t *ptuner_sub_mode_t;

		typedef enum {

		TUNER_LOCKED,
		TUNER_NOT_LOCKED
		} TUNERLockStatus_t, *pTUNERLockStatus_t;
		} tuner_lock_status_t, *ptuner_lock_status_t;

		typedef struct {

		char name; / Tuner brand & type name */
		s32 minFreqRF; /* Lowest RF input frequency, in kHz */
		s32 maxFreqRF; /* Highest RF input frequency, in kHz */
		s32 min_freq_rf; /* Lowest RF input frequency, in kHz */
		s32 max_freq_rf; /* Highest RF input frequency, in kHz */

		u8 subMode; /* Index to sub-mode in use */
		pTUNERSubMode_t subModeDescriptions; /* Pointer to description of sub-modes */
		u8 subModes; /* Number of available sub-modes */
		u8 sub_mode; /* Index to sub-mode in use */
		ptuner_sub_mode_t sub_modeDescriptions; /* Pointer to description of sub-modes */
		u8 sub_modes; /* Number of available sub-modes */

		/* The following fields will be either 0, NULL or false and do not need
		initialisation */
		void selfCheck; / gives proof of initialization */
		bool programmed; /* only valid if selfCheck is OK */
		s32 RFfrequency; /* only valid if programmed */
		s32 IFfrequency; /* only valid if programmed */
		void self_check; / gives proof of initialization */
		bool programmed; /* only valid if self_check is OK */
		s32 r_ffrequency; /* only valid if programmed */
		s32 i_ffrequency; /* only valid if programmed */

		void myUserData; / pointer to associated demod instance */
		u16 myCapabilities; /* value for storing application flags */
		void myUser_data; / pointer to associated demod instance */
		u16 my_capabilities; /* value for storing application flags */

		} TUNERCommonAttr_t, *pTUNERCommonAttr_t;
		} tuner_common_attr_t, *ptuner_common_attr_t;

		/*
		* Generic functions for DRX devices.
		*/
		typedef struct TUNERInstance_s *pTUNERInstance_t;
		typedef struct tuner_instance_s *p_tuner_instance_t;

		typedef DRXStatus_t(*TUNEROpenFunc_t) (pTUNERInstance_t tuner);
		typedef DRXStatus_t(*TUNERCloseFunc_t) (pTUNERInstance_t tuner);
		typedef drx_status_t(*tuner_open_func_t) (p_tuner_instance_t tuner);
		typedef drx_status_t(*tuner_close_func_t) (p_tuner_instance_t tuner);

		typedef DRXStatus_t(*TUNERSetFrequencyFunc_t) (pTUNERInstance_t tuner,
		TUNERMode_t mode,
		typedef drx_status_t(*tuner_set_frequency_func_t) (p_tuner_instance_t tuner,
		tuner_mode_t mode,
		s32
		frequency);

		typedef DRXStatus_t(*TUNERGetFrequencyFunc_t) (pTUNERInstance_t tuner,
		TUNERMode_t mode,
		typedef drx_status_t(*tuner_get_frequency_func_t) (p_tuner_instance_t tuner,
		tuner_mode_t mode,
		s32 *
		RFfrequency,
		r_ffrequency,
		s32 *
		IFfrequency);
		i_ffrequency);

		typedef DRXStatus_t(*TUNERLockStatusFunc_t) (pTUNERInstance_t tuner,
		pTUNERLockStatus_t
		lockStat);
		typedef drx_status_t(*tuner_lock_status_func_t) (p_tuner_instance_t tuner,
		ptuner_lock_status_t
		lock_stat);

		typedef DRXStatus_t(*TUNERi2cWriteReadFunc_t) (pTUNERInstance_t tuner,
		typedef drx_status_t(*tune_ri2c_write_read_func_t) (p_tuner_instance_t tuner,
		struct i2c_device_addr *
		wDevAddr, u16 wCount,
		w_dev_addr, u16 w_count,
		u8 *wData,
		struct i2c_device_addr *
		rDevAddr, u16 rCount,
		u8 *rData);
		r_dev_addr, u16 r_count,
		u8 *r_data);

		typedef struct {
		TUNEROpenFunc_t openFunc;
		TUNERCloseFunc_t closeFunc;
		TUNERSetFrequencyFunc_t setFrequencyFunc;
		TUNERGetFrequencyFunc_t getFrequencyFunc;
		TUNERLockStatusFunc_t lockStatusFunc;
		TUNERi2cWriteReadFunc_t i2cWriteReadFunc;
		tuner_open_func_t open_func;
		tuner_close_func_t close_func;
		tuner_set_frequency_func_t set_frequency_func;
		tuner_get_frequency_func_t get_frequency_func;
		tuner_lock_status_func_t lock_statusFunc;
		tune_ri2c_write_read_func_t i2c_write_read_func;

		} TUNERFunc_t, *pTUNERFunc_t;
		} tuner_func_t, *ptuner_func_t;

		typedef struct TUNERInstance_s {
		typedef struct tuner_instance_s {

		struct i2c_device_addr myI2CDevAddr;
		pTUNERCommonAttr_t myCommonAttr;
		void *myExtAttr;
		pTUNERFunc_t myFunct;
		struct i2c_device_addr my_i2c_dev_addr;
		ptuner_common_attr_t my_common_attr;
		void *my_ext_attr;
		ptuner_func_t my_funct;

		} TUNERInstance_t;
		} tuner_instance_t;

		/*------------------------------------------------------------------------------
		ENUM
		@@ -176,28 +176,28 @@ STRUCTS
		Exported FUNCTIONS
		------------------------------------------------------------------------------*/

		DRXStatus_t DRXBSP_TUNER_Open(pTUNERInstance_t tuner);
		drx_status_t drxbsp_tuner_open(p_tuner_instance_t tuner);

		DRXStatus_t DRXBSP_TUNER_Close(pTUNERInstance_t tuner);
		drx_status_t drxbsp_tuner_close(p_tuner_instance_t tuner);

		DRXStatus_t DRXBSP_TUNER_SetFrequency(pTUNERInstance_t tuner,
		TUNERMode_t mode,
		drx_status_t drxbsp_tuner_set_frequency(p_tuner_instance_t tuner,
		tuner_mode_t mode,
		s32 frequency);

		DRXStatus_t DRXBSP_TUNER_GetFrequency(pTUNERInstance_t tuner,
		TUNERMode_t mode,
		s32 *RFfrequency,
		s32 *IFfrequency);
		drx_status_t drxbsp_tuner_get_frequency(p_tuner_instance_t tuner,
		tuner_mode_t mode,
		s32 *r_ffrequency,
		s32 *i_ffrequency);

		DRXStatus_t DRXBSP_TUNER_LockStatus(pTUNERInstance_t tuner,
		pTUNERLockStatus_t lockStat);
		drx_status_t drxbsp_tuner_lock_status(p_tuner_instance_t tuner,
		ptuner_lock_status_t lock_stat);

		DRXStatus_t DRXBSP_TUNER_DefaultI2CWriteRead(pTUNERInstance_t tuner,
		struct i2c_device_addr *wDevAddr,
		u16 wCount,
		drx_status_t drxbsp_tuner_default_i2c_write_read(p_tuner_instance_t tuner,
		struct i2c_device_addr *w_dev_addr,
		u16 w_count,
		u8 *wData,
		struct i2c_device_addr *rDevAddr,
		u16 rCount, u8 *rData);
		struct i2c_device_addr *r_dev_addr,
		u16 r_count, u8 *r_data);

		/*------------------------------------------------------------------------------
		THE END

drivers/media/dvb-frontends/drx39xyj/drx39xxj.c

+69 −69

Original line number	Diff line number	Diff line
		@@ -33,16 +33,16 @@
		static int drx39xxj_set_powerstate(struct dvb_frontend *fe, int enable)
		{
		struct drx39xxj_state *state = fe->demodulator_priv;
		DRXDemodInstance_t *demod = state->demod;
		drx_demod_instance_t *demod = state->demod;
		int result;
		DRXPowerMode_t powerMode;
		drx_power_mode_t power_mode;

		if (enable)
		powerMode = DRX_POWER_UP;
		power_mode = DRX_POWER_UP;
		else
		powerMode = DRX_POWER_DOWN;
		power_mode = DRX_POWER_DOWN;

		result = DRX_Ctrl(demod, DRX_CTRL_POWER_MODE, &powerMode);
		result = drx_ctrl(demod, DRX_CTRL_POWER_MODE, &power_mode);
		if (result != DRX_STS_OK) {
		printk(KERN_ERR "Power state change failed\n");
		return 0;
		@@ -55,13 +55,13 @@ static int drx39xxj_set_powerstate(struct dvb_frontend *fe, int enable)
		static int drx39xxj_read_status(struct dvb_frontend fe, fe_status_t status)
		{
		struct drx39xxj_state *state = fe->demodulator_priv;
		DRXDemodInstance_t *demod = state->demod;
		drx_demod_instance_t *demod = state->demod;
		int result;
		DRXLockStatus_t lock_status;
		drx_lock_status_t lock_status;

		*status = 0;

		result = DRX_Ctrl(demod, DRX_CTRL_LOCK_STATUS, &lock_status);
		result = drx_ctrl(demod, DRX_CTRL_LOCK_STATUS, &lock_status);
		if (result != DRX_STS_OK) {
		printk(KERN_ERR "drx39xxj: could not get lock status!\n");
		*status = 0;
		@@ -102,18 +102,18 @@ static int drx39xxj_read_status(struct dvb_frontend fe, fe_status_t status)
		static int drx39xxj_read_ber(struct dvb_frontend fe, u32 ber)
		{
		struct drx39xxj_state *state = fe->demodulator_priv;
		DRXDemodInstance_t *demod = state->demod;
		drx_demod_instance_t *demod = state->demod;
		int result;
		DRXSigQuality_t sig_quality;
		drx_sig_quality_t sig_quality;

		result = DRX_Ctrl(demod, DRX_CTRL_SIG_QUALITY, &sig_quality);
		result = drx_ctrl(demod, DRX_CTRL_SIG_QUALITY, &sig_quality);
		if (result != DRX_STS_OK) {
		printk(KERN_ERR "drx39xxj: could not get ber!\n");
		*ber = 0;
		return 0;
		}

		*ber = sig_quality.postReedSolomonBER;
		*ber = sig_quality.post_reed_solomon_ber;
		return 0;
		}

		@@ -121,11 +121,11 @@ static int drx39xxj_read_signal_strength(struct dvb_frontend *fe,
		u16 *strength)
		{
		struct drx39xxj_state *state = fe->demodulator_priv;
		DRXDemodInstance_t *demod = state->demod;
		drx_demod_instance_t *demod = state->demod;
		int result;
		DRXSigQuality_t sig_quality;
		drx_sig_quality_t sig_quality;

		result = DRX_Ctrl(demod, DRX_CTRL_SIG_QUALITY, &sig_quality);
		result = drx_ctrl(demod, DRX_CTRL_SIG_QUALITY, &sig_quality);
		if (result != DRX_STS_OK) {
		printk(KERN_ERR "drx39xxj: could not get signal strength!\n");
		*strength = 0;
		@@ -140,11 +140,11 @@ static int drx39xxj_read_signal_strength(struct dvb_frontend *fe,
		static int drx39xxj_read_snr(struct dvb_frontend fe, u16 snr)
		{
		struct drx39xxj_state *state = fe->demodulator_priv;
		DRXDemodInstance_t *demod = state->demod;
		drx_demod_instance_t *demod = state->demod;
		int result;
		DRXSigQuality_t sig_quality;
		drx_sig_quality_t sig_quality;

		result = DRX_Ctrl(demod, DRX_CTRL_SIG_QUALITY, &sig_quality);
		result = drx_ctrl(demod, DRX_CTRL_SIG_QUALITY, &sig_quality);
		if (result != DRX_STS_OK) {
		printk(KERN_ERR "drx39xxj: could not read snr!\n");
		*snr = 0;
		@@ -158,18 +158,18 @@ static int drx39xxj_read_snr(struct dvb_frontend fe, u16 snr)
		static int drx39xxj_read_ucblocks(struct dvb_frontend fe, u32 ucblocks)
		{
		struct drx39xxj_state *state = fe->demodulator_priv;
		DRXDemodInstance_t *demod = state->demod;
		drx_demod_instance_t *demod = state->demod;
		int result;
		DRXSigQuality_t sig_quality;
		drx_sig_quality_t sig_quality;

		result = DRX_Ctrl(demod, DRX_CTRL_SIG_QUALITY, &sig_quality);
		result = drx_ctrl(demod, DRX_CTRL_SIG_QUALITY, &sig_quality);
		if (result != DRX_STS_OK) {
		printk(KERN_ERR "drx39xxj: could not get uc blocks!\n");
		*ucblocks = 0;
		return 0;
		}

		*ucblocks = sig_quality.packetError;
		*ucblocks = sig_quality.packet_error;
		return 0;
		}

		@@ -180,12 +180,12 @@ static int drx39xxj_set_frontend(struct dvb_frontend *fe)
		#endif
		struct dtv_frontend_properties *p = &fe->dtv_property_cache;
		struct drx39xxj_state *state = fe->demodulator_priv;
		DRXDemodInstance_t *demod = state->demod;
		drx_demod_instance_t *demod = state->demod;
		enum drx_standard standard = DRX_STANDARD_8VSB;
		DRXChannel_t channel;
		drx_channel_t channel;
		int result;
		DRXUIOData_t uioData;
		DRXChannel_t defChannel = { /* frequency */ 0,
		drxuio_data_t uio_data;
		drx_channel_t def_channel = { /* frequency */ 0,
		/* bandwidth */ DRX_BANDWIDTH_6MHZ,
		/* mirror */ DRX_MIRROR_NO,
		/* constellation */ DRX_CONSTELLATION_AUTO,
		@@ -216,7 +216,7 @@ static int drx39xxj_set_frontend(struct dvb_frontend *fe)

		if (standard != state->current_standard \|\| state->powered_up == 0) {
		/* Set the standard (will be powered up if necessary */
		result = DRX_Ctrl(demod, DRX_CTRL_SET_STANDARD, &standard);
		result = drx_ctrl(demod, DRX_CTRL_SET_STANDARD, &standard);
		if (result != DRX_STS_OK) {
		printk(KERN_ERR "Failed to set standard! result=%02x\n",
		result);
		@@ -227,21 +227,21 @@ static int drx39xxj_set_frontend(struct dvb_frontend *fe)
		}

		/* set channel parameters */
		channel = defChannel;
		channel = def_channel;
		channel.frequency = p->frequency / 1000;
		channel.bandwidth = DRX_BANDWIDTH_6MHZ;
		channel.constellation = DRX_CONSTELLATION_AUTO;

		/* program channel */
		result = DRX_Ctrl(demod, DRX_CTRL_SET_CHANNEL, &channel);
		result = drx_ctrl(demod, DRX_CTRL_SET_CHANNEL, &channel);
		if (result != DRX_STS_OK) {
		printk(KERN_ERR "Failed to set channel!\n");
		return -EINVAL;
		}
		/* Just for giggles, let's shut off the LNA again.... */
		uioData.uio = DRX_UIO1;
		uioData.value = false;
		result = DRX_Ctrl(demod, DRX_CTRL_UIO_WRITE, &uioData);
		uio_data.uio = DRX_UIO1;
		uio_data.value = false;
		result = drx_ctrl(demod, DRX_CTRL_UIO_WRITE, &uio_data);
		if (result != DRX_STS_OK) {
		printk(KERN_ERR "Failed to disable LNA!\n");
		return 0;
		@@ -268,7 +268,7 @@ static int drx39xxj_sleep(struct dvb_frontend *fe)
		static int drx39xxj_i2c_gate_ctrl(struct dvb_frontend *fe, int enable)
		{
		struct drx39xxj_state *state = fe->demodulator_priv;
		DRXDemodInstance_t *demod = state->demod;
		drx_demod_instance_t *demod = state->demod;
		bool i2c_gate_state;
		int result;

		@@ -287,7 +287,7 @@ static int drx39xxj_i2c_gate_ctrl(struct dvb_frontend *fe, int enable)
		return 0;
		}

		result = DRX_Ctrl(demod, DRX_CTRL_I2C_BRIDGE, &i2c_gate_state);
		result = drx_ctrl(demod, DRX_CTRL_I2C_BRIDGE, &i2c_gate_state);
		if (result != DRX_STS_OK) {
		printk(KERN_ERR "drx39xxj: could not open i2c gate [%d]\n",
		result);
		@@ -325,12 +325,12 @@ struct dvb_frontend drx39xxj_attach(struct i2c_adapter i2c)
		{
		struct drx39xxj_state *state = NULL;

		struct i2c_device_addr *demodAddr = NULL;
		DRXCommonAttr_t *demodCommAttr = NULL;
		DRXJData_t *demodExtAttr = NULL;
		DRXDemodInstance_t *demod = NULL;
		DRXUIOCfg_t uioCfg;
		DRXUIOData_t uioData;
		struct i2c_device_addr *demod_addr = NULL;
		drx_common_attr_t *demod_comm_attr = NULL;
		drxj_data_t *demod_ext_attr = NULL;
		drx_demod_instance_t *demod = NULL;
		drxuio_cfg_t uio_cfg;
		drxuio_data_t uio_data;
		int result;

		/* allocate memory for the internal state */
		@@ -338,50 +338,50 @@ struct dvb_frontend drx39xxj_attach(struct i2c_adapter i2c)
		if (state == NULL)
		goto error;

		demod = kmalloc(sizeof(DRXDemodInstance_t), GFP_KERNEL);
		demod = kmalloc(sizeof(drx_demod_instance_t), GFP_KERNEL);
		if (demod == NULL)
		goto error;

		demodAddr = kmalloc(sizeof(struct i2c_device_addr), GFP_KERNEL);
		if (demodAddr == NULL)
		demod_addr = kmalloc(sizeof(struct i2c_device_addr), GFP_KERNEL);
		if (demod_addr == NULL)
		goto error;

		demodCommAttr = kmalloc(sizeof(DRXCommonAttr_t), GFP_KERNEL);
		if (demodCommAttr == NULL)
		demod_comm_attr = kmalloc(sizeof(drx_common_attr_t), GFP_KERNEL);
		if (demod_comm_attr == NULL)
		goto error;

		demodExtAttr = kmalloc(sizeof(DRXJData_t), GFP_KERNEL);
		if (demodExtAttr == NULL)
		demod_ext_attr = kmalloc(sizeof(drxj_data_t), GFP_KERNEL);
		if (demod_ext_attr == NULL)
		goto error;

		/* setup the state */
		state->i2c = i2c;
		state->demod = demod;

		memcpy(demod, &DRXJDefaultDemod_g, sizeof(DRXDemodInstance_t));
		memcpy(demod, &drxj_default_demod_g, sizeof(drx_demod_instance_t));

		demod->myI2CDevAddr = demodAddr;
		memcpy(demod->myI2CDevAddr, &DRXJDefaultAddr_g,
		demod->my_i2c_dev_addr = demod_addr;
		memcpy(demod->my_i2c_dev_addr, &drxj_default_addr_g,
		sizeof(struct i2c_device_addr));
		demod->myI2CDevAddr->userData = state;
		demod->myCommonAttr = demodCommAttr;
		memcpy(demod->myCommonAttr, &DRXJDefaultCommAttr_g,
		sizeof(DRXCommonAttr_t));
		demod->myCommonAttr->microcode = DRXJ_MC_MAIN;
		demod->my_i2c_dev_addr->user_data = state;
		demod->my_common_attr = demod_comm_attr;
		memcpy(demod->my_common_attr, &drxj_default_comm_attr_g,
		sizeof(drx_common_attr_t));
		demod->my_common_attr->microcode = DRXJ_MC_MAIN;
		#if 0
		demod->myCommonAttr->verifyMicrocode = false;
		demod->my_common_attr->verify_microcode = false;
		#endif
		demod->myCommonAttr->verifyMicrocode = true;
		demod->myCommonAttr->intermediateFreq = 5000;
		demod->my_common_attr->verify_microcode = true;
		demod->my_common_attr->intermediate_freq = 5000;

		demod->myExtAttr = demodExtAttr;
		memcpy(demod->myExtAttr, &DRXJData_g, sizeof(DRXJData_t));
		((DRXJData_t *) demod->myExtAttr)->uioSmaTxMode =
		demod->my_ext_attr = demod_ext_attr;
		memcpy(demod->my_ext_attr, &drxj_data_g, sizeof(drxj_data_t));
		((drxj_data_t *) demod->my_ext_attr)->uio_sma_tx_mode =
		DRX_UIO_MODE_READWRITE;

		demod->myTuner = NULL;
		demod->my_tuner = NULL;

		result = DRX_Open(demod);
		result = drx_open(demod);
		if (result != DRX_STS_OK) {
		printk(KERN_ERR "DRX open failed! Aborting\n");
		kfree(state);
		@@ -389,18 +389,18 @@ struct dvb_frontend drx39xxj_attach(struct i2c_adapter i2c)
		}

		/* Turn off the LNA */
		uioCfg.uio = DRX_UIO1;
		uioCfg.mode = DRX_UIO_MODE_READWRITE;
		uio_cfg.uio = DRX_UIO1;
		uio_cfg.mode = DRX_UIO_MODE_READWRITE;
		/* Configure user-I/O #3: enable read/write */
		result = DRX_Ctrl(demod, DRX_CTRL_UIO_CFG, &uioCfg);
		result = drx_ctrl(demod, DRX_CTRL_UIO_CFG, &uio_cfg);
		if (result != DRX_STS_OK) {
		printk(KERN_ERR "Failed to setup LNA GPIO!\n");
		return NULL;
		}

		uioData.uio = DRX_UIO1;
		uioData.value = false;
		result = DRX_Ctrl(demod, DRX_CTRL_UIO_WRITE, &uioData);
		uio_data.uio = DRX_UIO1;
		uio_data.value = false;
		result = drx_ctrl(demod, DRX_CTRL_UIO_WRITE, &uio_data);
		if (result != DRX_STS_OK) {
		printk(KERN_ERR "Failed to disable LNA!\n");
		return NULL;

drivers/media/dvb-frontends/drx39xyj/drx39xxj.h

+1 −1

Original line number	Diff line number	Diff line
		@@ -28,7 +28,7 @@

		struct drx39xxj_state {
		struct i2c_adapter *i2c;
		DRXDemodInstance_t *demod;
		drx_demod_instance_t *demod;
		enum drx_standard current_standard;
		struct dvb_frontend frontend;
		int powered_up:1;

drivers/media/dvb-frontends/drx39xyj/drx39xxj_dummy.c

+36 −36

Original line number	Diff line number	Diff line
		@@ -11,90 +11,90 @@
		#include "drx39xxj.h"

		/* Dummy function to satisfy drxj.c */
		int DRXBSP_TUNER_Open(struct tuner_instance *tuner)
		int drxbsp_tuner_open(struct tuner_instance *tuner)
		{
		return DRX_STS_OK;
		}

		int DRXBSP_TUNER_Close(struct tuner_instance *tuner)
		int drxbsp_tuner_close(struct tuner_instance *tuner)
		{
		return DRX_STS_OK;
		}

		int DRXBSP_TUNER_SetFrequency(struct tuner_instance *tuner,
		int drxbsp_tuner_set_frequency(struct tuner_instance *tuner,
		u32 mode,
		s32 centerFrequency)
		s32 center_frequency)
		{
		return DRX_STS_OK;
		}

		int
		DRXBSP_TUNER_GetFrequency(struct tuner_instance *tuner,
		drxbsp_tuner_get_frequency(struct tuner_instance *tuner,
		u32 mode,
		s32 *RFfrequency,
		s32 *IFfrequency)
		s32 *r_ffrequency,
		s32 *i_ffrequency)
		{
		return DRX_STS_OK;
		}

		int DRXBSP_HST_Sleep(u32 n)
		int drxbsp_hst_sleep(u32 n)
		{
		msleep(n);
		return DRX_STS_OK;
		}

		u32 DRXBSP_HST_Clock(void)
		u32 drxbsp_hst_clock(void)
		{
		return jiffies_to_msecs(jiffies);
		}

		int DRXBSP_HST_Memcmp(void s1, void s2, u32 n)
		int drxbsp_hst_memcmp(void s1, void s2, u32 n)
		{
		return (memcmp(s1, s2, (size_t) n));
		}

		void DRXBSP_HST_Memcpy(void to, void *from, u32 n)
		void drxbsp_hst_memcpy(void to, void *from, u32 n)
		{
		return (memcpy(to, from, (size_t) n));
		}

		int DRXBSP_I2C_WriteRead(struct i2c_device_addr *wDevAddr,
		u16 wCount,
		int drxbsp_i2c_write_read(struct i2c_device_addr *w_dev_addr,
		u16 w_count,
		u8 *wData,
		struct i2c_device_addr *rDevAddr,
		u16 rCount, u8 *rData)
		struct i2c_device_addr *r_dev_addr,
		u16 r_count, u8 *r_data)
		{
		struct drx39xxj_state *state;
		struct i2c_msg msg[2];
		unsigned int num_msgs;

		if (wDevAddr == NULL) {
		if (w_dev_addr == NULL) {
		/* Read only */
		state = rDevAddr->userData;
		msg[0].addr = rDevAddr->i2cAddr >> 1;
		state = r_dev_addr->user_data;
		msg[0].addr = r_dev_addr->i2c_addr >> 1;
		msg[0].flags = I2C_M_RD;
		msg[0].buf = rData;
		msg[0].len = rCount;
		msg[0].buf = r_data;
		msg[0].len = r_count;
		num_msgs = 1;
		} else if (rDevAddr == NULL) {
		} else if (r_dev_addr == NULL) {
		/* Write only */
		state = wDevAddr->userData;
		msg[0].addr = wDevAddr->i2cAddr >> 1;
		state = w_dev_addr->user_data;
		msg[0].addr = w_dev_addr->i2c_addr >> 1;
		msg[0].flags = 0;
		msg[0].buf = wData;
		msg[0].len = wCount;
		msg[0].len = w_count;
		num_msgs = 1;
		} else {
		/* Both write and read */
		state = wDevAddr->userData;
		msg[0].addr = wDevAddr->i2cAddr >> 1;
		state = w_dev_addr->user_data;
		msg[0].addr = w_dev_addr->i2c_addr >> 1;
		msg[0].flags = 0;
		msg[0].buf = wData;
		msg[0].len = wCount;
		msg[1].addr = rDevAddr->i2cAddr >> 1;
		msg[0].len = w_count;
		msg[1].addr = r_dev_addr->i2c_addr >> 1;
		msg[1].flags = I2C_M_RD;
		msg[1].buf = rData;
		msg[1].len = rCount;
		msg[1].buf = r_data;
		msg[1].len = r_count;
		num_msgs = 2;
		}

		@@ -110,17 +110,17 @@ int DRXBSP_I2C_WriteRead(struct i2c_device_addr *wDevAddr,
		return DRX_STS_OK;

		#ifdef DJH_DEBUG
		struct drx39xxj_state *state = wDevAddr->userData;
		struct drx39xxj_state *state = w_dev_addr->user_data;

		struct i2c_msg msg[2] = {
		{.addr = wDevAddr->i2cAddr,
		.flags = 0, .buf = wData, .len = wCount},
		{.addr = rDevAddr->i2cAddr,
		.flags = I2C_M_RD, .buf = rData, .len = rCount},
		{.addr = w_dev_addr->i2c_addr,
		.flags = 0, .buf = wData, .len = w_count},
		{.addr = r_dev_addr->i2c_addr,
		.flags = I2C_M_RD, .buf = r_data, .len = r_count},
		};

		printk("drx3933 i2c operation addr=%x i2c=%p, wc=%x rc=%x\n",
		wDevAddr->i2cAddr, state->i2c, wCount, rCount);
		w_dev_addr->i2c_addr, state->i2c, w_count, r_count);

		if (i2c_transfer(state->i2c, msg, 2) != 2) {
		printk(KERN_WARNING "drx3933: I2C write/read failed\n");