/** @brief driver for Pi ADC card xxx
 *
 */
#include <stdio.h>
#include <stdint.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/ioctl.h>
#include <fcntl.h>
#include <linux/i2c-dev.h>

#include <epicsThread.h>
#include <epicsTime.h>
#include <epicsTypes.h>
#include <devLib.h>
#include <drvSup.h>
#include <epicsExport.h>
#include <errlog.h>

#include <iocsh.h>

#include "drvAdcPi.h"

/* crc("adcPi") */
#define MYMAGIC 1729550187U 




#define MCP3424_NEW_CONV  0x80
#define MCP3424_CHANNEL_1 0x00
#define MCP3424_CHANNEL_2 0x20
#define MCP3424_CHANNEL_3 0x40
#define MCP3424_CHANNEL_4 0x60
#define MCP3424_CONT_CONV 0x10
#define MCP3424_ONE_SHOT_CONV 0x00
#define MCP3424_12BIT_240SPS 0x00
#define MCP3424_14BIT_60SPS 0x04
#define MCP3424_16BIT_15SPS 0x08
#define MCP3424_18BIT_3_75SPS 0x0c
#define MCP3424_GAIN_1 0x00
#define MCP3424_GAIN_2 0x01
#define MCP3424_GAIN_4 0x02
#define MCP3424_GAIN_8 0x03
#define MCP3424_CONT_MASK 0x6f
 
// adcPi definitions, on i2c-bus
#define ADC_1 		0x68
#define ADC_2 		0x69
#define ADC_CHANNEL1	(MCP3424_NEW_CONV | MCP3424_CHANNEL_1 | MCP3424_CONT_CONV | MCP3424_14BIT_60SPS | MCP3424_GAIN_1 )
#define ADC_CHANNEL2	(MCP3424_NEW_CONV | MCP3424_CHANNEL_2 | MCP3424_CONT_CONV | MCP3424_14BIT_60SPS | MCP3424_GAIN_1 )
#define ADC_CHANNEL3	(MCP3424_NEW_CONV | MCP3424_CHANNEL_3 | MCP3424_CONT_CONV | MCP3424_14BIT_60SPS | MCP3424_GAIN_1 )
#define ADC_CHANNEL4	(MCP3424_NEW_CONV | MCP3424_CHANNEL_4 | MCP3424_CONT_CONV | MCP3424_14BIT_60SPS | MCP3424_GAIN_1 )

/** @brief linked list of card structures
 *
 */
struct adcPiCard {
	epicsUInt32 magic;
	adcPiCard *next;
	int cardNumber;
	unsigned int i2cAddress;
	char* baseAddress; // not used with i2c
	unsigned int fh; // file handle

};
static adcPiCard *firstCard = NULL;

int adcPiDebug = 1;
epicsExportAddress (int, adcPiDebug);

static long adcPiReport (int detail);

typedef struct {
	long 		number;
	DRVSUPFUN	report;
	DRVSUPFUN	init;
} drvAdcPi_drvet;
drvAdcPi_drvet adcPi = {
	2,
	adcPiReport,
	NULL
};

epicsExportAddress (drvet, adcPi);

static epicsUInt16 getAdc(adcPiCard* card, int signal)
{
static __u8  res[4];
static unsigned int dummy; 
static __u8 adc, adc_channel;
static int ret;
//static unsigned int threadPrio;
//epicsTimeStamp startTime, endTime;
//double elapsedTime;
//static int loopCounter;

	if (signal < 0 || signal > ADC_PI_MAX_CHANNEL) {
		errMessage (-1, "Signal Number out of range");
		return 0;
	}
	//threadPrio = epicsThreadGetPrioritySelf();
	//epicsThreadSetPriority( epicsThreadGetIdSelf(),epicsThreadPriorityMin );
	
	//printf(" card->fh : %d, signal : %d (prio: %d)\n", card->fh, signal, epicsThreadGetPrioritySelf());
	
	switch (signal){
    	case 0: { adc=ADC_1; adc_channel=ADC_CHANNEL1; }; break;
		case 1: { adc=ADC_1; adc_channel=ADC_CHANNEL2; }; break;
		case 2: { adc=ADC_1; adc_channel=ADC_CHANNEL3; }; break;
		case 3: { adc=ADC_1; adc_channel=ADC_CHANNEL4; }; break;
		case 4: { adc=ADC_2; adc_channel=ADC_CHANNEL1; }; break;
		case 5: { adc=ADC_2; adc_channel=ADC_CHANNEL2; }; break;
		case 6: { adc=ADC_2; adc_channel=ADC_CHANNEL3; }; break;
		case 7: { adc=ADC_2; adc_channel=ADC_CHANNEL4; }; break;
		default: { adc=ADC_1; adc_channel=ADC_CHANNEL1; }; break;
	}

		
	// choose device
	if (ioctl(card->fh,I2C_SLAVE,adc) != 0) errMessage (0, "ioctl failed");
	//if (usleep (50000) < 0) errMessage (0, "usleep failed");
	//printf ("adc_channel = 0x%02X \n", adc_channel);
	//epicsTimeGetCurrent(&startTime);
	if (i2c_smbus_write_byte (card->fh, adc_channel) != 0) errMessage (0, "i2c_smbus_write_byte failed");
	// wait a little bit for end of conversion
	if (usleep (50000) < 0) errMessage (0, "usleep failed");
	// 3 for != 18bit mode
	//loopCounter = 0;
	do {
		ret = i2c_smbus_read_i2c_block_data(card->fh, adc_channel, 3, res);
		// printf(" res[0] = 0x%02X, res[1] = 0x%02X, res[2] = 0x%02X\n", res[0], res[1], res[2]);
		if (ret != 3) {
			errMessage (0, "i2c_smbus_read_i2c_block_data");
			fprintf (stderr, "i2c_smbus_read_i2c_block_data returns %d bytes != 3\n", ret);
		}
		//if (res[2] & 0x80) {
		//	fprintf (stderr, "i2c_smbus_read_i2c_block_data, output register (0x%02X) not updated yet\n", res[2]);
		//}
		//loopCounter++;
	} while (res[2] & 0x80);
		
	//epicsTimeGetCurrent(&endTime);
	//elapsedTime = epicsTimeDiffInSeconds(&endTime, &startTime);
	//printf("Elapsed time %f\n", elapsedTime);
	//printf(" res[0] = 0x%02X, res[1] = 0x%02X, res[2] = 0x%02X, loopCounter = %d\n", res[0], res[1], res[2], loopCounter);
    
    
    dummy = (res[0]<<8|res[1]);
	if (dummy>=32768) dummy=65536-dummy;
	//val = dummy * 0.000154;
	// printf(" dummy = %d, val = %lf\n", dummy, val);
	//return val;
	//if (adcPiDebug) printf ("dummy = 0x%x\n", dummy);
	// epicsThreadSetPriority( epicsThreadGetIdSelf(), threadPrio);
	return dummy;
}


/** @brief configure function
 *
 * The configure function is called from the startup script
 */
int adcPiConfigure (int cardNumber, unsigned int i2cAddress)
{
	// long status;
	// volatile void* baseAddress;
	// char id[6];
	adcPiCard **pCard;
	
	/** @brief Check card number for sanity */
	if (cardNumber != 1) {
		fprintf (stderr, "adcPiConfigure: cardNumber %d must be 1\n", cardNumber);
		return S_dev_noDevice;
	}
	
	/** @brief Find end of card list and check for duplicates */
	for (pCard = &firstCard; *pCard; pCard=&(*pCard)->next) {
		if ((*pCard)->cardNumber == cardNumber) {
			fprintf (stderr, "adcPiConfigure: cardnumber %d already in use\n", cardNumber);
			return S_dev_identifyOverlap;
		}
	} // pCard points to the end of the list


    /** @brief Check address for sanity
     *
     * We use /dev/i2c-1, should be fixed/solved, so a "1" should be used*/
	if (i2cAddress != 1) {
		fprintf (stderr, "adcPiConfigure: i2cAddress %d must be 1\n", i2cAddress);
		return S_dev_noDevice;
	}

	// check VMEaddress for sanity
	
	// translate address to local address, check for overlap
	
	// check that correct hardware is installed, devReadProbe
	// read i2c?
	
	/** @brief create new card structure
	 *
	 */
	 *pCard = malloc (sizeof(adcPiCard));
	 if (!*pCard) {
		 fprintf (stderr, "adcPiConfigure: out of memory\n");
		 return S_dev_noMemory;
	 }
	 
	 (*pCard)->fh = open("/dev/i2c-1", O_RDWR); // "1" hardcoded!
	 if ((*pCard)->fh <= 0) {
		fprintf (stderr, "adcPiConfigure: could not open /dev/i2c-1\n");
		return S_dev_noDevice;
	}

	(*pCard)->magic = MYMAGIC;
	(*pCard)->next = NULL;
	(*pCard)->cardNumber = cardNumber;
	(*pCard)->i2cAddress = i2cAddress;
	
	return 0;
}

adcPiCard* adcPiOpen (int cardNumber)
{
	adcPiCard* card;
	for (card = firstCard; card; card=card->next)
		if (card->cardNumber == cardNumber) return card;
	return NULL;
}

int adcPiGet (adcPiCard* card, int signal, epicsUInt16* pValue)
{
	
	if (adcPiDebug>1)
		printf("adcPiGet card %d signal %d (adcPiDebug: %d)\n",
		  card->cardNumber, signal, adcPiDebug);
	
	if (!card) return S_dev_noDevice;
	if (card->magic != MYMAGIC) return S_dev_wrongDevice;
		
	if (signal < 0 || signal > ADC_PI_MAX_CHANNEL) return S_dev_badSignalNumber;
		
	*pValue = getAdc(card, signal);
	
	if (adcPiDebug>1)
		printf("adcPiGet card %d signal %d @%p = 0x%4X\n",
		  card->cardNumber, signal, (void *)&getAdc, (epicsUInt16)*pValue);
	return 0;
}

/** @brief report function
 *
 */
static long adcPiReport (int detail)
{
	adcPiCard *card;
	for (card = firstCard; card; card = card->next) {
		printf ("  card %d at address %p \n", card->cardNumber, card->baseAddress);
		if (detail >= 1) {
			int signal;
			unsigned short value;
			for (signal = 0; signal < ADC_PI_MAX_CHANNEL; signal++) {
				value = getAdc(card, signal);
				printf("     ADC %d = 0x%04x = %+8.4f V\n", signal, value, value * 0.000154); // tobedef
			}
		}
	}
	return 0;
}




static const iocshArg adcPiConfigureArg0 = { "cardNumber", iocshArgInt };
static const iocshArg adcPiConfigureArg1 = { "i2cAddress", iocshArgInt };

static const iocshArg * const adcPiConfigureArgs[] = {
	&adcPiConfigureArg0,
	&adcPiConfigureArg1
};
static const iocshFuncDef adcPiConfigureDef = { "adcPiConfigure", 2, adcPiConfigureArgs };
static void adcPiConfigureFunc (const iocshArgBuf *args)
{
	adcPiConfigure (args[0].ival, args[1].ival);
}

static void adcPiRegister ()
{
	iocshRegister (&adcPiConfigureDef, adcPiConfigureFunc);
}

epicsExportRegistrar (adcPiRegister);