#include <string.h>
#include <stdio.h>
#include <stdlib.h>
#include <linux/avm_i2c.h>
#include <avm_i2c.h>

/*------------------------------------------------------------------------------------------*\
\*------------------------------------------------------------------------------------------*/
char *program;
void *handle;
unsigned int debug = 0;
unsigned int gpio_display_bits = 0;

struct _i2c_addr {
    unsigned char addr;
    char *device_name;
    unsigned int (*read)(unsigned int);
    unsigned int (*write)(unsigned int, unsigned int);
};

extern struct _i2c_addr i2c_addr[];
unsigned int device_sub_addr = 0;

/*------------------------------------------------------------------------------------------*\
\*------------------------------------------------------------------------------------------*/
void print_device(void) {
    struct _i2c_addr *D = &i2c_addr[0];
    while(D->device_name) {
        printf("%s addr 0x%x%s%s\n", D->device_name, D->addr,
                D->read ? " (read supported)" : "",
                D->write ? " (write supported)" : "");
        D++;
    }
}

/*------------------------------------------------------------------------------------------*\
\*------------------------------------------------------------------------------------------*/
struct _i2c_addr *find_device(char *name) {
    struct _i2c_addr *D = &i2c_addr[0];
    while(*name && *name == ' ') name++;
    while(D->device_name) {
        if(!strcmp(D->device_name, name))
            return D;
        D++;
    }
    return NULL;
}

/*------------------------------------------------------------------------------------------*\
\*------------------------------------------------------------------------------------------*/
unsigned int read_temp_lm75(unsigned int sensor) {
    unsigned short value;
    signed short temp;
    
    signed int read_length;
    read_length = avm_i2c_read(handle, 0x48 | (sensor & 0x07), 0, (void *)&value, sizeof(value));
    if(read_length < 0) {
        printf("[LM75]: read error %d\n", read_length);
        return read_length;
    }
    if(debug)
        printf("[LM75] Value: 0x%x\n", value);
    temp = value & 0x80 ? -(value & 0x7F) : (value & 0x7F);
    printf(" temp: %d.%c C\n", temp, value & 0x8000 ? '5' : '0');
    return 0;
}

/*------------------------------------------------------------------------------------------*\
\*------------------------------------------------------------------------------------------*/
unsigned int write_gpio(unsigned int sensor, char *device, void *Buffer, unsigned int length) {
    signed int write_length;
    struct _i2c_addr *D = find_device(device);
    if(D == NULL)
        return -1;

    write_length = avm_i2c_raw_write(handle, D->addr | (sensor & 0x07), Buffer, length);
    if(write_length < 0) {
        printf("[%s]: write error %d\n", D->device_name, write_length);
        return write_length;
    }
    return 0;
}

/*------------------------------------------------------------------------------------------*\
\*------------------------------------------------------------------------------------------*/
unsigned int read_gpio(unsigned int sensor, char *device, unsigned int length) {
    signed int gpio;
    signed int read_length;
    struct _i2c_addr *D = find_device(device);
    if(D == NULL)
        return -1;

    read_length = avm_i2c_raw_read(handle, D->addr | (sensor & 0x07), (void *)&gpio, length);
    /*--- read_length = avm_i2c_read(handle, D->addr | (sensor & 0x07), 0, (void *)&gpio, length); ---*/
    if(read_length < 0) {
        printf("[%s]: read error %d\n", D->device_name, read_length);
        return read_length;
    }
    switch(length) {
        case 1:
            gpio &= 0xFF;
            break;
        case 2:
            gpio &= 0xFFFF;
            break;
    }

    if(gpio_display_bits) {
        printf("[%s] %u %u %u %u %u %u %u %u\n", D->device_name, 
                gpio & (1 << 0),
                gpio & (1 << 1),
                gpio & (1 << 2),
                gpio & (1 << 3),
                gpio & (1 << 4),
                gpio & (1 << 5),
                gpio & (1 << 6),
                gpio & (1 << 7)
        );
    } else {
        printf("[%s] Value: 0x%x\n", D->device_name, gpio);
    }
    return 0;
}

/*------------------------------------------------------------------------------------------*\
\*------------------------------------------------------------------------------------------*/
unsigned int write_gpio_pcf8574(unsigned int sensor, unsigned int value) {
    return write_gpio(sensor, "PCF8574", (void *)&value, 1);
}

/*------------------------------------------------------------------------------------------*\
\*------------------------------------------------------------------------------------------*/
unsigned int read_gpio_pcf8574(unsigned int sensor) {
    return read_gpio(sensor, "PCF8574", 1);
}

/*------------------------------------------------------------------------------------------*\
\*------------------------------------------------------------------------------------------*/
unsigned int write_gpio_pcf8574a(unsigned int sensor, unsigned int value) {
    return write_gpio(sensor, "PCF8574A", (void *)&value, 1);
}

/*------------------------------------------------------------------------------------------*\
\*------------------------------------------------------------------------------------------*/
unsigned int read_gpio_pcf8574a(unsigned int sensor) {
    return read_gpio(sensor, "PCF8574A", 1);
}

/*------------------------------------------------------------------------------------------*\
\*------------------------------------------------------------------------------------------*/
unsigned int write_gpio_pcf8575(unsigned int sensor, unsigned int value) {
    return write_gpio(sensor, "PCF8575", (void *)&value, 2);
}

/*------------------------------------------------------------------------------------------*\
\*------------------------------------------------------------------------------------------*/
unsigned int read_gpio_pcf8575(unsigned int sensor) {
    return read_gpio(sensor, "PCF8575", 2);
}

/*------------------------------------------------------------------------------------------*\
\*------------------------------------------------------------------------------------------*/
unsigned int read_ad_pcf8591(unsigned int sensor) {
    signed char value;
    signed int read_length;
    unsigned int channel;
    for(channel = 0 ; channel < 4 ; channel++) {
        read_length = avm_i2c_read(handle, 0x48 | (sensor & 0x07), channel, (void *)&value, sizeof(value));
        if(read_length < 0) {
            printf("[PCF8591]: read error %d\n", read_length);
            return read_length;
        }
        printf("[PCF8591] Value: 0x%x\n", value);
    }
    return 0;
}

/*------------------------------------------------------------------------------------------*\
\*------------------------------------------------------------------------------------------*/
struct _i2c_addr i2c_addr[] = {
    { 0x48, "LM75", read_temp_lm75, NULL },   /*--- temp Sensor ---*/
    { 0x48, "PCF8591", read_ad_pcf8591, NULL },  /*--- AD-DA wandler ---*/
    { 0x20, "PCF8575", read_gpio_pcf8575, write_gpio_pcf8575 }, /*--- 16-Bit GPIO ---*/
    { 0x20, "PCF8574", read_gpio_pcf8574, write_gpio_pcf8574 }, /*--- 8-Bit GPIO ---*/
    { 0x38, "PCF8574A", read_gpio_pcf8574a, write_gpio_pcf8574a }, /*--- 8-Bit GPIO ---*/
    { 0x00, NULL, NULL, NULL }
};

/*------------------------------------------------------------------------------------------*\
\*------------------------------------------------------------------------------------------*/
void usage(char *program) {
    unsigned int i;
    printf("use: %s [-d][-b][-s subaddr][-a device addr][-q][-r register_addr][-w write_value][-D device-name]\n", program);
    printf("supported device-names are:\n");
    for(i = 0 ; i2c_addr[i].device_name ; i++) 
        printf("\t%s (addr=0x%x)\n", i2c_addr[i].device_name, i2c_addr[i].addr);
}

/*------------------------------------------------------------------------------------------*\
\*------------------------------------------------------------------------------------------*/
int main(int argc, char* argv[]) {
    struct _i2c_addr *D;
    int zuende = 0;
    unsigned int write_value = 0;
    char Buffer[32];
    unsigned int device_addr = 0, register_addr = 0, read_length, i;
    unsigned int do_write = 0;
    program = argv[0];


    handle = avm_i2c_open(avm_i2c_type_8_bit);
    if(handle == NULL) {
        printf("[%s]: avm_i2c_open failed\n", program);
        exit(-1);
    }

    for(i = 1 ; i < argc ; i++) {
        if(argv[i][0] == '-') {
            switch(argv[i][1]) {
                case 'h':
                    usage(argv[0]);
                    exit(0);
                case 'd':
                    debug = 1;
                    break;
                case 'b':
                    gpio_display_bits = 1;
                    break;
                case 's':
                    device_sub_addr = atoi(argv[++i]);
                    break;
                case 'q':
                    exit(0);
                case 'a':
                    device_addr = atoi(argv[++i]);
                    break;
                case 'r':
                    register_addr = atoi(argv[++i]);
                    do_write = 0;
                    break;
                case 'w':
                    write_value = atoi(argv[++i]);
                    do_write = 1;
                    break;
                case 'R':
                    read_length = atoi(argv[++i]);

                    printf("read %u bytes from device 0x%x register 0x%x\n", read_length, device_addr, register_addr);
                    read_length = avm_i2c_read(handle, device_addr + device_sub_addr, register_addr, Buffer, read_length);

                    printf("read: %u bytes: ", read_length);
                    for(i = 0 ; i < read_length ; i++)
                        printf("0x%02x ", Buffer[i]);
                    printf("\n");
                    break;
                case 'D':
                    D = find_device(argv[++i]);
                    if(do_write) {
                        if(D && D->write) {
                            D->write(device_sub_addr, write_value);
                        }
                    } else {
                        if(D && D->read) {
                            D->read(device_sub_addr);
                        }
                    }
                    break;
            }
        }
    }



    while(!zuende) {
        printf("[q]uit [a]ddress <value> [r]egister <value> [R]ead <length> [D]evice <name> [sub_device]: ");
        gets(Buffer);

        switch(Buffer[0]) {
            case 'q':
                zuende = 1;
                break;
            case 'a':
                if(strlen(Buffer) < 3)
                    device_addr = 0x48;
                else
                    device_addr = atoi(Buffer + 1);
                break;
            case 'r':
                if(strlen(Buffer) < 3)
                    register_addr = 0;
                else
                    register_addr = atoi(Buffer + 1);
                break;
            case 'R':
                if(strlen(Buffer) < 3)
                    read_length = 2;
                else
                    read_length = atoi(Buffer + 1);

                printf("read %u bytes from device 0x%x register 0x%x\n", read_length, device_addr, register_addr);
                read_length = avm_i2c_read(handle, device_addr, register_addr, Buffer, read_length);

                printf("read: %u bytes: ", read_length);
                for(i = 0 ; i < read_length ; i++)
                    printf("0x%02x ", Buffer[i]);
                printf("\n");
                break;
            case 'D':
                if(strlen(Buffer) < 3) {
                    print_device();
                    break;
                }
                D = find_device(Buffer + 1);
                if(D && D->read) {
                    D->read(0);
                }
                break;
        }
    }
    return 0;
}