/**************************************************************************
**
**   pnp.c - support for generic peak and poke functions
**
***************************************************************************
*/

/*--------------------------
**  include files
**--------------------------
*/
#if LINUX
#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <stdlib.h>
#include <stdarg.h>
#else 
#include <common.h>   // uboot general include file
#include <exports.h>   // uboot general include file
#endif

#include "ce.h"

#include "ir.h"
#include "al.h"


#include "h2.h"

#include "pnp.h"


void pnp_print_pg4(char *s, struct pattern_generator_4 *pg4)
{
    int ii = 0;

    printf("Values for PG4 %s:\n", s);
    for (ii = 0; ii < 9; ii++)
        printf("    %04x : %04i\n", pg4->data[ii], pg4->duration[ii]);
    printf("ss: %i\n", pg4->ss);
}

int pnp_start(ce_t *Ce)
{
    ce_go(Ce, 1); // start the clocking engine
    return PASS;
}

int pnp_stop(ce_t *Ce)
{
    ce_go(Ce, 0); // stop the clocking engine
    return PASS;
}

int pnp_shutter_open(ce_t *Ce)
{
    ce_put(Ce, CE_CMD_SHUTTEROPEN);
    return PASS;
}

int pnp_shutter_close(ce_t *Ce)
{
    ce_put(Ce, CE_CMD_SHUTTERCLOS);
    return PASS;
}

int pnp_digio_low(ce_t *Ce, unsigned int value)
{
    ce_put(Ce, CE_PARAM_UPDWR_LO | value);
    ce_put(Ce, CE_CMD_UPDWR);
    return PASS;
}



int pnp_set_ppg4(ce_t *Ce, struct pattern_generator_4 *ppg4)
{
    int ii = 0;
    unsigned short p[8];


    pnp_print_pg4("huh", ppg4);

    printf("\ngrog\n");
    p[0] = ((ppg4->duration[1] << 10) & 0xFC00) | ((ppg4->duration[0]) & 0x03FF);

    printf("%04x\n", ppg4->duration[0]);
    printf("%04x\n", ppg4->duration[1]);
    printf("%04x\n", p[0]);


    p[1] = ((ppg4->duration[3] << 14) & 0xC000) | ((ppg4->duration[2] << 4) & 0x3FF0) | ((ppg4->duration[1] >>6) & 0x000F);
    p[2] = ((ppg4->duration[4] << 8) & 0xFF00) | ((ppg4->duration[3] >> 2) & 0x00FF);
    p[3] = ((ppg4->duration[6] << 12) & 0xF000) | ((ppg4->duration[5] << 2) & 0x0FFC) | ((ppg4->duration[4] >> 8) & 0x0003);
    p[4] = ((ppg4->duration[7] << 6) & 0xFFC0) | ((ppg4->duration[6] >> 4) & 0x003F);
    p[5] = ((ppg4->data[0] << 12) & 0xF000) | ((ppg4->ss << 10) & 0x0C00) | ((ppg4->duration[8] & 0x03FF));

    // p[6] & p[7] are straight 4 bit chunks
    p[6] = ((ppg4->data[1] & 0x000F)) | ((ppg4->data[2] & 0x000F) << 4) |  ((ppg4->data[3] & 0x000F) << 8) | ((ppg4->data[4] & 0x000F) << 12);
    p[7] = ((ppg4->data[5] & 0x000F)) | ((ppg4->data[6] & 0x000F) << 4) |  ((ppg4->data[7] & 0x000F) << 8) | ((ppg4->data[8] & 0x000F) << 12);

    for(ii = 0; ii < 8; ii++)
    {
        printf("%i : %04x\n", ii, p[ii]);
    }

    ce_put(Ce, CE_PARAM_PARSEQ_0 | p[0]);
    ce_put(Ce, CE_PARAM_PARSEQ_1 | p[1]);
    ce_put(Ce, CE_PARAM_PARSEQ_2 | p[2]);
    ce_put(Ce, CE_PARAM_PARSEQ_3 | p[3]);
    ce_put(Ce, CE_PARAM_PARSEQ_4 | p[4]);
    ce_put(Ce, CE_PARAM_PARSEQ_5 | p[5]);
    ce_put(Ce, CE_PARAM_PARSEQ_6 | p[6]);
    ce_put(Ce, CE_PARAM_PARSEQ_7 | p[7]);

    return PASS;
}


int pnp_set_ppg4_value(ce_t *Ce, unsigned int value)
{
    struct pattern_generator_4 pg4;
    unsigned short *ptr;
    int ii = 0;
    unsigned short p[8];

    for(ii = 0; ii < 9; ii++)
        pg4.duration[ii] = 1;

    pg4.ss = 0;
 
    for(ii = 0; ii < 9; ii++)
        pg4.data[ii] = value & 0xF;


    ptr = (unsigned short *)&pg4;

    p[0] = ((pg4.duration[1] << 10) & 0xFC00) | ((pg4.duration[0]) & 0x03FF);
    p[1] = ((pg4.duration[3] << 14) & 0xC000) | ((pg4.duration[2] << 4) & 0x3FF0) | ((pg4.duration[1] >>6) & 0x000F);
    p[2] = ((pg4.duration[4] << 8) & 0xFF00) | ((pg4.duration[3] >> 2) & 0x00FF);
    p[3] = ((pg4.duration[6] << 12) & 0xF000) | ((pg4.duration[5] << 2) & 0x0FFC) | ((pg4.duration[4] >> 8) & 0x0003);
    p[4] = ((pg4.duration[7] << 6) & 0xFFC0) | ((pg4.duration[6] >> 4) & 0x003F);
    p[5] = ((pg4.data[0] << 12) & 0xF000) | ((pg4.ss << 10) & 0x0C00) | ((pg4.duration[8] & 0x03FF));

    // p[6] & p[7] are straight 4 bit chunks
    p[6] = ((pg4.data[1] & 0x000F)) | ((pg4.data[2] & 0x000F) << 4) |  ((pg4.data[3] & 0x000F) << 8) | ((pg4.data[4] & 0x000F) << 12);
    p[7] = ((pg4.data[5] & 0x000F)) | ((pg4.data[6] & 0x000F) << 4) |  ((pg4.data[7] & 0x000F) << 8) | ((pg4.data[8] & 0x000F) << 12);

    for(ii = 0; ii < 8; ii++)
    {
        printf("%i : %04x\n", ii, p[ii]);
    }

    ce_put(Ce, CE_PARAM_PARSEQ_0 | p[0]);
    ce_put(Ce, CE_PARAM_PARSEQ_1 | p[1]);
    ce_put(Ce, CE_PARAM_PARSEQ_2 | p[2]);
    ce_put(Ce, CE_PARAM_PARSEQ_3 | p[3]);
    ce_put(Ce, CE_PARAM_PARSEQ_4 | p[4]);
    ce_put(Ce, CE_PARAM_PARSEQ_5 | p[5]);
    ce_put(Ce, CE_PARAM_PARSEQ_6 | p[6]);
    ce_put(Ce, CE_PARAM_PARSEQ_7 | p[7]);

    return PASS;
}


int pnp_run_ppg4(ce_t *Ce, unsigned int iter)
{
    printf("pnp_run_ppg4(..., %i)\n", iter);
    ce_put(Ce, CE_CMD_PARSEQ | CE_ITER(iter));
    return PASS;
}


int pnp_set_spg4(ce_t *Ce, struct pattern_generator_4 *spg4)
{
    int ii = 0;
    unsigned short p[8];


    pnp_print_pg4("huh", spg4);

    printf("\ngrog\n");
    p[0] = ((spg4->duration[1] << 10) & 0xFC00) | ((spg4->duration[0]) & 0x03FF);

    printf("%04x\n", spg4->duration[0]);
    printf("%04x\n", spg4->duration[1]);
    printf("%04x\n", p[0]);


    p[1] = ((spg4->duration[3] << 14) & 0xC000) | ((spg4->duration[2] << 4) & 0x3FF0) | ((spg4->duration[1] >>6) & 0x000F);
    p[2] = ((spg4->duration[4] << 8) & 0xFF00) | ((spg4->duration[3] >> 2) & 0x00FF);
    p[3] = ((spg4->duration[6] << 12) & 0xF000) | ((spg4->duration[5] << 2) & 0x0FFC) | ((spg4->duration[4] >> 8) & 0x0003);
    p[4] = ((spg4->duration[7] << 6) & 0xFFC0) | ((spg4->duration[6] >> 4) & 0x003F);
    p[5] = ((spg4->data[0] << 12) & 0xF000) | ((spg4->ss << 10) & 0x0C00) | ((spg4->duration[8] & 0x03FF));

    // p[6] & p[7] are straight 4 bit chunks
    p[6] = ((spg4->data[1] & 0x000F)) | ((spg4->data[2] & 0x000F) << 4) |  ((spg4->data[3] & 0x000F) << 8) | ((spg4->data[4] & 0x000F) << 12);
    p[7] = ((spg4->data[5] & 0x000F)) | ((spg4->data[6] & 0x000F) << 4) |  ((spg4->data[7] & 0x000F) << 8) | ((spg4->data[8] & 0x000F) << 12);

    for(ii = 0; ii < 8; ii++)
    {
        printf("%i : %04x\n", ii, p[ii]);
    }

    ce_put(Ce, CE_PARAM_VIDSEQ_PG4_0 | p[0]);
    ce_put(Ce, CE_PARAM_VIDSEQ_PG4_1 | p[1]);
    ce_put(Ce, CE_PARAM_VIDSEQ_PG4_2 | p[2]);
    ce_put(Ce, CE_PARAM_VIDSEQ_PG4_3 | p[3]);
    ce_put(Ce, CE_PARAM_VIDSEQ_PG4_4 | p[4]);
    ce_put(Ce, CE_PARAM_VIDSEQ_PG4_5 | p[5]);
    ce_put(Ce, CE_PARAM_VIDSEQ_PG4_6 | p[6]);
    ce_put(Ce, CE_PARAM_VIDSEQ_PG4_7 | p[7]);

    return PASS;
}



int pnp_set_spg4_value(ce_t *Ce, unsigned int value)
{    
    struct pattern_generator_4 pg4;
    unsigned short *ptr;
    int ii = 0;
    unsigned short p[8];

    for(ii = 0; ii < 9; ii++)
        pg4.duration[ii] = 1;

    pg4.ss = 0;

    for(ii = 0; ii < 9; ii++)
        pg4.data[ii] = value & 0xF;

    ptr = (unsigned short *)&pg4;

    p[0] = ((pg4.duration[1] << 10) & 0xFC00) | ((pg4.duration[0]) & 0x03FF);
    p[1] = ((pg4.duration[3] << 14) & 0xC000) | ((pg4.duration[2] << 4) & 0x3FF0) | ((pg4.duration[1] >>6) & 0x000F);
    p[2] = ((pg4.duration[4] << 8) & 0xFF00) | ((pg4.duration[3] >> 2) & 0x00FF);
    p[3] = ((pg4.duration[6] << 12) & 0xF000) | ((pg4.duration[5] << 2) & 0x0FFC) | ((pg4.duration[4] >> 8) & 0x0003);
    p[4] = ((pg4.duration[7] << 6) & 0xFFC0) | ((pg4.duration[6] >> 4) & 0x003F);
    p[5] = ((pg4.data[0] << 12) & 0xF000) | ((pg4.ss << 10) & 0x0C00) | ((pg4.duration[8] & 0x03FF));

    // p[6] & p[7] are straight 4 bit chunks
    p[6] = ((pg4.data[1] & 0x000F)) | ((pg4.data[2] & 0x000F) << 4) |  ((pg4.data[3] & 0x000F) << 8) | ((pg4.data[4] & 0x000F) << 12);
    p[7] = ((pg4.data[5] & 0x000F)) | ((pg4.data[6] & 0x000F) << 4) |  ((pg4.data[7] & 0x000F) << 8) | ((pg4.data[8] & 0x000F) << 12);


    for(ii = 0; ii < 8; ii++)
    {
        printf("%i : %04x\n", ii, p[ii]);
    }

    ce_put(Ce, CE_PARAM_VIDSEQ_PG4_0| p[0]);
    ce_put(Ce, CE_PARAM_VIDSEQ_PG4_1 | p[1]);
    ce_put(Ce, CE_PARAM_VIDSEQ_PG4_2 | p[2]);
    ce_put(Ce, CE_PARAM_VIDSEQ_PG4_3 | p[3]);
    ce_put(Ce, CE_PARAM_VIDSEQ_PG4_4 | p[4]);
    ce_put(Ce, CE_PARAM_VIDSEQ_PG4_5 | p[5]);
    ce_put(Ce, CE_PARAM_VIDSEQ_PG4_6 | p[6]);
    ce_put(Ce, CE_PARAM_VIDSEQ_PG4_7 | p[7]);

    return PASS;
}



int pnp_set_spg3(ce_t *Ce, struct pattern_generator_3 *pg3)
{
    int ii = 0;
    unsigned short p[8];



    p[0] = ((pg3->duration[1] << 10) & 0xFC00) | ((pg3->duration[0]) & 0x03FF);
    p[1] = ((pg3->duration[3] << 14) & 0xC000) | ((pg3->duration[2] << 4) & 0x3FF0) | ((pg3->duration[1] >>6) & 0x000F);
    p[2] = ((pg3->duration[4] << 8) & 0xFF00) | ((pg3->duration[3] >> 2) & 0x00FF);
    p[3] = ((pg3->duration[6] << 12) & 0xF000) | ((pg3->duration[5] << 2) & 0x0FFC) | ((pg3->duration[4] >> 8) & 0x0003);
    p[4] = ((pg3->duration[7] << 6) & 0xFFC0) | ((pg3->duration[6] >> 4) & 0x003F);
    p[5] = ((pg3->repeat << 10) & 0xFC00) | ((pg3->duration[8] & 0x03FF));

    p[6] = ((pg3->data[5] << 15) & 0x8000) | ((pg3->data[4] << 12) & 0x7000) | ((pg3->data[3] << 9) & 0x0E00) | ((pg3->data[2] << 6) & 0x01C0) | ((pg3->data[1] << 3) & 0x0038) | ((pg3->data[0]) & 0x0007);

    p[7] = ((pg3->data[8] << 8) & 0x0700) | ((pg3->data[7] << 5) & 0x00E0) | ((pg3->data[6] << 2) & 0x001C) | ((pg3->data[5] >> 1) & 0x0001);

    for(ii = 0; ii < 8; ii++)
    {
        printf("%i : %03x\n", ii, p[ii]);
    }

    ce_put(Ce, CE_PARAM_VIDSEQ_PG3_0| p[0]);
    ce_put(Ce, CE_PARAM_VIDSEQ_PG3_1 | p[1]);
    ce_put(Ce, CE_PARAM_VIDSEQ_PG3_2 | p[2]);
    ce_put(Ce, CE_PARAM_VIDSEQ_PG3_3 | p[3]);
    ce_put(Ce, CE_PARAM_VIDSEQ_PG3_4 | p[4]);
    ce_put(Ce, CE_PARAM_VIDSEQ_PG3_5 | p[5]);
    ce_put(Ce, CE_PARAM_VIDSEQ_PG3_6 | p[6]);
    ce_put(Ce, CE_PARAM_VIDSEQ_PG3_7 | p[7]);

    return PASS;
}

int pnp_run_spg(ce_t *Ce, unsigned int iter)
{
    printf("pnp_run_spg(..., %i)\n", iter);
    ce_put(Ce, CE_CMD_VIDSEQ | CE_ITER(iter));
    return PASS;
}