drvgfaspi/kspi.c

#include<linux/string.h>
#include "kspi.h"
#include "kfile.h"

//uint8_t mode = SPI_MODE_3;
//uint8_t bits = 8;
//uint32_t speed = 1000000;
#define CMD_ACK			0xcc
#define CMD_NAK			0x33

#define CMD_GET_FIRMWARE_VERSION 0x51
#define CMD_GET_I2C 0x56
#define CMD_SET_I2C 0x57
#define CMD_GET_ADDRESS 0x58
#define CMD_SET_ADDRESS 0x59
#define CMD_SET_BACKLIGHT 0x5B
#define CMD_GET_UPTIME 0x5C
#define CMD_GET_ADC 0x5A

static unsigned char transfer_1(struct file *pf, unsigned char Tx)
{
	int ret;
	uint8_t tx = Tx;
	uint8_t rx;

	struct spi_ioc_transfer tr =
	{
		.tx_buf = (unsigned long) &tx,
		.rx_buf = (unsigned long) &rx,
		.len = 1,
		.delay_usecs = 0,
		.speed_hz = 1000000,
		.bits_per_word = 8,
	};

	ret = kf_ioctl(pf, SPI_IOC_MESSAGE(1), (unsigned long)&tr);

	if(ret < 0)
	{
		printk(KERN_ALERT "transfer_1 failed: %d\n", ret);
	    return 0;
	}

    return rx;
}

static int WaitACK(struct file *pf)
{
    unsigned char rcv = 0;
    int i = 0;

    // warten auf ACK

    while ((rcv != CMD_ACK) && (rcv != CMD_NAK) && i < 1000/*(time(NULL) < endwait)*/)
    {
        rcv = transfer_1(pf, 0);
        ++i;
    }

    return rcv;
}

int SendCMD(struct file *pf, unsigned char Cmd, unsigned char DataLen, unsigned char *Data)
{
	unsigned char Len = DataLen + 3;
	unsigned char Chk = Cmd;
	int i;

//	printk(KERN_ALERT "%s, Ctx: \"%s\"-(%d)\n", __FUNCTION__, current->comm, current->pid);

	for (i = 0; i < DataLen; i++)
	    Chk += *(Data + i);

	transfer_1(pf, Len);
	transfer_1(pf, Chk);
	transfer_1(pf, Cmd);

	for (i = 0; i < DataLen; i++) {
	    transfer_1(pf, *(Data + i));
	}
	return WaitACK(pf);
}

int ReadCmd(struct file *pf, int MaxLen, unsigned char *Data)
{
    unsigned char rcv = 0;
    int i = 0;
    int len;
    unsigned char chksum = 0, chkval = 0;
    int ret = 0;

//	printk(KERN_ALERT "%s, Ctx: \"%s\"-(%d)\n", __FUNCTION__, current->comm, current->pid);

    // warten auf längenbyte der Antwort
    while((rcv == 0) && (i < 2000))
    {
        rcv = transfer_1(pf, 0);
        ++i;
    }

    // daten einlesen
    len = rcv;
    for(i = 0; i < (len - 1); ++i)
    {
        rcv = transfer_1(pf, 0);
        //printf("%2.2X-", rcv);

        if(i == 0) //CHKSUM
        {
            chkval = 0;
            chksum = rcv;
        }
        else
        {
            chkval += rcv;
            if((i - 1) < MaxLen)
                *(Data + i - 1) = rcv;
        }
    }

    if(chksum != chkval)
    {
        ret = -1;
    }
    else
    {
        ret = len - 2;
    }

    return ret;
}

int CmdGetFirmwareVersion(struct file *pf, int *Hw, int *Sw)
{
    int ret = -1;
    int len = 0;

//	printk(KERN_ALERT "%s, Ctx: \"%s\"-(%d)\n", __FUNCTION__, current->comm, current->pid);

    ret = SendCMD(pf, CMD_GET_FIRMWARE_VERSION , 0, NULL);
    if(ret == CMD_ACK)
    {
        unsigned char Data[255];
        memset(Data, 0, sizeof(Data));

        if((len = ReadCmd(pf, sizeof(Data), Data)) == 9)
        {
            int HW_Version, SW_Version;

            HW_Version = (Data[1] << 24) + (Data[2] << 16) + (Data[3] << 8) + Data[4];
            SW_Version = (Data[5] << 24) + (Data[6] << 16) + (Data[7] << 8) + Data[8];

            if(Hw != NULL) *Hw = HW_Version;
            if(Sw != NULL) *Sw = SW_Version;
            ret = 0;
        } else {
            printk(KERN_ALERT "LEN = %d\n", len);
        }
    }

    transfer_1(pf, CMD_ACK); /* Testweise immer ACK */

    return ret;
}

unsigned long long CmdGetUptime(struct file *pf)
{
    unsigned long long ret = 0;
    int len = 0;

    ret = SendCMD(pf, CMD_GET_UPTIME , 0, NULL);
    if(ret == CMD_ACK)
    {
        unsigned char Data[255];
        ret = 0; //ACK erhalten soweit gut
        memset(Data, 0, sizeof(Data));

        if((len = ReadCmd(pf, sizeof(Data), Data)) == 9)
        {
            ret = (unsigned long long)(Data[1]) << 56 |
                  (unsigned long long)(Data[2]) << 48 |
                  (unsigned long long)(Data[3]) << 40 |
                  (unsigned long long)(Data[4]) << 32 |
                  (unsigned long long)(Data[5]) << 24 |
                  (unsigned long long)(Data[6]) << 16 |
                  (unsigned long long)(Data[7]) << 8 |
                  (unsigned long long)(Data[8]);
        }

        transfer_1(pf, CMD_ACK); /**< ACK */
    }
    return ret;
}

int CmdGetAddress(struct file *pf, unsigned int Addr, unsigned int *Value)
{
    int ret = -1;
    int len = 0;
    unsigned char ReadADDRESS[4];
    unsigned char DestData[10];
    int DestLen = sizeof(DestData);

    ReadADDRESS[0] = (unsigned char)((Addr >> 24) & 0xff);
    ReadADDRESS[1] = (unsigned char)((Addr >> 16) & 0xff);
    ReadADDRESS[2] = (unsigned char)((Addr >> 8) & 0xff);
    ReadADDRESS[3] = (unsigned char)(Addr & 0xff);

    ret = SendCMD(pf, CMD_GET_ADDRESS , sizeof(ReadADDRESS), ReadADDRESS);
    if(ret == CMD_ACK) {
        unsigned char Data[255];

        ret = 0; //ACK erhalten soweit gut
        memset(Data, 0, sizeof(Data));
        if((len = ReadCmd(pf, sizeof(Data), Data)) > 0) {
            memcpy(DestData, Data + 1, ((len - 1) <= DestLen)?(len - 1):DestLen);
            ret = len - 1;
        }
        transfer_1(pf, CMD_ACK); /**< ACK */
    }

    if(Value)
        *Value = (unsigned int)(DestData[0]) << 24 |
                 (unsigned int)(DestData[1]) << 16 |
                 (unsigned int)(DestData[2]) << 8 |
                 (unsigned int)(DestData[3]);
    return ret;
}

void getUPTIME(struct file *pf, unsigned int Addr, int nFwVersion)
{
    unsigned int dd;
    int day, hour, min;

    if(nFwVersion >= 0x113 )
    {
        unsigned long long Data;
        Data = CmdGetUptime(pf);
        day = Data / 86400000;
        dd = Data - day * 86400000;
        hour = dd / 3600000;
        dd -= hour * 3600000;
        min = dd / 60000;

    }
    else
    {
        unsigned int Data = 0xFFFFFFFF;

        CmdGetAddress(pf, Addr, &Data);
        day = Data / 86400000;
        dd = Data - day * 86400000;
        hour = dd / 3600000;
        dd -= hour * 3600000;
        min = dd / 60000;
    }
    
    
//    printf("%d d %2.2d:%2.2d\n", day, hour, min);
}

static const int g_kty_tab[][2] =
{
  {199, 1250},
  {351, 1000},
  {643, 750},
  {1185, 500},
  {2048, 250},
  {3025,  0},
  {3705, -250}
};

#define KTY_TAB_LEN				((sizeof g_kty_tab / sizeof g_kty_tab[0]) - 1)

int lin_kty(int widerstand)
{
	int i;

	if(widerstand <= g_kty_tab[0][0])
		return(g_kty_tab[0][1]);

	if(widerstand >= g_kty_tab[KTY_TAB_LEN][0])
		return(g_kty_tab[KTY_TAB_LEN][1]);

	/* Suchen des nächsten Tabelleneintrags */

	for(i=1; i<=KTY_TAB_LEN; i++)
	{
		if(g_kty_tab[i][0] >= widerstand)
		{
			break;
		}
	}

	/* Linear interpolieren */
	return 	(long)g_kty_tab[i-1][1] +                            /* y1 */
			(((long)g_kty_tab[i][1] - (long)g_kty_tab[i-1][1]) *   /* y2 - y1 */
			((long)widerstand - (long)g_kty_tab[i-1][0]) /       /* x - x1 */
			((long)g_kty_tab[i][0] - (long)g_kty_tab[i-1][0]));    /* x2 - x1 */
}

static int scale (int in_min, int in_max, int out_min, int out_max, int wert)
{
	int abc;
	abc = (((long)out_max - (long)out_min) * (long)wert) / ( (long)in_max - (long)in_min);
	abc = abc + out_min;
	return abc;
}

int CmdGetADC(struct file *pf, LPTIVA_ADC padc)
{
    int ret;
    int len = 0;

    ret = SendCMD(pf, CMD_GET_ADC , 0, NULL);

    if(ret == CMD_ACK)
    {
		unsigned short data[128];
		memset(data, 0, sizeof(data));

        if((len = ReadCmd(pf, sizeof(data) - 1, ((unsigned char*)data) + 1)) == 13)
        {
            padc->UVers		= scale(0, 4096, 0, 4375, ntohs(data[1]));	// val / 100.0 + 0.4
            padc->UBatV3	= scale(0, 4096, 0, 500, ntohs(data[2]));	// val / 100.0
            padc->Temp		= lin_kty(ntohs(data[3]));					// val / 10.0
            padc->UV5Vsys	= scale(0, 4096, 0, 570, ntohs(data[4]));	// val / 100.0
            padc->UV3V6Bat	= scale(0, 4096, 0, 500, ntohs(data[5]));	// val / 100.0
            padc->TempTIVA	= ntohs(data[6]);							// 147.5 - 187.5 * val / 4096.0
            ret = 0;
        }
        else
        {
            printk(KERN_ALERT "CmdGetADC - ReadCmd - LEN = %d\n", len);
	    	ret = -1;
        }
    }
    else
    {
		printk(KERN_ALERT "CmdGetADC - SendCMD - ret = %d\n", ret);
    	ret = -1;
    }

	transfer_1(pf, CMD_ACK); /* Testweise immer ACK */
    return ret;
}