apps/hello/hello.c

Go to the documentation of this file.

#include <stdio.h>
//
#include <sys/socket.h>
#include <netinet/in.h>


#include <sys/ioctl.h>
#include <fcntl.h>
#include <stdio.h>
#include <stdlib.h>
#include <ctype.h>
#include <errno.h>
#include <unistd.h>
#include <string.h>

//#include <asm/cmoscama.h>
#include <asm/elphel/c313a.h>

static int dfd;
#if 0
static unsigned long ishad;
#endif

static char * usage = "rev R1_0_2\n"
                        "Usage: hello \n-r\n-w addr(0..f) data (0..ffffffff)\n" \
                        "-sr RA - read abstract sensor register\n"\
                        "-sr    - read all 64 abstract sensor registers\n"\
                        "-sw RA RD - write abstract sensor register\n"\
                        "-it delays - set delays for i2c (!=0) low byte - SCL high, byte1 - SCL low,\n"\
                        "                                 byte2 - salve->master, byte3 master->slave\n"\
                        "-ir BUS SA RA - read i2c register RA from slave SA bus number BUS\n"\
                        "-iw BUS SA RA DATA - write i2c register on BUS, slave address SA, register RA data DATA\n"\
                        "-ir - read all relevant i2c registers from slave 0x60/0x66\n"\
                        "-iw - write all relevant i2c registers from slave 0x60/0x66\n"\
                        "-IR SA RA - read 16-bit i2c register RA from slave SA bus number 0\n"\
                        "-IW SA RA DATA - write 16-bit i2c register on bus 0, slave address SA, register RA data DATA\n"\
                        "-IR - read all relevant 16-bit i2c registers from slave 0xba\n"\
                        "-ds INDEX - read DMA descriptors as long words (4/descriptor)\n"\
                        "-db INDEX - read DMA buffer\n"\
                        "-xs - reset zr32112, start exposure (will remove MRST also)\n"\
                        "-xe - end exposure, start DMA\n"\
                        "-xx - stop DMA\n"\
                        "-x - stop DMA/start exposure/wait keypress/end exposure\n"\
                        " -nr address number_of_words - read data from KAI11000 board\n"\
                        " -nw address {data1...dataN} - write data to KAI11000 board\n"\
                        " -mi init (reset on-off) MCP board, write sync table\n"\
                        " -mr address number_of_words - read data from MCP board\n"\
                        " -mw address {data1...dataN} - write data to MCP board\n"\
                        " -md program demo sequence\n"\
                        " -ml loop reenabling external sync till <cntrl-C>\n"\
                        " -Mi (userspace processing) init (reset on-off) MCP board, write sync table\n"\
                        " -Mr (userspace processing) address number_of_words - read data from MCP board\n"\
                        " -Mw (userspace processing) address {data1...dataN} - write data to MCP board\n"\
                        " -Md (userspace processing) program demo sequence\n"\
                        " -Ml (userspace processing) loop reenabling external sync till <cntrl-C>\n"\
                        " -z exposure - set exposure time, start waiting for xtrn (0-stop)\n"\
                        " -z - return camera sequencer status:\n"\
                        "    0- stopped, 1(5ms),2 - waiting trig, 3 -exposure, 4 - readout,6 - done)\n"\
                        " -c bit(0..1f of CR) op(0 -nop, 1 - clr, 2 - set, 3 - toggle)\n"\
                        " -req_io - return present of IO exctension board: 0 - not found, 1 - found\n";



# if 0

void    initMCP(void) {// should be open O_RDWR - make sure external reset is off

  int i;
  ishad = (unsigned long) ioctl(dfd, _IO(CMOSCAM_IOCTYPE, IO_CCAM_CR_SHADOW), NULL);
  if ((ishad & 0x4000) == 0) { // reset was on
    i=ioctl(dfd, _IO(CMOSCAM_IOCTYPE, IO_CSP0W (1) ), (ishad = ((ishad & MCPOtherBits) | MCPReset)));
    i=ioctl(dfd, _IO(CMOSCAM_IOCTYPE, IO_CSP0W (1) ), (ishad = ((ishad & MCPOtherBits) | MCPNoReset)));
  }

}

void    resetMCP(void) {

  int i;
  ishad = (unsigned long) ioctl(dfd, _IO(CMOSCAM_IOCTYPE, IO_CCAM_CR_SHADOW), NULL);
  i=ioctl(dfd, _IO(CMOSCAM_IOCTYPE, IO_CSP0W (1) ), (ishad = ((ishad & MCPOtherBits) | MCPReset)));
  i=ioctl(dfd, _IO(CMOSCAM_IOCTYPE, IO_CSP0W (1) ), (ishad = ((ishad & MCPOtherBits) | MCPNoReset)));

}


void    MCPSendDibit(int dibit) {
        // 0- "start", 1 - "0", 2 - "1", 3 - "act"

  int i;
  if (dibit & 2) i=ioctl(dfd, _IO(CMOSCAM_IOCTYPE, IO_CSP0W (1) ), (ishad ^= MCPToggleB) );
  else           i=ioctl(dfd, _IO(CMOSCAM_IOCTYPE, IO_CSP0W (1) ), (ishad ^= MCPToggleA) );
  if (dibit & 1) i=ioctl(dfd, _IO(CMOSCAM_IOCTYPE, IO_CSP0W (1) ), (ishad ^= MCPToggleB) );
  else           i=ioctl(dfd, _IO(CMOSCAM_IOCTYPE, IO_CSP0W (1) ), (ishad ^= MCPToggleA) );

}

int     MCPSendGetDibit(int dibit) {
        // 0- "start", 1 - "0", 2 - "1", 3 - "act" - returns dibit read
  int i,d;

//  int ii;
 
//  ii = ioctl(dfd, _IO(CMOSCAM_IOCTYPE, IO_CSP0R(1)), NULL);
//  printf("dibit:  %x ",ii);
  d = (ioctl(dfd, _IO(CMOSCAM_IOCTYPE, IO_CSP0R(1)), NULL) >>2) & 1;

 
  if (dibit & 2) i=ioctl(dfd, _IO(CMOSCAM_IOCTYPE, IO_CSP0W (1) ), (ishad ^= MCPToggleB) );
  else           i=ioctl(dfd, _IO(CMOSCAM_IOCTYPE, IO_CSP0W (1) ), (ishad ^= MCPToggleA) );

//  ii = ioctl(dfd, _IO(CMOSCAM_IOCTYPE, IO_CSP0R(1)), NULL);
//  printf("%x\r\n",ii);


  d |= (ioctl(dfd, _IO(CMOSCAM_IOCTYPE, IO_CSP0R(1)), NULL) >>1) & 2;

  if (dibit & 1) i=ioctl(dfd, _IO(CMOSCAM_IOCTYPE, IO_CSP0W (1) ), (ishad ^= MCPToggleB) );
  else           i=ioctl(dfd, _IO(CMOSCAM_IOCTYPE, IO_CSP0W (1) ), (ishad ^= MCPToggleA) );
  return d;
 return dibit;
}

int MCPSendA (int wnr, int a) { // wnr 0 - read, 1 - write
  int   d;
  initMCP();
  MCPSendDibit(0);      // start
  d=MCPSendGetDibit((wnr & 1)+1);       // "0" - read, "1" - write
// later - check "in control" here...
  do { // at least one 0/1 should be sent
     MCPSendDibit((a & 1)+1);
     a = (a >> 1);
//     printf ("a= %x\r\n",a);
  } while (a);
  if (wnr) MCPSendDibit(3);     // act
  return d;
}

void MCPWriteD (int d) {
  while (d) {
     MCPSendDibit((d & 1)+1);
     d = (d >> 1);
  }
  MCPSendDibit(3);      // act
}

int MCPReadD (void) { // will always read 12 bit data
  int d;
  MCPSendDibit(3);      // act
  d  = MCPSendGetDibit(1); // while sending 0
  d |= MCPSendGetDibit(1) <<  2; 
  d |= MCPSendGetDibit(1) <<  4; 
  d |= MCPSendGetDibit(1) <<  6; 
  d |= MCPSendGetDibit(1) <<  8; 
  d |= MCPSendGetDibit(1) << 10; 
  return d;
}

void MCPWriteSyncTab(void) { // write 256x4 sync table
  int   i,d;
  MCPSendA(1,MCPwrsynctb);      // synctab
  for (i=0;i<256;i++) {
    d=-1;
/*
    if      ((i & 0b11111111) == 0b11111111) d = 0b0000;
    else if ((i & 0b11111111) == 0b00000000) d = 0b1000;
    else if ((i & 0b00000011) == 0b00000010) d = 0b0001;
    else if ((i & 0b00000011) == 0b00000001) d = 0b1001;
    else if ((i & 0b00000111) == 0b00000100) d = 0b0010;
    else if ((i & 0b00000111) == 0b00000011) d = 0b1010;
    else if ((i & 0b00001111) == 0b00001000) d = 0b0011;
    else if ((i & 0b00001111) == 0b00000111) d = 0b1011;
    else if ((i & 0b00011111) == 0b00010000) d = 0b0100;
    else if ((i & 0b00011111) == 0b00001111) d = 0b1100;
    else if ((i & 0b00111111) == 0b00100000) d = 0b0101;
    else if ((i & 0b00111111) == 0b00011111) d = 0b1101;
    else if ((i & 0b01111111) == 0b01000000) d = 0b0110;
    else if ((i & 0b01111111) == 0b00111111) d = 0b1110;
    else if ((i & 0b11111111) == 0b10000000) d = 0b0111;
    else if ((i & 0b11111111) == 0b01111111) d = 0b1111;
*/
    if      ((i & 0xff) == 0xff) d = 0x0;
    else if ((i & 0xff) == 0x00) d = 0x8;
    else if ((i & 0x03) == 0x02) d = 0x1;
    else if ((i & 0x03) == 0x01) d = 0x9;
    else if ((i & 0x07) == 0x04) d = 0x2;
    else if ((i & 0x07) == 0x03) d = 0xa;
    else if ((i & 0x0f) == 0x08) d = 0x3;
    else if ((i & 0x0f) == 0x07) d = 0xb;
    else if ((i & 0x1f) == 0x10) d = 0x4;
    else if ((i & 0x1f) == 0x0f) d = 0xc;
    else if ((i & 0x3f) == 0x20) d = 0x5;
    else if ((i & 0x3f) == 0x1f) d = 0xd;
    else if ((i & 0x7f) == 0x40) d = 0x6;
    else if ((i & 0x7f) == 0x3f) d = 0xe;
    else if ((i & 0xff) == 0x80) d = 0x7;
    else if ((i & 0xff) == 0x7f) d = 0xf;

    if (d<0) {printf ("incomplete case in MCPWriteSyncTab\r\n");return;}
    MCPWriteD (d);
    printf("%1x",d); if ((i & 0x1f) == 0x1f) printf ("\r\n");
  }
}


void MCPDemoSequencer(void) { // program some demo/reasonable sequencer parameters
/* 2-pulse sequence:
    1-st pulse - delay 0, duration 10
    2-nd pulse - delay 1000, duration 10000
*/ 
    MCPSendA(1,MCPwrseq);       // sequencer table
    MCPWriteD (  0x09);         // first word - ON-OFF-NOP-NOP
    MCPWriteD (0x0018);         // delay after first word (in 40-ns steps) up to 15 bits+ "extend" bit =16bits
    MCPWriteD (  0x04);         // second word - NOP-ON-NOP-NOP
    MCPWriteD (0x00f9);         // delay after second word
    MCPWriteD (  0x38);         // third word - NOP-OFF-END-NOP

// program sync delay mask (to prevent "glitches" - needs adjustment?
    MCPSendA(1,MCPwrsmsk);      //
    MCPWriteD (  0x2);          // 4-step 0..3

// write "on" support period
    MCPSendA(1,MCPwrsup);       //
    MCPWriteD (  0x1);          // 4-step 0..3

// set all minimal delays
    MCPSendA(1,MCPwrdlys);      //
    MCPWriteD (  0x0);
    MCPWriteD (  0x0);
    MCPWriteD (  0x0);
    MCPWriteD (  0x0);
    MCPWriteD (  0x0);
    MCPWriteD (  0x0);
    MCPWriteD (  0x0);
    MCPWriteD (  0x0);
// program inverter
    MCPSendA(1,MCPwinv);        //
    MCPWriteD (  0x1000);       // wait 200usec
    MCPWriteD (  0x4048);       // 1-st transistor on for 3.6usec
    MCPWriteD (  0x8048);       // 2-nd transistor on for 3.6usec
    MCPWriteD (  0xc000);       // restart sequence
// turn it on
    MCPSendA(1,MCPwinvctl);     //
    MCPWriteD ( 4);             // always on (to resetting after trigger)

// that's all for now...  
        

}
#endif

int main (int argc, char *argv[]) {
#define zr_init_size 72
        short MCP_buf[MCP_W_size+MCP_R_size];
/*     unsigned int zr_inits[zr_init_size]= \
        {0x0100, // |0x80 - test ramp, |0x01 - video
         0x0203,0x0303,0x0400,0x0500,0x0600,0x0700,0x08a1,
         0x0981,0x1204,0x13fe,0x1400,0x1500,0x1600,
         0x2080,0x2100,0x2200,
         0x8001,0x8100,0x820a,0x830c,
         0x8602,0x871f,0x8801,0x8907,
         0x8a1f,0x8b0c,0x8c03,0x8d1f,
         0x8e08,0x8f1f,0x900a,0x9111,   
         0x9208,0x931f,0x9406,0x950a,   
         0x961f,0x9701,0x980f,0x9900,   
         0x9a1f,0x9b02,0x9c0f,0x9f07,   
         0xa01f,0xa101,0xa20a,0xa30f,   
         0xa417,0xa500,0xa61f,0xa70f,   
         0xa80a,0xa90f,0xaa17,0xab02,   
         0xac1f,0xad07,0xae00,0xaf03,   
         0xb017,0xb30c,0xb41f,0xb500,   
         0xb600,0xb700,0xb800,0xb900,   
         0xba00,0xbb00,0xbc01      };   

*/      

//    char c;
 
    char * cp;
        int i,j;
        int devfd;
//      unsigned long data[5];
//      int     sdata[5];
//      unsigned long *data= (unsigned long *) &sdata[0];

        unsigned long a,d, bus, sa, ra, rd;
//      unsigned long t1,t2;
//      int mcpd;
        int mcpa;
        if (argc<2) {printf(usage); return 0;}
        if (argv[1][0] != '-'){printf(usage); return 0;}

//#if 0
        if(strstr(argv[1], "-req_io")) {
                int io_present = 0;
                devfd = open("/dev/ccami2c", O_RDONLY);
                io_present = ioctl(devfd, _IO(CMOSCAM_IOCTYPE, IO_EXT_BOARD_PRESENT), 0);
                close(devfd);
                if(io_present == 0)
                        printf("0\n");
                else
                        printf("1\n");
                return 0;
        }
        if (argv[1][1] == 'n') { // MCP control - new, using read/write file
          if ((argv[1][2] == 'r') || (argv[1][2] == 'R')) { // MCP read registers "-MR address number_of_words"
            if (argc<3) {printf(" should be -nr address {number_of_words}\r\n");return 0;}
            mcpa= strtol (argv[2],&cp,16);
            if ((dfd = open("/dev/sensorfpgacomm", O_RDONLY))<0) {printf("open sensorfpgacomm returned %d\r\n",dfd); return -1;};

            i=1;
            if (argc>3) i=strtol (argv[3],&cp,16);
                j=lseek(dfd,mcpa<<1,0);
                if (j<0) return j;
                j=read(dfd,&MCP_buf[mcpa],i<<1);
                printf("read returned %d\r\n",j);
                if (j<0) return j;
                i=j>>1;
            for (j=0;j<i;j++) {
              if ((j & 7) == 0) {
                if (j > 0) printf ("\r\n");
                printf("%3x: ",mcpa+j);
              } else printf (" ");
              printf("%3x",MCP_buf[mcpa+j]);
            }
            printf("\r\n");
            close(dfd);
            return 0;
          }
          if ((argv[1][2] == 'w') || (argv[1][2] == 'W')) { // MCP write registers "-MW address word1..wordN"
            if (argc<3) {printf(" should be -nw address {data1...dataN}\r\n");return 0;}
            mcpa= strtol (argv[2],&cp,16);
                i=mcpa;
                for (j=3;(j<argc) && (i>=0) && (i<MCP_W_size);j++) MCP_buf[i++]= strtol (argv[j],&cp,16);
                i=i-mcpa;       //count
                if (i==0) return 0;     //nothing to write
            if ((dfd = open("/dev/sensorfpgacomm", O_WRONLY))<0) {printf("open sensorfpgacomm returned %d\r\n",dfd); return -1;};
                j=lseek(dfd,mcpa<<1,0);
                if (j<0) return j;
                j=write(dfd,&MCP_buf[mcpa],i<<1);
                printf("write returned %d\r\n",j);
                if (j<0) return j;
                close(dfd);
            return 0;
          }
          printf(" only -nr ,-nw are implemented\r\n");
          return 0;
        }

//#endif

  
#if 0
        if (argv[1][1] == 'M'){ // MCP control - old (ioctl)
          if ((argv[1][2] == 'r') || (argv[1][2] == 'R')) { // MCP read registers "-MR address number_of_words"
            if (argc<3) {printf(" should be -NR address {number_of_words}\r\n");return 0;}
            mcpa= strtol (argv[2],&cp,16);
            dfd = open("/dev/ccam_dma.raw", O_RDWR);
            mcpd= MCPSendA (0, mcpa);
            printf ("Multiprocessor status= %x\r\n",mcpd);
            i=1;
            if (argc>3) i=strtol (argv[3],&cp,16);
            for (j=0;j<i;j++) {
              if ((j & 7) == 0) {
                if (j > 0) printf ("\r\n");
                printf("%3x: ",mcpa+j);
              } else printf (" ");
              mcpd=MCPReadD ();
              printf("%3x",mcpd);
            }
            printf("\r\n");
            close(dfd);
            return 0;
          }
          if ((argv[1][2] == 'w') || (argv[1][2] == 'W')) { // MCP write registers "-MW address word1..wordN"
            if (argc<3) {printf(" should be -NW address {data1...dataN}\r\n");return 0;}
            mcpa= strtol (argv[2],&cp,16);
            dfd = open("/dev/ccam_dma.raw", O_RDWR);
            mcpd= MCPSendA (1, mcpa);
            printf ("Multiprocessor status= %x\r\n",mcpd);
            for (j=3;j<argc;j++) {
              mcpd= strtol (argv[j],&cp,16);
              MCPWriteD (mcpd);
            }
            close(dfd);
            return 0;
          }
          if ((argv[1][2] == 'i') || (argv[1][2] == 'I')) {
            dfd = open("/dev/ccam_dma.raw", O_RDWR);
            resetMCP();
            MCPWriteSyncTab();
            close(dfd);
            return 0;
          }
          if ((argv[1][2] == 'd') || (argv[1][2] == 'D')) {
            dfd = open("/dev/ccam_dma.raw", O_RDWR);
            resetMCP();
            MCPWriteSyncTab();
            MCPDemoSequencer();
            close(dfd);
            return 0;
          }

          if ((argv[1][2] == 'l') || (argv[1][2] == 'L')) {
            printf("Turn off external trigger to exit\r\n");
            dfd = open("/dev/ccam_dma.raw", O_RDWR);
// enable outputs
            mcpd= MCPSendA (1, MCPctlgate+1);
            MCPWriteD (0);
            j=0;
            while (1) {
// enable sequencer
              mcpd= MCPSendA (1, MCPctlseq+1);
              MCPWriteD (0);
// wait sequencer over
              i=1000;
              do {
                mcpd= MCPSendA (0, 0);
                i--;
              } while ((!(MCPReadD () & 0x4)) && (i>0));
              if (i == 0) {
// disable sequencer
                mcpd= MCPSendA (1, MCPctlseq+0);
                MCPWriteD (0);

                if (j==0) printf("No external trigger - it should be running\r\n");
                close(dfd);
                return 0;
              }
              j++;
              
            }

            close(dfd);
            return 0;
          }

          printf(" only -Mr ,-Mw, -Mi, -Md and -Ml are implemented\r\n");
          return 0;
        }
#endif
//      short MCP_buf[MCP_W_size+MCP_R_size];

//#if 0
        if (argv[1][1] == 'm') { // MCP control - new, using read/write file
          if ((argv[1][2] == 'r') || (argv[1][2] == 'R')) { // MCP read registers "-MR address number_of_words"
            if (argc<3) {printf(" should be -nr address {number_of_words}\r\n");return 0;}
            mcpa= strtol (argv[2],&cp,16);
            if ((dfd = open("/dev/ccammcp", O_RDONLY))<0) {printf("open ccammcp returned %d\r\n",dfd); return -1;};

            i=1;
            if (argc>3) i=strtol (argv[3],&cp,16);
                j=lseek(dfd,mcpa<<1,0);
                if (j<0) return j;
                j=read(dfd,&MCP_buf[mcpa],i<<1);
                printf("read returned %d\r\n",j);
                if (j<0) return j;
                i=j>>1;
            for (j=0;j<i;j++) {
              if ((j & 7) == 0) {
                if (j > 0) printf ("\r\n");
                printf("%3x: ",mcpa+j);
              } else printf (" ");
              printf("%3x",MCP_buf[mcpa+j]);
            }
            printf("\r\n");
            close(dfd);
            return 0;
          }


          if ((argv[1][2] == 'w') || (argv[1][2] == 'W')) { // MCP write registers "-MW address word1..wordN"
            if (argc<3) {printf(" should be -nw address {data1...dataN}\r\n");return 0;}
            mcpa= strtol (argv[2],&cp,16);
                i=mcpa;
                for (j=3;(j<argc) && (i>=0) && (i<MCP_W_size);j++) MCP_buf[i++]= strtol (argv[j],&cp,16);
                i=i-mcpa;       //count
                if (i==0) return 0;     //nothing to write
            if ((dfd = open("/dev/ccammcp", O_WRONLY))<0) {printf("open ccammcp returned %d\r\n",dfd); return -1;};
                j=lseek(dfd,mcpa<<1,0);
                if (j<0) return j;
                j=write(dfd,&MCP_buf[mcpa],i<<1);
                printf("write returned %d\r\n",j);
                if (j<0) return j;
                close(dfd);
            return 0;
          }
#if 0


          if ((argv[1][2] == 'i') || (argv[1][2] == 'I')) {
            dfd = open("/dev/ccamrw", O_RDWR);
            resetMCP();
            close(dfd);
            return 0;
          }
          if ((argv[1][2] == 'd') || (argv[1][2] == 'D')) {      // old variant
            dfd = open("/dev/ccam_dma.raw", O_RDWR);
            resetMCP();
            MCPWriteSyncTab();
            MCPDemoSequencer();
            close(dfd);
            return 0;
          }


          if ((argv[1][2] == 'l') || (argv[1][2] == 'L')) {
            printf("Turn off external trigger to exit\r\n");
            dfd = open("/dev/ccam_dma.raw", O_RDWR);
// enable outputs
            mcpd= MCPSendA (1, MCPctlgate+1);
            MCPWriteD (0);
            j=0;
            while (1) {
// enable sequencer
              mcpd= MCPSendA (1, MCPctlseq+1);
              MCPWriteD (0);
// wait sequencer over
              i=1000;
              do {
                mcpd= MCPSendA (0, 0);
                i--;
              } while ((!(MCPReadD () & 0x4)) && (i>0));
              if (i == 0) {
// disable sequencer
                mcpd= MCPSendA (1, MCPctlseq+0);
                MCPWriteD (0);

                if (j==0) printf("No external trigger - it should be running\r\n");
                close(dfd);
                return 0;
              }
              j++;
              
            }

            close(dfd);
            return 0;
          }
#endif
          printf(" only -mr ,-mw, -mi, -md and -ml are implemented\r\n");
          return 0;
        }

//#endif
#if 0

        if ((argv[1][1] == 'r') || (argv[1][1] == 'R')) { // read all ports
          devfd = open("/dev/ccam_dma.raw", O_RDONLY);
          printf ("open returned - %x\r\n",devfd);
          for (i=0;i<4;i++) {
            sdata[i] = ioctl(devfd, _IO(CMOSCAM_IOCTYPE, IO_CSP0R(i)), NULL);
          }
          sdata[4] = (i=ioctl(devfd, _IO(CMOSCAM_IOCTYPE, IO_CCAM_CR_SHADOW), NULL));

          close(devfd);
// could not make ioctl to return 32 bits - all negative become -1
// so I'll throw away bit 30 and use it to return bit 31
           data[4]=(data[4] & 0x3fffffff) |((data[4] & 0x40000000) << 1);
//      return (long ) ((ccam_cr_shadow & 0x3fffffff) | ((ccam_cr_shadow >>1) & 0x40000000));


//        printf ("data[4]= %lx sdata[4]= %lx sdata[4]>>1 =  %lx i/10= %lx i - decimal= %d\r\n",
//                      data[4], sdata[4], sdata[4]>>1, i/10,i);
//
//        printf ("data[4]= %x sdata[4]= %x sdata[4]>>1 = %x\r\n",
//
//                      data[4], sdata[4], sdata[4]>>1);

          printf ("data %lx %lx %lx %lx\nshadow CR %lx\r\n",
                   data[0],
                   data[1],
                   data[2],
                   data[3],
                   data[4]);
          return 0;

        }

        if ((argv[1][1] == 'w') || (argv[1][1] == 'w')) { // write port
          if (argc<4) {printf("Needs more args...\r\n"); return 0;}
          a=(strtol (argv[2],&cp,16) & 0xf);
          d=strtol (argv[3],&cp,16);
          printf ("command arguments got - %lx %lx\r\n", a,  d);
          devfd = open("/dev/ccam_dma.raw", O_WRONLY);
          printf ("open returned - %x\r\n",devfd);
          i=ioctl(devfd, _IO(CMOSCAM_IOCTYPE, IO_CSP0W (a) ), d);
          printf ("ioctl returned - %x\r\n",i);
          close(devfd);
          printf ("devfd closed\r\n");

          return 0;
        }
#endif
        if ((argv[1][1] == 's') || (argv[1][1] == 'S')) { // sensor registers r/w
          if ((argv[1][2] == 'r') || (argv[1][2] == 'R')) {
            if (argc<3) { // dumping all 64 registers
                devfd = open("/dev/ccam_dma.raw", O_RDONLY);
                printf ("open returned - %x\r\n",devfd);
                for (i=0;i<0x40;i++) {
                  if ((i & 0x0f)==0) printf("\r\n%2x:",i);
                  d=ioctl(devfd, _CCCMD( CCAM_RPARS , i ), 0);
                  printf(" %4lx", d);
                }
                printf ("\r\n");
                close(devfd);
                printf ("devfd closed\r\n");
                return 0;
            }
            a= strtol (argv[2],&cp,16);
            devfd = open("/dev/ccam_dma.raw", O_RDONLY);
            printf ("open returned - %x\r\n",devfd);
            d=ioctl(devfd, _CCCMD( CCAM_RPARS , a ), 0);
            printf ("sensor register %lx = %lx\r\n", a,d);
            close(devfd);
            printf ("devfd closed\r\n");
            return 0;

          } else if  ((argv[1][2] == 'w') || (argv[1][2] == 'W')) {
            if (argc<4) {printf("Needs more args...\r\n"); return 0;}
            a= strtol (argv[2],&cp,16);
            d= strtol (argv[3],&cp,16);
            devfd = open("/dev/ccam_dma.raw", O_WRONLY);
            printf ("open returned - %x\r\n",devfd);
            i=ioctl(devfd, _CCCMD( CCAM_WPARS , a ), d);
            printf ("ioctl (%x,%lx,%lx) returned - %x\r\n",devfd, _CCCMD( CCAM_WPARS , a ), d, i);

            close(devfd);
            printf ("devfd closed\r\n");
            return 0;
          }
        }

/* Micron sensor 16-bit i2c accesses */
  
        if (argv[1][1] == 'I') { // i2c operations
          if ((argv[1][2] == 'r') || (argv[1][2] == 'R')) {
            if (argc<3) { // dumping all i2c registers from zoran chip
              devfd = open("/dev/ccam_dma.raw", O_WRONLY);
                j=ioctl(devfd, _CCCMD( CCAM_RPARS , P_SENSOR ), 0);
                printf ("P_SENSOR - %x\r\n",j);
              close(devfd);
                bus=0;
                devfd = open("/dev/ccami2c", O_RDONLY);
                printf ("open returned - %x\r\n",devfd);

// read sensor type
    sa=0xba; //MI1300
    if (j==52) sa=0x90; //maybe will change later to 0xba as other sensors
    j= 256;
    printf("dumping all i2c data from slave address %lx\r\n",sa);

//              for (i=0;i<256;i++) {
                for (i=0;i<j;i++) {
                  if ((i & 0x0f)==0) printf("\r\n%2x:",i);
                  d=ioctl(devfd, _IO(CMOSCAM_IOCTYPE,I2C_16_READREG), I2C_16_READARG ( sa, i));
                  printf(" %4lx", d);
                }
                printf ("\r\n");
                close(devfd);
                printf ("devfd closed\r\n");
                return 0;
            }
            if (argc<4) {printf("Needs more args...\r\n"); return 0;}

            sa= (strtol (argv[2],&cp,16) & 0xff);
            ra= (strtol (argv[3],&cp,16) & 0xff);
            devfd = open("/dev/ccami2c", O_RDONLY);
            printf ("open returned - %x\r\n",devfd);

            d=ioctl(devfd, _IO(CMOSCAM_IOCTYPE,I2C_16_READREG), I2C_16_READARG (sa, ra)) ;
            printf ("i2c 16-bit register = %lx\r\n", d);
            close(devfd);
          printf ("devfd closed\r\n");
            return 0;
          } else if  ((argv[1][2] == 'w') || (argv[1][2] == 'W')) {

            if (argc<5) {printf("Needs more args...\r\n"); return 0;}
            sa= (strtol (argv[2],&cp,16) & 0xff);
            ra= (strtol (argv[3],&cp,16) & 0xff);
            rd= (strtol (argv[4],&cp,16) & 0xffff);
            devfd = open("/dev/ccami2c", O_WRONLY);
            printf ("open returned - %x\r\n",devfd);

            d=ioctl(devfd, _IO(CMOSCAM_IOCTYPE, I2C_16_WRITEREG ),I2C_16_WRITEARG(sa, ra, rd));
            printf ("i2c returned - %lx\r\n",d);//168
            close(devfd);  printf ("devfd closed\r\n");

            return 0;
          } else if  ((argv[1][2] == 't') || (argv[1][2] == 'T')) {
                 rd=0;
                 if (argc>2)    rd= strtol (argv[2],&cp,16);
            devfd = open("/dev/ccami2c", O_RDWR);
            printf ("open returned - %x\r\n",devfd);
            d=ioctl(devfd, _IO(CMOSCAM_IOCTYPE, I2C_DELAYS ), rd);
            printf ("i2c timing is - %lx\r\n",d);//168
            close(devfd);  printf ("devfd closed\r\n");

            return 0;
          } // if  ((argv[1][2] == 'w') ...


/* Zoran/Kodak normal i2c accesses */
  
        } else if (argv[1][1] == 'i') { // i2c operations
          if ((argv[1][2] == 'r') || (argv[1][2] == 'R')) {
            if (argc<3) { // dumping all i2c registers from zoran chip
              devfd = open("/dev/ccam_dma.raw", O_WRONLY);
                j=ioctl(devfd, _CCCMD( CCAM_RPARS , P_SENSOR ), 0);
                printf ("P_SENSOR - %x\r\n",j);
              close(devfd);


                bus=0;
                devfd = open("/dev/ccami2c", O_RDONLY);
                printf ("open returned - %x\r\n",devfd);

// read sensor type
        if ((j!=4) && (j!=5) && (j!=8) && (j!=9)) {
//        if (j >= 32) {
          sa=0x66; // KODAk
          if ((j>=0x24) && (j<0x28)) j=256; //KAC5000
          else j=192; //KAC1310
        } else {
                  sa=0x60; // ZORAN
          j=16;    // length
        }
                printf("dumping all i2c data from slave address %lx\r\n",sa);

//              for (i=0;i<256;i++) {
                for (i=0;i<j;i++) {
                  if ((i & 0x0f)==0) printf("\r\n%2x:",i);
                  d=ioctl(devfd, _IO(CMOSCAM_IOCTYPE,I2C_READREG), I2C_READARG ( bus,  sa, i));
                  printf(" %2lx", d);
                }
                printf ("\r\n");
                close(devfd);
                printf ("devfd closed\r\n");
                return 0;
            }
            if (argc<5) {printf("Needs more args...\r\n"); return 0;}

            bus=(strtol (argv[2],&cp,16) & 0x1);
            sa= (strtol (argv[3],&cp,16) & 0xff);
            ra= (strtol (argv[4],&cp,16) & 0xff);
            devfd = open("/dev/ccami2c", O_RDONLY);
            printf ("open returned - %x\r\n",devfd);

            d=ioctl(devfd, _IO(CMOSCAM_IOCTYPE,I2C_READREG), I2C_READARG (bus, sa, ra)) ;
            printf ("i2c register = %lx\r\n", d);
            close(devfd);
          printf ("devfd closed\r\n");

            return 0;
          } else if  ((argv[1][2] == 'w') || (argv[1][2] == 'W')) {
  
            if (argc<3) { // writing defaults to zoran chip
                printf("initializing zoran/fpga\r\n");
                return 0;
            }

            if (argc<6) {printf("Needs more args...\r\n"); return 0;}
            bus=(strtol (argv[2],&cp,16) & 0x1);
            sa= (strtol (argv[3],&cp,16) & 0xff);
            ra= (strtol (argv[4],&cp,16) & 0xff);
            rd= (strtol (argv[5],&cp,16) & 0xff);
            devfd = open("/dev/ccami2c", O_WRONLY);
            printf ("open returned - %x\r\n",devfd);

            d=ioctl(devfd, _IO(CMOSCAM_IOCTYPE, I2C_WRITEREG ),I2C_WRITEARG(bus, sa, ra, rd));
            printf ("i2c returned - %lx\r\n",d);//168
            close(devfd);  printf ("devfd closed\r\n");

            return 0;
          } else if  ((argv[1][2] == 't') || (argv[1][2] == 'T')) {
                 rd=0;
                 if (argc>2)    rd= strtol (argv[2],&cp,16);
            devfd = open("/dev/ccami2c", O_RDWR);
            printf ("open returned - %x\r\n",devfd);
            d=ioctl(devfd, _IO(CMOSCAM_IOCTYPE, I2C_DELAYS ), rd);
            printf ("i2c timing is - %lx\r\n",d);//168
            close(devfd);  printf ("devfd closed\r\n");

            return 0;
          } // if  ((argv[1][2] == 'w') ...

// #define CCAM_DMA_SIZE 445830
// #define CCAM_DESCR_SIZE (( CCAM_DMA_SIZE >> 14)+1)
#if 0
        } else if ((argv[1][1] == 'd') || (argv[1][1] == 'D')) {
            if ((argv[1][2] == 's') || (argv[1][2] == 'S')) {
              if (argc<3) { // read all
                devfd = open("/dev/ccam_dma.raw", O_RDONLY);
                printf ("open returned - %x\r\n",devfd);
                for (i=0; i< CCAM_DESCR_SIZE; i++) {
                  for (j=0;j<4;j++) sdata[j]= \
                        ioctl(devfd, _IO(CMOSCAM_IOCTYPE, IO_CCAM_MONITOR_DMA_DESCR ), (i<<2)+j);
                  printf ("%2x: %8lx %8lx %8lx %8lx\r\n",i,data[0],data[1],data[2],data[3]);
                }
                close(devfd);  printf ("devfd closed\r\n");
                return 0;
              } else {
                a=(strtol (argv[2],&cp,16));
                devfd = open("/dev/ccam_dma.raw", O_RDONLY);
                printf ("open returned - %x\r\n",devfd);
                d=(unsigned long) ioctl(devfd, _IO(CMOSCAM_IOCTYPE, IO_CCAM_MONITOR_DMA_DESCR ), a);
                printf ("DMA descriptor [%lx:%lx] = %lx\r\n", (a>>2), (a & 3),  d);
                close(devfd);  printf ("devfd closed\r\n");
                return 0;
              }
            }
            if ((argv[1][2] == 'b') || (argv[1][2] == 'B')) {
              if (argc<3) a=0;
              else a=(strtol (argv[2],&cp,16));
              devfd = open("/dev/ccam_dma.raw", O_RDONLY);
              printf ("open returned - %x\r\n",devfd);
              for (i=0; i< 20; i++) {
                for (j=0;j<4;j++) sdata[j]= \
                  ioctl(devfd, _IO(CMOSCAM_IOCTYPE, IO_CCAM_MONITOR_DMA_BUFFER ), a+(i<<2)+j);
                printf ("%6lx: %8lx %8lx %8lx %8lx\r\n",a+(i <<2),data[0],data[1],data[2],data[3]);
              }
              close(devfd);  printf ("devfd closed\r\n");
              return 0;
            }
#endif
        } else if  (argv[1][1] == 'z'){
          if (argc<3) {
              if ((devfd = open("/dev/ccam_dma.raw", O_RDONLY))<=0) return -1; // may use ccam_dma.raw
              printf ("open returned - %x\r\n",devfd);
              i=ioctl(devfd, _IO(CMOSCAM_IOCTYPE, IO_CCAM_MONITOR_SEQ ), 0);
         errno=0;
              j=ioctl(devfd, _IO(CMOSCAM_IOCTYPE, IO_CCAM_MONITOR_SEQ ), 1);
              if (j==-1) j=-errno;
              printf ("Cam-sequencer state - %x,  count= %x\r\n",i,j);
              close(devfd);
              return 0;
          } else {
              j= strtol (argv[2],&cp,16);

              if ((devfd = open("/dev/ccam_dma.raw", O_WRONLY))<=0) return -1; // may use ccam_dma.raw
/*
              printf ("open returned - %x\r\n",devfd);
                  if (j) {
                    ioctl(devfd, _CCCMD(CCAM_WPARS , P_EXPOS ),    j);
                ioctl(devfd, _CCCMD(CCAM_WPARS , P_UPDATE ),   1); // 1 - at once, 2 - later
                i=ioctl(devfd, _IO(CMOSCAM_IOCTYPE, IO_CCAM_SET_EXT_EXPOSURE ), 1);
                  } else
                    i=ioctl(devfd, _IO(CMOSCAM_IOCTYPE, IO_CCAM_SET_EXT_EXPOSURE ), 0);
              printf ("ioctl returned - %x\r\n",i);
*/
              i=ioctl(devfd, _IO(CMOSCAM_IOCTYPE, IO_CCAM_SET_EXT_EXPOSURE ), j);
              close(devfd);
              return 0;
          }
        } else if  (argv[1][1] == 'Z') {
          if (argc<3) {
              if ((devfd = open("/dev/ccam_dma.raw", O_RDONLY))<=0) return -1; // may use ccam_dma.raw
              printf ("open returned - %x\r\n",devfd);
              i=ioctl(devfd, _IO(CMOSCAM_IOCTYPE, IO_CCAM_MONITOR_SEQ ), 0);
              j=ioctl(devfd, _IO(CMOSCAM_IOCTYPE, IO_CCAM_MONITOR_SEQ ), 1);
              printf ("(CLI) Cam-sequencer state - %x,  count= %x\r\n",i,j);
              close(devfd);
              return 0;
          } else {
              j= strtol (argv[2],&cp,16);

              if ((devfd = open("/dev/ccam_dma.raw", O_WRONLY))<=0) return -1; // may use ccam_dma.raw
                  if (j) {
                    ioctl(devfd, _CCCMD(CCAM_WPARS , P_EXPOS ),    j);
                ioctl(devfd, _CCCMD(CCAM_WPARS , P_UPDATE ),   1); // 1 - at once, 2 - later
                i=ioctl(devfd, _IO(CMOSCAM_IOCTYPE, IO_CCAM_SET_EXT_EXPOSURE ), 1);
                  } else
                    i=ioctl(devfd, _IO(CMOSCAM_IOCTYPE, IO_CCAM_SET_EXT_EXPOSURE ), 0);
              i=ioctl(devfd, _IO(CMOSCAM_IOCTYPE, IO_CCAM_SET_EXT_EXPOSURE ), j);
              printf ("ioctl returned - %x\r\n",i);
              close(devfd);
              return 0;
          }
        } else if  ((argv[1][1] == 'c') || (argv[1][1] == 'c')){

          if (argc<3) {printf("Needs more args (bit #, [op])\r\n"); return 0;}
          a=(strtol (argv[2],&cp,16) & 0x1f);
          d=0;
          if (argc>3) d=(strtol (argv[3],&cp,16) & 0x3);
          if ((devfd = open("/dev/ccam_dma.raw", O_RDWR))<0) return -1;
          i=ioctl(devfd, _IO(CMOSCAM_IOCTYPE, IO_CCAM_CR_MODIFY), d | (a<<2));
          j=ioctl(devfd, _IO(CMOSCAM_IOCTYPE, IO_CCAM_CR_MODIFY), 0 | (a<<2));
          printf ("CR[%lx]=%x (was %x)\r\n",a,j,i);
          close(devfd);
          printf ("devfd closed\r\n");

          return 0;


//#define IO_CCAM_SET_EXT_EXPOSURE  0x06 >0 - in 10us, ==0 - stop
//#define IO_CCAM_MONITOR_SEQ       0x07
#if 0
        
        } else if  ((argv[1][1] == 'x') || (argv[1][1] == 'X')) {
              if  (argv[1][1] == 'X')     devfd = open("/dev/ccam_dma.raw", O_WRONLY);
              else devfd = open("/dev/ccam_dma.raw", O_WRONLY);
              printf ("open returned - %x\r\n",devfd);
              switch (argv[1][2]){ // s/e/x
               case ('x'):
               case ('X'):{
                d= (unsigned long) ioctl (devfd, _IO(CMOSCAM_IOCTYPE, IO_CCAM_STOP_DMA ), NULL);
                printf ("Stop DMA returned %lx\r\n", d);
                close(devfd);  printf ("devfd closed\r\n");
                return 0;
               }
               case ('s'):
               case ('S'):{
                d= ioctl (devfd, _IO(CMOSCAM_IOCTYPE, IO_CCAM_EXPOS_START ), NULL);
                printf ("START EXPOSURE returned %lx\r\n", d);
                close(devfd);  printf ("devfd closed\r\n");
                return 0;
               }

               case ('e'):
               case ('E'):{
                d= ioctl (devfd, _IO(CMOSCAM_IOCTYPE, IO_CCAM_EXPOS_END ), NULL);
                printf ("END EXPOSURE returned %lx\r\n", d);
                close(devfd);  printf ("devfd closed\r\n");
                return 0;
               }
               default: {
                printf ("getting picture..\r\n");
                if (argc<3) t1=10000; // 100 msec exposure
                else t1=(strtol (argv[2],&cp,10));
                if (argc<4) t2=1000; // 10 msec pre-erase
                else t2=(strtol (argv[3],&cp,10));
                if (argc<5) a=2; // 10 msec pre-erase
                else a=(strtol (argv[4],&cp,10));
                d= ioctl (devfd, _IO(CMOSCAM_IOCTYPE, IO_CCAM_STOP_DMA ), NULL);

                for (i=0;i<a;i++){
                        d= ioctl (devfd, _IO(CMOSCAM_IOCTYPE, IO_CCAM_EXPOS_START ), t2);
//                      printf ("Stop DMA returned %lx\r\n", d);
                }
//              d= ioctl (devfd, _IO(CMOSCAM_IOCTYPE, IO_CCAM_EXPOS_START ), NULL);
//              printf ("START EXPOSURE returned %lx\r\n", d);
//              printf ("press any key to continue...");
//              c=getchar ();
//              printf ("OK\r\n");
// +            d= ioctl (devfd, _IO(CMOSCAM_IOCTYPE, IO_CCAM_EXPOS_END ), NULL);

//              printf ("_IO(CMOSCAM_IOCTYPE, IO_CCAM_EXPOSE )= %lx\r\n", _IO(CMOSCAM_IOCTYPE, IO_CCAM_EXPOSE ) );

                d= ioctl (devfd, _IO(CMOSCAM_IOCTYPE, IO_CCAM_EXPOSE ), t1);

//              printf ("END EXPOSURE returned %lx\r\n", d);
                close(devfd);  printf ("devfd closed\r\n");
                return 0;

               } // default

              } // switch
#endif

        } // if  ((argv[1][1] == 'x')...

        printf(usage);
        return 0;       
}

---