os/linux-2.6-tag--devboard-R2_10-4/arch/cris/arch-v32/drivers/elphel/fpgaconfi2c.c

Go to the documentation of this file.

/*!***************************************************************************
fpgaconfi2c.c
*/

/****************** INCLUDE FILES SECTION ***********************************/

#include <linux/module.h>
#include <linux/sched.h>
#include <linux/slab.h>
#include <linux/errno.h>
#include <linux/kernel.h>
#include <linux/fs.h>
#include <linux/string.h>
#include <linux/init.h>
#include <linux/autoconf.h>

#include <asm/system.h>
#include <asm/svinto.h>
#include <asm/io.h>

#include <asm/irq.h>



#include <asm/delay.h>
#include <asm/uaccess.h>
#include <asm/fpgaconfa.h>

#include "fpgaconf.h"
#include "fpgaconfi2c.h"

#define D(x)

/****************** I2C DEFINITION SECTION *************************/
#define XCLOCK_LOW_TIME            8
#define XCLOCK_HIGH_TIME           8
#define XSTART_CONDITION_HOLD_TIME 8
#define XSTOP_CONDITION_HOLD_TIME  8
#define XENABLE_OUTPUT             0x01
#define XENABLE_INPUT              0x00
#define XI2C_CLOCK_HIGH            1
#define XI2C_CLOCK_LOW             0
#define XI2C_DATA_HIGH             1
#define XI2C_DATA_LOW              0
/*
port A:
 0 - TDO  (in)
 1 - TDI  (out)
 2 - TMS  (out)
 3 - TCK  (out)
 4 - INIT (i/o)
 5 - DONE (in)
 6 - NU
 7 - PGM  (out)

port B:
 0 - I2C SDA
 1 - I2C SCL
 2-7 - NU
*/
/* use the kernel delay routine */

#define xi2c_delay(usecs) udelay(usecs)

int xi2c_diagnose(void);
int     xi2c_start(void);
void xi2c_stop(void);
int xi2c_outbyte(unsigned char d);
unsigned char xi2c_inbyte(void);

void xi2c_sendack(void);
int setCYField (int addr, int mask, int value);


static unsigned long portb_shadow=0x0000fe03;  // only i2c uses port B
void initPortB(void) {
  *R_PORT_PB_SET=portb_shadow;
}

/* I2C functions */

#define  xi2c_disable *R_PORT_PB_SET=(portb_shadow  = 0x0203)
#define  xi2c_dir_out *R_PORT_PB_SET=(portb_shadow  = 0x0303)
#define  xi2c_dir_in  *R_PORT_PB_SET=(portb_shadow  = 0x0203)
#define  xi2c_scl_0   *R_PORT_PB_SET=(portb_shadow &= 0x0301)
#define  xi2c_scl_1   *R_PORT_PB_SET=(portb_shadow |= 0x0002)
#define  xi2c_sda(x)  *R_PORT_PB_SET=(portb_shadow = (portb_shadow & 0x0002) | 0x0300 | ((x)? 1:0));
#define  xi2c_getbit  (*R_PORT_PB_READ & 1)
#define  xi2c_getscl  ((*R_PORT_PB_READ >>1) & 1)

/* diagnose i2c bus problems. Will always return non-zero
Normally is called from xi2c_start, if it detects problem  */
int xi2c_diagnose(void) {
        int error=0;
  D(printk("xi2c_diagnose\r\n"));

        while (!error) {
                xi2c_dir_out;   // will force high SCL, SDA
                xi2c_delay(XCLOCK_HIGH_TIME);
                if (!xi2c_getbit) error |= ERR_I2C_SDA_ST0;
                if (!xi2c_getscl) error |= ERR_I2C_SCL_ST0;
                if (error) break;
                xi2c_scl_0;
                xi2c_sda (0);
                xi2c_delay(XCLOCK_LOW_TIME);
                if (!xi2c_getbit) error |= ERR_I2C_SDA_ST0;
                if (!xi2c_getscl) error |= ERR_I2C_SCL_ST0;
                if (error) break;
                xi2c_disable; // first disables, then sets high
                xi2c_delay(XCLOCK_HIGH_TIME*2);
                if (!xi2c_getbit) error |= ERR_I2C_SDA_NOPULLUP;
                if (!xi2c_getscl) error |= ERR_I2C_SCL_NOPULLUP;
                if (error) break;
                xi2c_sda(0);    // scl will be left disabled (high)
                if (!xi2c_getscl) error |= ERR_I2C_SHORT;
                break;
        }
        if (!error) error =      ERR_I2C_NOTDETECTED;
        /* try start-stop to reset effects of playing with sda/scl lines */
        xi2c_dir_out;   // will force high SCL, SDA
        xi2c_sda (0);
        xi2c_delay(XSTART_CONDITION_HOLD_TIME);
        xi2c_scl_0;
        xi2c_delay(XCLOCK_LOW_TIME*2);
        xi2c_scl_1;
        xi2c_delay(XCLOCK_HIGH_TIME*2);
        xi2c_sda (1);
        xi2c_delay(XSTOP_CONDITION_HOLD_TIME);
        xi2c_disable;

        return error;
}

/* generate i2c start condition and test bus */

int     xi2c_start(void) {
//      int error=0;
        int i;
  D(printk("xi2c_start:\r\n"));
        /* SCL=1 SDA=1 */
        xi2c_dir_out;   // will set high SCL, SDA
        xi2c_delay(XCLOCK_HIGH_TIME/2);
        /* if the periferial (?) driving sda low (after being interrupted)? - try to recover */
        xi2c_dir_in;
        xi2c_delay(XCLOCK_HIGH_TIME/2);
        if (!xi2c_getbit) {
                for (i=0;(i<9) && !xi2c_getbit;i++) {
                        xi2c_scl_0;
                        xi2c_delay(XCLOCK_LOW_TIME);
                        xi2c_scl_1;
                        xi2c_delay(XCLOCK_HIGH_TIME);
                }
                if (!xi2c_getbit) return  xi2c_diagnose(); // did not help - really stuck
                /* it is breathing - try "START"-"STOP" */
                xi2c_sda (0);
                xi2c_delay(XSTART_CONDITION_HOLD_TIME);
                xi2c_scl_0;
                xi2c_delay(XCLOCK_LOW_TIME*2);
                xi2c_scl_1;
                xi2c_delay(XCLOCK_HIGH_TIME*2);
                xi2c_sda (1);
                xi2c_delay(XSTOP_CONDITION_HOLD_TIME);
        }
        /* SCL=1 SDA=1 */
        xi2c_dir_out;   // will set high SCL, SDA
        xi2c_delay(XCLOCK_HIGH_TIME/2);

        if ((!xi2c_getbit) || (!xi2c_getscl)) return  xi2c_diagnose();
        /* SCL=1 SDA=0 */
        xi2c_sda(0);
        xi2c_delay(XSTART_CONDITION_HOLD_TIME);
        if (( xi2c_getbit) || (!xi2c_getscl)) return  xi2c_diagnose();
        /* SCL=0 SDA=0 */
        xi2c_scl_0;
        xi2c_delay(XCLOCK_LOW_TIME);
        if (( xi2c_getbit) || ( xi2c_getscl)) return  xi2c_diagnose();
        return 0;
}

/* generate i2c stop condition */
void xi2c_stop(void) {  // assumed to be enabled
        /* SCL=0 SDA=0  */
  D(printk("xi2c_stop\r\n"));

        xi2c_scl_0;
        xi2c_sda (0);
        xi2c_delay(XCLOCK_LOW_TIME*2);
        /* SCL=1 SDA=0 */
        xi2c_scl_1;
        xi2c_delay(XCLOCK_HIGH_TIME*2);
        /* SCL=1 SDA=1 */
        xi2c_sda (1);
        xi2c_delay(XSTOP_CONDITION_HOLD_TIME);
        xi2c_disable;   // both high with resistor pull-up
}

/* write a byte to the i2c interface , return acknowledge */
int xi2c_outbyte(unsigned char d) { 
        int i;
        unsigned char x=d;      // make it non-destructive
  D(printk("xi2c_outbyte: byte=%x\r\n",  (int) x));

        for (i = 0; i < 8; i++) { // assumed to be with SCL=0;
                xi2c_sda (x & 0x80);    // checks only on non-zero, so no need to '>>'
//portb_shadow
  D(printk("%x ",  (int) portb_shadow));

                xi2c_delay(XCLOCK_LOW_TIME/2);
                xi2c_scl_1;
                xi2c_delay(XCLOCK_HIGH_TIME);
                xi2c_scl_0;
                xi2c_delay(XCLOCK_LOW_TIME/2);
                x <<= 1;
        }
  D(printk("\r\n"));

        /* enable input  */
        xi2c_dir_in;
        xi2c_delay(XCLOCK_LOW_TIME/2);
        xi2c_scl_1;
        xi2c_delay(XCLOCK_HIGH_TIME);
        i= (1-xi2c_getbit);
        xi2c_scl_0;
        xi2c_delay(XCLOCK_LOW_TIME/2);
  D(printk("xi2c_outbyte:  ACK=%x\r\n", i));


        return i;
}

/* read a byte from the i2c interface */

unsigned char xi2c_inbyte(void) { // assumed SCL=0, SDA=X
        unsigned char aBitByte = 0;
        int i;
        /* enable input */
  D(printk("xi2c_inbyte\r\n"));

        xi2c_dir_in;
        /* get bits      */
        for (i = 0; i < 8; i++) {
                xi2c_delay(XCLOCK_LOW_TIME/2);
                /* low clock period      */
                xi2c_scl_1;
                xi2c_delay(XCLOCK_HIGH_TIME);
                aBitByte = (aBitByte << 1) | xi2c_getbit;
                xi2c_scl_0;
                xi2c_delay(XCLOCK_LOW_TIME/2);
        }
  D(printk("xi2c_inbyte:  data=%x\r\n", aBitByte));
        return aBitByte;        // returns with SCL=0, SDA - OFF
}

/*#---------------------------------------------------------------------------
*#
*# FUNCTION NAME: I2C::sendAck
*#
*# DESCRIPTION  : Send ACK on received data
*#
*#--------------------------------------------------------------------------*/
void xi2c_sendack(void) {
         D(printk("xi2c_sendack\r\n"));

                xi2c_sda (0);
                xi2c_delay(XCLOCK_LOW_TIME/2);
                xi2c_scl_1;
                xi2c_delay(XCLOCK_HIGH_TIME);
                xi2c_scl_0;
                xi2c_delay(XCLOCK_LOW_TIME/2);
}

/*#---------------------------------------------------------------------------
*#
*# FUNCTION NAME: fi2c_writeData
*#
*# DESCRIPTION  : Writes a sequence of bytes to an I2C device
*# removed retries, will add test-ready later as a separate function
*# removed all "dummy stuff" - I never needed that
*#
*#--------------------------------------------------------------------------*/
int fi2c_writeData(unsigned char theSlave, unsigned char *theData, int size) {
        int i,error=0;
        /* we don't like to be interrupted      *** WHY??? ***   */
   D(printk("i2c_writeData:  theSlave=%x data=%x %x size=%x\r\n", theSlave, theData[0], theData[1], size));

        /* generate start condition, test bus */
        if ((error=xi2c_start())) return error;
        /* send slave address, wait for ack */
        if(!xi2c_outbyte(theSlave)) {
                 xi2c_stop();
                 return ERR_I2C_BSY;    // device does not exist or not ready
        }
// OK, now send theData verifying ACK goes after each byte
        for (i=0;i<size;i++) {
                if(!xi2c_outbyte(theData[i])) {
                        xi2c_stop();
                        return ERR_I2C_NACK;    // device failure
                }
        }
        xi2c_stop();
        return 0;
}

/*#---------------------------------------------------------------------------
*#
*# FUNCTION NAME: i2c_readData
*#
*# DESCRIPTION  : Reads a data from the i2c device, returns 0- OK, else - error code
*#
*#--------------------------------------------------------------------------*/

int fi2c_readData(unsigned char theSlave, unsigned char *theData, int size) {
        int i, error=0;
        if ((error=xi2c_start())) return error;
        /* send slave address, wait for ack */
   D(printk("i2c_readData:  theSlave=%x size=%x\r\n", theSlave, size));

        if(!xi2c_outbyte(theSlave)) {
                 xi2c_stop();
                 return ERR_I2C_BSY;    // device does not exist or not ready
        }
        for (i=0;i<size;i++) {
                theData[i]=xi2c_inbyte();
                xi2c_sendack();
        }
         xi2c_stop();
         return 0;
        
}


/* Main device API. ioctl's to write or read to/from i2c registers.  */
// for now - single register read/write only
int fi2c_ioctl(struct inode *inode, struct file *file,
          unsigned int cmd, unsigned long arg) {
          unsigned char data[2];
//          unsigned long flags;

          int error=0;
   D(printk("i2c_ioctl cmd= %x, arg= %x\n\r",cmd,(int) arg));
   D(printk("i2c_ioctl:  ((int *)file->private_data)[0]= %x\n\r",((int *)file->private_data)[0]));
        if(_IOC_TYPE(cmd) != FPGACONF_IOCTYPE) {
                return -EINVAL;
        }

        switch (_IOC_NR(cmd)) {
                case I2C_WRITEREG:

                        /* write to an i2c slave */
                        D(printk("i2cw slave=%d, reg=%d, value=%d\n", 
                                 (int) I2C_ARGSLAVE(arg),
                                 (int) I2C_ARGREG(arg),
                                 (int) I2C_ARGVALUE(arg)));
                        data[0]=I2C_ARGREG(arg);
                        data[1]=I2C_ARGVALUE(arg);
                        return -fi2c_writeData(I2C_ARGSLAVE(arg) & 0xfe, &data[0], 2);
                case I2C_READREG:
                {
                        /* read from an i2c slave */
                        D(printk("i2cr slave=%d, reg=%d ", 
                                 (int) I2C_ARGSLAVE(arg),
                                 (int) I2C_ARGREG(arg)));

                        data[0]=I2C_ARGREG(arg);
                        error=fi2c_writeData(I2C_ARGSLAVE(arg) & 0xfe, &data[0], 1);
                        if (error) return -error;

                        error=fi2c_readData(I2C_ARGSLAVE(arg) | 0x01, &data[1], 1);
                        if (error) return -error;
                        D(printk("returned %d\n", data[1]));

                        return data[1];
                }
                default:
                        return -EINVAL;

        }
        
        return 0;
}
//int fi2c_writeData(unsigned char theSlave, unsigned char *theData, int size);

//int fi2c_readData(unsigned char theSlave, unsigned char *theData, int size);
#define CY223933_SA 0xd2

int setCYField (int addr, int mask, int value) {
    unsigned char data[2];
    int error;
    data[0]=addr;
    error=fi2c_writeData(CY223933_SA,       &data[0], 1);
    if (error) return -error;
    error=fi2c_readData(CY223933_SA | 0x01, &data[1], 1);
    if (error) return -error;
    data[1]^=(data[1] ^ (unsigned long) value) & (unsigned long) mask;
    error=fi2c_writeData(CY223933_SA,       &data[0], 2);
    return error;
}

// sets clock to 1-127MHz for clock 0/1
int setClockFreq(int nclock, int freq) {
  int i,bp,bq,bdiv,pllc;
  const int freqtab[]=
  {     0x0, 0x1303640, 0x1303320, 0x2d08220, 0x1303190, 0x1303140, 0x2d08110, 0x24060f0,
  0x14030d0, 0x15030c0, 0x13030a0, 0x10020a0, 0x1503090, 0x1403080, 0x1603080, 0x2406070,
  0x1603070, 0x2d08060, 0x1503060, 0x3308060, 0x1303050, 0x2406050, 0x1002050, 0x1102050,
  0x1202050, 0x1303040, 0x1403040, 0x1503040, 0x1603040, 0x1703040, 0x1202040, 0x1903040,
  0x1a03040, 0x1b03040, 0x2d08030, 0x2406030, 0x1503030, 0x6912030, 0x3308030, 0x6f12030,
  0x1202030, 0x7512030, 0x3908030, 0x7b12030, 0x1b03030, 0x1502030, 0x3f08030, 0x8712030,
  0x1e03030, 0x8d12030, 0x1303020, 0x2d08020, 0x1403020, 0x2f08020, 0x1503020, 0x1002020,
  0x1603020, 0x3308020, 0x1703020, 0x3508020, 0x1202020, 0x3708020, 0x1903020, 0x3908020,
  0x1a03020, 0x1402020, 0x1b03020, 0x3d08020, 0x1c03020, 0x3f08020, 0x1602020, 0x4108020,
  0x1e03020, 0x4308020, 0x1f03020, 0x1802020, 0x2003020, 0x4708020, 0x2103020, 0x4908020,
  0x1201020, 0x4b08020, 0x2303020, 0x4d08020, 0x2403020, 0x1c02020, 0x2503020, 0x5108020,
  0x2603020, 0x5308020, 0x1501020, 0x5508020, 0x2803020, 0x5708020, 0x2903020, 0x2002020,
  0x2a03020, 0x5b08020, 0x2b03020, 0x5d08020, 0x1303010, 0x5f12010, 0x2d08010, 0x6112010,
  0x1403010, 0x2406010, 0x2f08010, 0x6512010, 0x1503010, 0x6712010, 0x1002010, 0x6912010,
  0x1603010, 0x6b12010, 0x3308010, 0x1102010, 0x1703010, 0x6f12010, 0x3508010, 0x7112010,
  0x1202010, 0x7312010, 0x3708010, 0x7512010, 0x1903010, 0x1302010, 0x3908010, 0x7912010};
  if ((freq<0) || (freq>127)) {printk("bad frequency for clock %d - %d MHz\n",nclock,freq);return -2;}
//          n=((bp<<20)+(bq<<12)+(bdiv<<4)+pllc);
          bp=  (freqtab[freq]>>20)&0x7ff;
          bq=  (freqtab[freq]>>12)&0xff;
          bdiv=(freqtab[freq]>> 4)&0xff;
          pllc= freqtab[freq]     &0x0f;
  printk ("fpgaconfi2c.c::setClockFreq(clock=%d, freq=%d) bp=0x%x, bq=0x%x, bdiv=0x%x, pllc=0x%x\r\n", nclock, freq,bp,bq,bdiv,pllc);
  switch (nclock) {
       case 0: {
          if (freq==0) {
            setCYField (0x16, 0x40, 0x00); // turn off pll3
            setCYField (0x09, 0x7f, 0x00); // turn off divider- A
            setCYField (0x08, 0x7f, 0x00); // turn off divider- A
            return 0;
          }
          setCYField (0x16, 0x7f, 0x40+(pllc<<3)+((bp & 1)<<2)+((bp & 0x600)>>9) );
          setCYField (0x15, 0xff, ((bp & 0x1fe)>>1) );
          setCYField (0x14, 0xff, bq );
          setCYField (0x09, 0x7f, bdiv); // set divider- A
          setCYField (0x08, 0x7f, bdiv); // set divider- A
          setCYField (0x0e, 0x03, 0x03); // set PLL3 as source for ClkA
          return 0;
       }
       case 1: {
          if (freq==0) {
            setCYField (0x0b, 0x7f, 0x00); // turn off divider- B
            setCYField (0x0a, 0x7f, 0x00); // turn off divider- B
            for (i=0;i<24;i+=3) setCYField (0x42+i, 0x40, 0x00); // turn off pll1
            return 0;
          }
// progam all variants
          for (i=0;i<24;i+=3) {
            setCYField (0x42+i, 0x7f, 0x40+(pllc<<3)+((bp & 1)<<2)+((bp & 0x600)>>9) );
            setCYField (0x41+i, 0xff, ((bp & 0x1fe)>>1) );
            setCYField (0x40+i, 0xff, bq );
          }
          setCYField (0x0b, 0x7f, bdiv); // set divider- B
          setCYField (0x0a, 0x7f, bdiv); // set divider- B
          setCYField (0x0e, 0x0c, 0x04); // set PLL1 as source for ClkB
          return 0;
       }
   default: return -1; // wrong clock number
  }
}

---