int ths8200_is_present(void)
{
__u8 data;
int err;
data = 0x02;
err = davinci_i2c_write(1, &data, THS8200_I2C_ADDR);
if ( err != 0)
{
return 0;
}
err = davinci_i2c_read(1, &data, THS8200_I2C_ADDR);
if ( err != 0)
{
return 0;
}
if (data != 4) // Value read by Neal
{
return 0;
}
// Everthing check out, return 1 (TRUE)
return 1;
}
static int evm_read_time(struct device *dev, struct rtc_time *tm)
{
char rtcdata [9];
rtcdata[0] = 2;
rtcdata[1] = 1;
davinci_i2c_write(2, rtcdata, 0x23);
msleep(1);
davinci_i2c_read(9, rtcdata, 0x23);
msleep(1);
/* FIXME the RTC reports 12-hour time, without an AM/PM indicator,
* but Linux requires that we report 24 hour time...
*/
tm->tm_year = BCD_TO_BIN(rtcdata[3]) * 100
+ BCD_TO_BIN(rtcdata[2])
- 1900;
tm->tm_mon = BCD_TO_BIN(rtcdata[4]);
tm->tm_mday = BCD_TO_BIN(rtcdata[5]);
tm->tm_hour = BCD_TO_BIN(rtcdata[6]);
tm->tm_min = BCD_TO_BIN(rtcdata[7]);
tm->tm_sec = BCD_TO_BIN(rtcdata[8]);
return 0;
}
static int davinci_i2c_attach_adapter(struct i2c_adapter *adapter)
{
struct i2c_client *client = &davinci_i2c_client;
int err;
if (client->adapter != NULL)
return -EBUSY; /* our client is already attached */
client->adapter = adapter;
#ifdef CONFIG_DAVINCI_I2C_EXPANDER
/*
* We may have the I2C expander support enabled without actual
* expander present on the board...
*/
if (davinci_i2c_expander.name == NULL)
return -ENODEV;
client->addr = davinci_i2c_expander.address;
strlcpy(client->name, davinci_i2c_expander.name, I2C_NAME_SIZE);
err = i2c_attach_client(client);
if (err) {
client->adapter = NULL;
return err;
}
davinci_i2c_write(1, &davinci_i2c_expander.init_data,
davinci_i2c_expander.address);
if (davinci_i2c_expander.setup != NULL)
davinci_i2c_expander.setup();
#endif
return 0;
}
static int __init cpld_init(void) {
int err = 0;
/* power up tvp5147 and tvp7002 */
u8 val=0x0;
err = davinci_i2c_write(1, &val, CPLD_VIDEO_REG);
if (!err) {
cpld_initialized = 1;
}
return err;
}
int set_cpld_for_tvp7002() {
int err = 0;
u8 val;
err = davinci_i2c_read(1, &val, CPLD_VIDEO_REG);
if(err)
return err;
val |= 0x10;
err = davinci_i2c_write(1, &val, CPLD_VIDEO_REG);
return err;
}
int set_cpld_for_tvp5147() {
int err = 0;
u8 val;
err = davinci_i2c_read(1, &val, CPLD_VIDEO_REG);
if(err)
return err;
val &= 0xEF;
err = davinci_i2c_write(1, &val, CPLD_VIDEO_REG);
return err;
}
static int write (int i2cfd, char * buf, int len)
{
if (len > 2)
{
printf("ERROR: trying to write more than one register is not supported\n");
return 2;
}
return davinci_i2c_write(len, buf, THS8200_I2C_ADDR);
}
int dm644x_mmc_get_ro(int index)
{
char input_state[4] = { 2, 4, 0, 0 };
davinci_i2c_write(2, input_state, 0x23);
udelay(1000);
davinci_i2c_read(4, input_state, 0x23);
udelay(1000);
return input_state[3] & 0x40;
}
/* following function is used to set THS7353 */
static int ths7353_setvalue(void)
{
int err = 0;
u8 val[2];
u16 ths7353_i2c_addr = 0x5C >> 1;
val[1] = 0x95;
val[0] = 0x01;
val[1] = 0x94;
err = davinci_i2c_write(2, val, ths7353_i2c_addr);
val[0] = 0x02;
val[1] = 0x95;
err |= davinci_i2c_write(2, val, ths7353_i2c_addr);
val[0] = 0x03;
val[1] = 0x94;
err |= davinci_i2c_write(2, val, ths7353_i2c_addr);
if (err) {
printk("THS7353\n");
}
return err;
}
int set_tsif_clk(enum tsif_clk_speed clk_speed)
{
unsigned int value;
unsigned int sys_vddpwdn = (unsigned int)IO_ADDRESS(0x01C40048);
unsigned int sys_tsif_ctl = (unsigned int)IO_ADDRESS(0x01C40050);
unsigned int sys_vsclkdis = (unsigned int)IO_ADDRESS(0x01C4006C);
davinci_cfg_reg(DM646X_CRGMUX);
davinci_cfg_reg(DM646X_STSOMUX);
davinci_cfg_reg(DM646X_STSIMUX);
{
int err = 0;
char val2[2];
val2[0] = 0x27 | 0x80;
val2[1] = tsif_output_clk_freq[clk_speed][0];
err = davinci_i2c_write(2, val2, CDCE949);
val2[0] = 0x28 | 0x80;
val2[1] = tsif_output_clk_freq[clk_speed][1];
err = davinci_i2c_write(2, val2, CDCE949);
val2[0] = 0x29 | 0x80;
val2[1] = tsif_output_clk_freq[clk_speed][2];
err = davinci_i2c_write(2, val2, CDCE949);
val2[0] = 0x2a | 0x80;
val2[1] = tsif_output_clk_freq[clk_speed][3];
err = davinci_i2c_write(2, val2, CDCE949);
val2[0] = 0x2b | 0x80;
val2[1] = tsif_output_clk_freq[clk_speed][4];
err = davinci_i2c_write(2, val2, CDCE949);
val2[0] = 0x24 | 0x80;
val2[1] = 0x6f;
err = davinci_i2c_write(2, val2, CDCE949);
}
mdelay(200);
value = 2 << 12 | /* Auxclk */
8 << 8 | /* CRG0_VCXI */
2 << 4 | /* Auxclk */
0; /* CRG0_VCXI */
outl(value, sys_tsif_ctl);
/* Enable all the TSIF related clocks */
value = inl(sys_vsclkdis);
value &= ~(unsigned int)(0x000000FC);
outl(value, sys_vsclkdis);
/* Powerup UART1 Flow control and Data */
value = inl(sys_vddpwdn);
value &= ~(unsigned int)(0x000000C0);
outl(value, sys_vddpwdn);
return 0;
}
static __init int dm644x_evm_expander_special(enum i2c_expander_pins pin,
unsigned val)
{
static u8 cmd[4] = { 4, 6, 0x00, 0x09 };
if (pin == CF_SEL) {
int err = davinci_i2c_write(4, cmd, 0x23);
if (err)
return err;
}
return 0;
}
int set_vid_in_mode_for_tvp5147() {
int err = 0;
u8 val;
unsigned int value;
unsigned int sys_vsclk =
(unsigned int)IO_ADDRESS(0x01C40038);
err = davinci_i2c_read(1, &val, CPLD_VIDEO_REG);
if(err)
return err;
val &= 0xDF;
err = davinci_i2c_write(1, &val, CPLD_VIDEO_REG);
if(err)
return err;
value = inl(sys_vsclk);
value |= (1<<4);
outl(value, sys_vsclk);
return err;
}
static int read_ir_values(void)
{
int err;
message[0] = 2;
message[1] = 2;
err = davinci_i2c_write(2, message, 0x23);
if (err)
return err;
msleep(1);
err = davinci_i2c_read(MESSAGE_LENGTH, message, 0x23);
if (err)
return err;
msleep(1);
next_value = 0;
return 0;
}
int set_vid_out_mode_for_hd() {
int err = 0;
u8 val;
unsigned int value;
unsigned int sys_vsclk =
(unsigned int)IO_ADDRESS(0x01C40038);
err = davinci_i2c_read(1, &val, CPLD_VIDEO_REG);
if(err)
return err;
val |= 0x40;
err = davinci_i2c_write(1, &val, CPLD_VIDEO_REG);
if(err)
return err;
value = inl(sys_vsclk);
value &= ~(7<<8);
value &= ~(7<<12);
value |= (2<<8);
value |= (2<<12);
outl(value, sys_vsclk);
return err;
}
int davinci_i2c_expander_op(enum i2c_expander_pins pin, unsigned val)
{
u16 address = davinci_i2c_expander.address;
u8 data = 0;
int err;
if (val > 1)
return -EINVAL;
if (davinci_i2c_expander.validate != NULL) {
err = davinci_i2c_expander.validate(pin);
if (err)
return err;
}
mutex_lock(&expander_lock);
err = davinci_i2c_read(1, &data, address);
if (err)
goto exit;
if (davinci_i2c_expander.special != NULL) {
err = davinci_i2c_expander.special(pin, val);
if (err)
goto exit;
}
data &= ~(1 << pin);
data |= val << pin;
err = davinci_i2c_write(1, &data, address);
exit:
mutex_unlock(&expander_lock);
return err;
}
static void am_or_pm(struct device *dev)
{
char rtcdata [9];
struct rtc_time tm, time, temp;
unsigned char mon, day, hrs, min, sec;
unsigned char yr_low, yr_high;
unsigned int yrs;
evm_read_time(dev, &tm);
temp = tm;
yrs = temp.tm_year + 1900;
yr_high = yrs / 100;
yr_low = yrs % 100;
mon = temp.tm_mon + 1;
day = temp.tm_mday;
min = 59;
sec = 59;
hrs = 11;
rtcdata [0] = 9;
rtcdata [1] = 0;
rtcdata [2] = BIN_TO_BCD(yr_low);
rtcdata [3] = BIN_TO_BCD(yr_high);
mon--;
rtcdata [4] = BIN_TO_BCD(mon);
rtcdata [5] = BIN_TO_BCD(day);
rtcdata [6] = BIN_TO_BCD(hrs);
rtcdata [7] = BIN_TO_BCD(min);
rtcdata [8] = BIN_TO_BCD(sec);
davinci_i2c_write(9, rtcdata, 0x23);
msleep(1);
msleep(1000);
evm_read_time(dev, &time);
if (time.tm_mday == temp.tm_mday)
am = 1;
else
am = 0;
davinci_i2c_write(9, rtcdata, 0x23);
msleep(1);
msleep(1000);
yrs = tm.tm_year + 1900;
yr_high = yrs / 100;
yr_low = yrs % 100;
mon = tm.tm_mon + 1;
day = tm.tm_mday;
min = tm.tm_min;
hrs = tm.tm_hour;
if (tm.tm_sec < 58)
sec = tm.tm_sec + 2;
else
sec = 59;
davinci_i2c_write(9, rtcdata, 0x23);
msleep(1);
}
static int evm_set_time(struct device *dev, struct rtc_time *tm)
{
char rtcdata [9];
char ampmdata [9];
unsigned char mon, day, hrs = 0, min, sec, leap_yr;
unsigned char yr_low, yr_high;
unsigned int yrs;
am_or_pm(dev);
yrs = tm->tm_year + 1900;
yr_high = yrs / 100;
yr_low = yrs % 100;
mon = tm->tm_mon;
hrs = tm->tm_hour;
day = tm->tm_mday;
min = tm->tm_min;
sec = tm->tm_sec;
leap_yr = ((!(yrs % 4) && (yrs % 100)) || !(yrs % 400));
if (am == 1 && tm->tm_hour <= 12) {
hrs = tm->tm_hour;
if (tm->tm_hour == 0)
hrs = tm->tm_hour + 12;
} else if ((am == 1 && tm->tm_hour > 12)
|| (am == 0 && tm->tm_hour < 12)) {
unsigned char mon1 = mon, day1 = day, hrs1 = 11;
unsigned char min1 = 59, sec1 = 59;
unsigned char yr_low1 = yr_low, yr_high1 = yr_high;
ampmdata [0] = 9;
ampmdata [1] = 0;
ampmdata [2] = BIN_TO_BCD(yr_low1);
ampmdata [3] = BIN_TO_BCD(yr_high1);
ampmdata [4] = BIN_TO_BCD(mon1);
ampmdata [5] = BIN_TO_BCD(day1);
ampmdata [6] = BIN_TO_BCD(hrs1);
ampmdata [7] = BIN_TO_BCD(min1);
ampmdata [8] = BIN_TO_BCD(sec1);
davinci_i2c_write(9, ampmdata, 0x23);
msleep(1);
msleep(1000);
am = (am == 1) ? 0 : 1;
if (!am)
hrs = tm->tm_hour - 12;
else if (tm->tm_hour == 0)
hrs = tm->tm_hour + 12;
} else if (am == 0 && tm->tm_hour > 12)
hrs = tm->tm_hour - 12;
rtcdata [0] = 9;
rtcdata [1] = 0;
rtcdata [2] = BIN_TO_BCD(yr_low);
rtcdata [3] = BIN_TO_BCD(yr_high);
rtcdata [4] = BIN_TO_BCD(mon);
rtcdata [5] = BIN_TO_BCD(day);
rtcdata [6] = BIN_TO_BCD(hrs);
rtcdata [7] = BIN_TO_BCD(min);
rtcdata [8] = BIN_TO_BCD(sec);
davinci_i2c_write(9, rtcdata, 0x23);
msleep(1);
return 0;
}
