[deliverable/linux.git] / drivers / media / dvb-frontends / drx39xyj / drx39xxj_dummy.c

#include <linux/kernel.h>
#include <linux/init.h>
#include <linux/module.h>
#include <linux/string.h>
#include <linux/slab.h>
#include <linux/delay.h>
#include <linux/jiffies.h>
#include <linux/types.h>

#include "drx_driver.h"
#include "drx39xxj.h"

/* Dummy function to satisfy drxj.c */
DRXStatus_t DRXBSP_TUNER_Open(pTUNERInstance_t tuner)
{
	return DRX_STS_OK;
}

DRXStatus_t DRXBSP_TUNER_Close(pTUNERInstance_t tuner)
{
	return DRX_STS_OK;
}

DRXStatus_t DRXBSP_TUNER_SetFrequency(pTUNERInstance_t tuner,
				      TUNERMode_t mode,
				      s32 centerFrequency)
{
	return DRX_STS_OK;
}

DRXStatus_t
DRXBSP_TUNER_GetFrequency(pTUNERInstance_t tuner,
			  TUNERMode_t mode,
			  s32 *RFfrequency,
			  s32 *IFfrequency)
{
	return DRX_STS_OK;
}

DRXStatus_t DRXBSP_HST_Sleep(u32 n)
{
	msleep(n);
	return DRX_STS_OK;
}

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

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)
{
	return (memcpy(to, from, (size_t) n));
}

DRXStatus_t DRXBSP_I2C_WriteRead(struct i2c_device_addr *wDevAddr,
				 u16 wCount,
				 u8 *wData,
				 struct i2c_device_addr *rDevAddr,
				 u16 rCount, u8 *rData)
{
	struct drx39xxj_state *state;
	struct i2c_msg msg[2];
	unsigned int num_msgs;

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

	if (state->i2c == NULL) {
		printk("i2c was zero, aborting\n");
		return 0;
	}
	if (i2c_transfer(state->i2c, msg, num_msgs) != num_msgs) {
		printk(KERN_WARNING "drx3933: I2C write/read failed\n");
		return -EREMOTEIO;
	}

	return DRX_STS_OK;

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

	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},
	};

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

	if (i2c_transfer(state->i2c, msg, 2) != 2) {
		printk(KERN_WARNING "drx3933: I2C write/read failed\n");
		return -EREMOTEIO;
	}
#endif
	return 0;
}
Commit	Line	Data
38b2df95 DH	1	#include <linux/kernel.h>
	2	#include <linux/init.h>
	3	#include <linux/module.h>
	4	#include <linux/string.h>
	5	#include <linux/slab.h>
	6	#include <linux/delay.h>
	7	#include <linux/jiffies.h>
	8	#include <linux/types.h>
	9
	10	#include "drx_driver.h"
38b2df95 DH	11	#include "drx39xxj.h"
	12
	13	/* Dummy function to satisfy drxj.c */
443f18d0	14	DRXStatus_t DRXBSP_TUNER_Open(pTUNERInstance_t tuner)
38b2df95 DH	15	{
	16	return DRX_STS_OK;
	17	}
	18
443f18d0	19	DRXStatus_t DRXBSP_TUNER_Close(pTUNERInstance_t tuner)
38b2df95 DH	20	{
	21	return DRX_STS_OK;
	22	}
	23
443f18d0 MCC	24	DRXStatus_t DRXBSP_TUNER_SetFrequency(pTUNERInstance_t tuner,
443f18d0 MCC	25	TUNERMode_t mode,
73f7065b	26	s32 centerFrequency)
38b2df95 DH	27	{
	28	return DRX_STS_OK;
	29	}
	30
	31	DRXStatus_t
443f18d0 MCC	32	DRXBSP_TUNER_GetFrequency(pTUNERInstance_t tuner,
443f18d0 MCC	33	TUNERMode_t mode,
73f7065b MCC	34	s32 *RFfrequency,
73f7065b MCC	35	s32 *IFfrequency)
38b2df95 DH	36	{
	37	return DRX_STS_OK;
	38	}
	39
43a431e4	40	DRXStatus_t DRXBSP_HST_Sleep(u32 n)
38b2df95 DH	41	{
	42	msleep(n);
	43	return DRX_STS_OK;
	44	}
	45
43a431e4	46	u32 DRXBSP_HST_Clock(void)
38b2df95 DH	47	{
	48	return jiffies_to_msecs(jiffies);
	49	}
	50
43a431e4	51	int DRXBSP_HST_Memcmp(void s1, void s2, u32 n)
38b2df95	52	{
443f18d0	53	return (memcmp(s1, s2, (size_t) n));
38b2df95 DH	54	}
38b2df95 DH	55
43a431e4	56	void DRXBSP_HST_Memcpy(void to, void *from, u32 n)
38b2df95	57	{
443f18d0	58	return (memcpy(to, from, (size_t) n));
38b2df95 DH	59	}
38b2df95 DH	60
5b223b39	61	DRXStatus_t DRXBSP_I2C_WriteRead(struct i2c_device_addr *wDevAddr,
43a431e4 MCC	62	u16 wCount,
43a431e4 MCC	63	u8 *wData,
5b223b39	64	struct i2c_device_addr *rDevAddr,
43a431e4	65	u16 rCount, u8 *rData)
38b2df95 DH	66	{
	67	struct drx39xxj_state *state;
	68	struct i2c_msg msg[2];
	69	unsigned int num_msgs;
	70
	71	if (wDevAddr == NULL) {
	72	/* Read only */
	73	state = rDevAddr->userData;
	74	msg[0].addr = rDevAddr->i2cAddr >> 1;
	75	msg[0].flags = I2C_M_RD;
	76	msg[0].buf = rData;
	77	msg[0].len = rCount;
	78	num_msgs = 1;
	79	} else if (rDevAddr == NULL) {
	80	/* Write only */
	81	state = wDevAddr->userData;
	82	msg[0].addr = wDevAddr->i2cAddr >> 1;
	83	msg[0].flags = 0;
	84	msg[0].buf = wData;
	85	msg[0].len = wCount;
	86	num_msgs = 1;
	87	} else {
	88	/* Both write and read */
	89	state = wDevAddr->userData;
	90	msg[0].addr = wDevAddr->i2cAddr >> 1;
	91	msg[0].flags = 0;
	92	msg[0].buf = wData;
	93	msg[0].len = wCount;
	94	msg[1].addr = rDevAddr->i2cAddr >> 1;
	95	msg[1].flags = I2C_M_RD;
	96	msg[1].buf = rData;
	97	msg[1].len = rCount;
	98	num_msgs = 2;
	99	}
	100
	101	if (state->i2c == NULL) {
443f18d0 MCC	102	printk("i2c was zero, aborting\n");
443f18d0 MCC	103	return 0;
38b2df95 DH	104	}
	105	if (i2c_transfer(state->i2c, msg, num_msgs) != num_msgs) {
	106	printk(KERN_WARNING "drx3933: I2C write/read failed\n");
	107	return -EREMOTEIO;
	108	}
	109
	110	return DRX_STS_OK;
	111
	112	#ifdef DJH_DEBUG
	113	struct drx39xxj_state *state = wDevAddr->userData;
	114
	115	struct i2c_msg msg[2] = {
443f18d0 MCC	116	{.addr = wDevAddr->i2cAddr,
	117	.flags = 0,.buf = wData,.len = wCount},
	118	{.addr = rDevAddr->i2cAddr,
	119	.flags = I2C_M_RD,.buf = rData,.len = rCount},
38b2df95 DH	120	};
	121
	122	printk("drx3933 i2c operation addr=%x i2c=%p, wc=%x rc=%x\n",
	123	wDevAddr->i2cAddr, state->i2c, wCount, rCount);
	124
	125	if (i2c_transfer(state->i2c, msg, 2) != 2) {
	126	printk(KERN_WARNING "drx3933: I2C write/read failed\n");
	127	return -EREMOTEIO;
	128	}
	129	#endif
	130	return 0;
	131	}