lib_adt7461.c

#include "edtinc.h"

#include "lib_adt7461.h"



/* IO to chip pins*/


/* int temp_clock = 0, temp_data = 1, temp_den = 0;*/


void
edt_adt7461_set_reg(EdtDev *edt_p, u_int adt7461_reg)
{
    edt_p->adt7461_reg = (u_int) adt7461_reg;
}

u_int
edt_adt7461_get_reg(EdtDev *edt_p)
{
    if (edt_p->adt7461_reg == 0)
        edt_p->adt7461_reg = (u_int) EDT_ADT7461_REG;

    return (u_int) edt_p->adt7461_reg;
}

// Select a mezzanine adt7461 chip to access
void edt_adt7461_set_mezzanine_chip(EdtDev *edt_p, int mezzanine_chip_select)
{
    switch (mezzanine_chip_select)
    {
    case 0:
        edt_p->adt7461_reg = (u_int) EDT_ADT7461_MEZZ0_REG;
        break;

    case 1:
        edt_p->adt7461_reg = (u_int) EDT_ADT7461_MEZZ1_REG;
        break;

    default:
        edt_p->adt7461_reg = (u_int) EDT_ADT7461_REG;
    }
}

// Select a baseboard adt7461 chip to access
void edt_adt7461_set_baseboard_chip(EdtDev *edt_p, int baseboard_chip_select)
{

    edt_p->adt7461_reg = (u_int) EDT_ADT7461_REG;

    if (baseboard_chip_select == 1)
        edt_reg_or(edt_p, EDT_PCIE_CFG, 1);
    else
        edt_reg_and(edt_p, EDT_PCIE_CFG, 0xFFFFFFE);

}

void
edt_adt7461_set_clock(EdtDev *edt_p, int clock)
{
    int val = edt_reg_read(edt_p, (u_int)edt_p->adt7461_reg) & ~EDT_ADT7461_CLK;
    edt_reg_write(edt_p, (u_int)edt_p->adt7461_reg, (val | ((clock)?EDT_ADT7461_CLK:0)));
}

void
edt_adt7461_set_data(EdtDev *edt_p, int data)
{
    int val = edt_reg_read(edt_p, (u_int)edt_p->adt7461_reg) & ~EDT_ADT7461_DATA;
    edt_reg_write(edt_p, (u_int)edt_p->adt7461_reg, (val | ((data)?EDT_ADT7461_DATA:0)));
}

void
edt_adt7461_set_den(EdtDev *edt_p, int enable)
{
    int val = edt_reg_read(edt_p, (u_int)edt_p->adt7461_reg) & ~EDT_ADT7461_TRISTATE;
    edt_reg_write(edt_p, (u_int)edt_p->adt7461_reg, (val | ((!enable)?EDT_ADT7461_TRISTATE:0)));
}

void
edt_adt7461_show_bits(EdtDev *edt_p)

{
    int val = edt_reg_read(edt_p, (u_int)edt_p->adt7461_reg);

    printf("%s %s %s\n", 
        (val & EDT_ADT7461_TRISTATE)? "DEN":"   ",
        (val & EDT_ADT7461_DATA)?"DATA":"    ",
        (val & EDT_ADT7461_CLK)?"CLK":"   ");

}

void
edt_adt7461_set(EdtDev *edt_p, int enable, int data, int clock )
{
    int rval = edt_reg_read(edt_p, (u_int)edt_p->adt7461_reg) & 
        ~(EDT_ADT7461_TRISTATE|EDT_ADT7461_CLK|EDT_ADT7461_DATA) ;

    int val  = ((clock)  ? EDT_ADT7461_CLK : 0)
        | ((data) ? EDT_ADT7461_DATA : 0) | ((enable) ? 0 : EDT_ADT7461_TRISTATE);


    edt_reg_write(edt_p, (u_int)edt_p->adt7461_reg, val | rval);


    /*  edt_adt7461_show_bits(edt_p);*/


}


int
edt_adt7461_get_therm_reset(EdtDev *edt_p)

{
    int val;
    val = edt_reg_read(edt_p, (u_int)edt_p->adt7461_reg) & EDT_ADT7461_THERM_RESET;
    return (val != 0);
}

void
edt_adt7461_set_therm_reset(EdtDev *edt_p, int enable)

{
    int val = edt_reg_read(edt_p, (u_int)edt_p->adt7461_reg) & ~EDT_ADT7461_THERM_RESET;
    edt_reg_write(edt_p, (u_int)edt_p->adt7461_reg, val | (enable)?EDT_ADT7461_THERM_RESET:0);
}

int
edt_adt7461_read_alert_pin(EdtDev *edt_p)
{
    if ((edt_reg_read(edt_p, (u_int)edt_p->adt7461_reg) & EDT_ADT7461_ALERT) != 0) {
        return 1;
    } else {
        return 0;
    }
}


int
edt_adt7461_read_data_pin(EdtDev *edt_p)
{
    int val;
    val = edt_reg_read(edt_p, (u_int)edt_p->adt7461_reg) & EDT_ADT7461_DATA;
    edt_msg(EDTLIB_MSG_INFO_2, "read_data_pin %x\n", val);
    return (val != 0);
}

int
edt_adt7461_read_therm_pin(EdtDev *edt_p)
{
    int val;
    val = edt_reg_read(edt_p, (u_int)edt_p->adt7461_reg) & EDT_ADT7461_THERM;
    edt_msg(EDTLIB_MSG_INFO_2, "read_data_pin %x\n", val);
    return (val != 0);
}


/* Basic communication parts*/


void
edt_adt7461_send_bus_reset(EdtDev *edt_p) 
{
    /*send low to hi data transition while clock is hi*/
    edt_msg(EDTLIB_MSG_INFO_2, "Send Bus Reset\n");
    edt_adt7461_set_den(edt_p, 1);
    edt_adt7461_set_clock(edt_p,1);
    edt_adt7461_set_data(edt_p,1);
    edt_adt7461_set_data(edt_p,0);



}

void
edt_adt7461_send_bus_start(EdtDev *edt_p)

{
    /*assuming clock starts hi*/
    /*send hi to low data transition while clock is hi*/
    edt_msg(EDTLIB_MSG_INFO_2, "Send Bus Start\n");


    edt_adt7461_set_den(edt_p,1);
    edt_adt7461_set_data(edt_p,1);

    edt_adt7461_set_data(edt_p,0);

    edt_adt7461_set_clock(edt_p,0);



}

void
edt_adt7461_send_bus_stop(EdtDev *edt_p)

{
    /*assuming clock starts low*/
    /*send low to hi data transition while clock is hi*/
    edt_msg(EDTLIB_MSG_INFO_2, "Send Bus Stop\n");
    edt_adt7461_set_clock(edt_p,1);

    edt_adt7461_set_data(edt_p,0);
    edt_adt7461_set_data(edt_p,1);


}

int
edt_adt7461_get_ack(EdtDev *edt_p)

{
    int rc = 1;
    edt_msg(EDTLIB_MSG_INFO_2, "Get Ack\n");
    /*check for acknowledge from slave (pulls data line low)*/

    edt_adt7461_set_den(edt_p,0);
    edt_adt7461_set_clock(edt_p, 0);
    edt_adt7461_set_clock(edt_p, 1);

    /*    edt_adt7461_set(edt_p,0,0,0); //disable data output*/

    /* edt_adt7461_set(edt_p,0,0,1); //clock high*/
    if (edt_adt7461_read_data_pin(edt_p)) {
        rc = 0; /*data is hi - no acknowledge*/
    }

    edt_adt7461_set_clock(edt_p, 0);

    /*   edt_adt7461_set(edt_p,0,0,0); //clock low*/

    return rc;
}


int
edt_adt7461_send_data_byte(EdtDev *edt_p, int data)

{
    /*assuming clock starts low*/
    int i;
    /*write out one bit x8*/
    int dbit;
    edt_msg(EDTLIB_MSG_INFO_2, "Send Data Byte %02x\n", data);

    edt_adt7461_set_den(edt_p, 1);
    edt_adt7461_set_clock(edt_p, 0);

    for (i = 0; i < 8; i++) {
        dbit  = data & 0x80;
        edt_adt7461_set_data(edt_p, dbit);;
        edt_adt7461_set_clock(edt_p, 1);
        edt_adt7461_set_clock(edt_p, 0);

        data = data << 1;
    }

    if (!edt_adt7461_get_ack(edt_p))
        return -1;

    return 0;
}

int
edt_adt7461_get_data_byte(EdtDev *edt_p, int doAcknowledge)

{
    /*assuming clock starts low*/
    int i;
    int data = 0;
    /*read in one bit x8*/
    edt_msg(EDTLIB_MSG_INFO_2, "Get Data Byte %s\n", (doAcknowledge)?"Ack" : "");

    edt_adt7461_set_den(edt_p,0);
    edt_adt7461_set_clock(edt_p, 0);

    for (i = 0; i < 8; i++) {
        edt_adt7461_set_clock(edt_p,1); /*clock goes high*/
        data = (data << 1) | ( edt_adt7461_read_data_pin(edt_p) ? 0x01 : 0x00 ); /*data bit is read*/
        edt_adt7461_set_clock(edt_p,0); /*clock goes high*/
    }
    if (doAcknowledge) {

        if (!edt_adt7461_get_ack(edt_p))
            return -1;
        else
            return data;
    } else {
        edt_adt7461_set_den(edt_p,1);
        edt_adt7461_set_data(edt_p, 1);
        /*send no acknowledge to slave (pull data line hi)*/
        edt_adt7461_set_clock(edt_p,1); /*clock goes high*/
        edt_adt7461_set_clock(edt_p,0); /*clock goes low*/

        return data;
    }
}


/* Full register read/write commands*/


int
edt_adt7461_reg_read(EdtDev *edt_p, int address)

{
    int status;
    int data;
    switch (0) {
        case 0:
            /*send start condition*/
            edt_adt7461_send_bus_start(edt_p);
            /*send address of temperature controller*/
            status = edt_adt7461_send_data_byte(edt_p, (EDT_ADT7461_DEVICE_ADDR << 1) | 0x00);
            if (status == -1) break;
            /*send register address for read*/
            status = edt_adt7461_send_data_byte(edt_p, address);
            if (status == -1) break;
            /*send stop condition*/
            edt_adt7461_send_bus_stop(edt_p);
            /*send start condition*/
            edt_adt7461_send_bus_start(edt_p);
            /*send address of temperature controller*/
            status = edt_adt7461_send_data_byte(edt_p, (EDT_ADT7461_DEVICE_ADDR << 1) | 0x01);
            if (status == -1) break;
            /*read data for read*/
            data = edt_adt7461_get_data_byte(edt_p, 0);
            if (data == -1) break;
            /*send stop condition*/
            edt_adt7461_send_bus_stop(edt_p);
            return data;
    }
    /*reset bus*/
    edt_adt7461_send_bus_reset(edt_p);
    return -1;  /*transaction failed*/
}

int
edt_adt7461_reg_write(EdtDev *edt_p, int address, int data)

{
    int status;
    switch (0) {
        case 0:
            /*send start condition*/
            edt_adt7461_send_bus_start(edt_p);
            /*send address of temperature controller*/
            status = edt_adt7461_send_data_byte(edt_p, (EDT_ADT7461_DEVICE_ADDR << 1) | 0x00);
            if (status == -1) break;
            /*send register address for write*/
            status = edt_adt7461_send_data_byte(edt_p, address);
            if (status == -1) break;
            /*send data for write*/
            status = edt_adt7461_send_data_byte(edt_p, data);
            if (status == -1) break;
            /*send stop condition*/
            edt_adt7461_send_bus_stop(edt_p);
            return 0;
    }
    /*reset bus*/
    edt_adt7461_send_bus_reset(edt_p);
    return -1;  /*transaction failed*/
}

int
edt_adt7461_read_alert_address(EdtDev *edt_p)

{
    int status;
    int deviceAddress;
    switch (0) {
        case 0:
            /*send start condition*/
            edt_adt7461_send_bus_start(edt_p);
            /*send address of temperature controller*/
            status = edt_adt7461_send_data_byte(edt_p, (EDT_ADT7461_ALERT_RESPONSE_ADDR << 1) | 0x01);
            if (status == -1) break;
            /*read address of alert-causing device*/
            deviceAddress = edt_adt7461_get_data_byte(edt_p, 0);
            if (deviceAddress == -1) break;
            /*send stop condition*/
            edt_adt7461_send_bus_stop(edt_p);
            return deviceAddress & 0xFE;
    }
    /*reset bus*/
    edt_adt7461_send_bus_reset(edt_p);
    return -1;  /*transaction failed*/
}

/* Main*/



/* returns 10-bit temperature*/
/* with two bits for fractional degree*/
int
edt_adt7461_read_extern(EdtDev *edt_p, int tenbits)

{

    int low, high;

    low = edt_adt7461_reg_read(edt_p,EDT_ADT7461_EXT_TEMP_LOW_BYTE_R);
    high = edt_adt7461_reg_read(edt_p,EDT_ADT7461_EXT_TEMP_R);

    if (tenbits)
        return (high << 2) | (low >> 6);
    else
        return high;
}

int
edt_adt7461_read_intern(EdtDev *edt_p)

{
    return edt_adt7461_reg_read(edt_p,EDT_ADT7461_INTERN_TEMP_R);
}

void
edt_adt7461_set_alert_high(EdtDev *edt_p, int alert_high)

{       
    edt_adt7461_reg_write(edt_p, EDT_ADT7461_EXT_TEMP_HIGH_W, alert_high);
}

int
edt_adt7461_get_alert_high(EdtDev *edt_p)

{       
    return edt_adt7461_reg_read(edt_p, EDT_ADT7461_EXT_TEMP_HIGH_R);
}
void
edt_adt7461_set_alert_low(EdtDev *edt_p, int alert_low)

{       
    edt_adt7461_reg_write(edt_p, EDT_ADT7461_EXT_TEMP_LOW_W, alert_low);
}

int
edt_adt7461_get_alert_low(EdtDev *edt_p)

{       
    return edt_adt7461_reg_read(edt_p, EDT_ADT7461_EXT_TEMP_LOW_R);
}

void
edt_adt7461_set_therm(EdtDev *edt_p, int therm_high)

{

    edt_adt7461_reg_write(edt_p, EDT_ADT7461_EXT_THERM_W, therm_high);


}

int
edt_adt7461_get_therm(EdtDev *edt_p)

{

    return edt_adt7461_reg_read(edt_p, EDT_ADT7461_EXT_THERM_W);


}

void
edt_adt7461_set_therm_hysteresis(EdtDev *edt_p, int hysteresis)

{

    edt_adt7461_reg_write(edt_p, EDT_ADT7461_THERM_HYSTERESIS, hysteresis);

}

int
edt_adt7461_get_therm_hysteresis(EdtDev *edt_p)

{

    return      edt_adt7461_reg_read(edt_p, EDT_ADT7461_THERM_HYSTERESIS);

}

int
edt_adt7461_get_alert(EdtDev *edt_p)

{
    int alert;

    alert = edt_adt7461_read_alert_pin(edt_p);

    /* clear */

    if (alert)
        edt_adt7461_read_alert_address(edt_p);

    return alert;
}

void
edt_adt4761_print_status(EdtDev *edt_p, int full)

{

    int alert;
    int external;
    int internal;
    int therm;


    alert = edt_adt7461_get_alert(edt_p);
    therm = edt_adt7461_read_therm_pin(edt_p);
    external = edt_adt7461_read_extern(edt_p, TRUE);
    internal = edt_adt7461_read_intern(edt_p);
    printf("Ext %d.%02d Int %i", external >> 2, (external & 3) * 25, internal);

    if (full)
    {


        printf(" Alert min %i max %i",
            edt_adt7461_get_alert_low(edt_p),
            edt_adt7461_get_alert_high(edt_p));

        printf(" Therm %d Hyster %d", 
            edt_adt7461_get_therm(edt_p),
            edt_adt7461_get_therm_hysteresis(edt_p));

        printf(" Stat 0x%02x T Reset %s", 
            edt_adt7461_reg_read(edt_p, EDT_ADT7461_STATUS_REG_R),
            (edt_adt7461_get_therm_reset(edt_p)) ? "On ":"Off"
            );



    }
    if (alert) {
        printf(" ALERT");                       
    }
    if (therm) {
        printf(" THERM");                       
    }

    printf("\n");
}

---