/*!*************************************************************************** *! *! FILE NAME : i2c.c *! *! DESCRIPTION: implements an interface for IIC/I2C, both directly from other *! kernel modules (i2c_writereg/readreg) and from userspace using *! ioctl()'s *! *! Nov 30 1998 Torbjorn Eliasson Initial version. *! Bjorn Wesen Elinux kernel version. *! Jan 14 2000 Johan Adolfsson Fixed PB shadow register stuff - *! don't use PB_I2C if DS1302 uses same bits, *! use PB. *| June 23 2003 Pieter Grimmerink Added 'i2c_sendnack'. i2c_readreg now *| generates nack on last received byte, *| instead of ack. *| i2c_getack changed data level while clock *| was high, causing DS75 to see a stop condition *! *! --------------------------------------------------------------------------- *! *! (C) Copyright 1999-2007 Axis Communications AB, LUND, SWEDEN *! *!***************************************************************************/ /****************** INCLUDE FILES SECTION ***********************************/ #include <linux/module.h> #include <linux/sched.h> #include <linux/errno.h> #include <linux/kernel.h> #include <linux/fs.h> #include <linux/string.h> #include <linux/init.h> #include <linux/mutex.h> #include <asm/etraxi2c.h> #include <asm/io.h> #include <asm/delay.h> #include "i2c.h" /****************** I2C DEFINITION SECTION *************************/ #define D(x) #define I2C_MAJOR 123 /* LOCAL/EXPERIMENTAL */ static DEFINE_MUTEX(i2c_mutex); static const char i2c_name[] = "i2c"; #define CLOCK_LOW_TIME 8 #define CLOCK_HIGH_TIME 8 #define START_CONDITION_HOLD_TIME 8 #define STOP_CONDITION_HOLD_TIME 8 #define ENABLE_OUTPUT 0x01 #define ENABLE_INPUT 0x00 #define I2C_CLOCK_HIGH 1 #define I2C_CLOCK_LOW 0 #define I2C_DATA_HIGH 1 #define I2C_DATA_LOW 0 #define i2c_enable() #define i2c_disable() /* enable or disable output-enable, to select output or input on the i2c bus */ #define i2c_dir_out() crisv32_io_set_dir(&cris_i2c_data, crisv32_io_dir_out) #define i2c_dir_in() crisv32_io_set_dir(&cris_i2c_data, crisv32_io_dir_in) /* control the i2c clock and data signals */ #define i2c_clk(x) crisv32_io_set(&cris_i2c_clk, x) #define i2c_data(x) crisv32_io_set(&cris_i2c_data, x) /* read a bit from the i2c interface */ #define i2c_getbit() crisv32_io_rd(&cris_i2c_data) #define i2c_delay(usecs) udelay(usecs) static DEFINE_SPINLOCK(i2c_lock); /* Protect directions etc */ /****************** VARIABLE SECTION ************************************/ static struct crisv32_iopin cris_i2c_clk; static struct crisv32_iopin cris_i2c_data; /****************** FUNCTION DEFINITION SECTION *************************/ /* generate i2c start condition */ void i2c_start(void) { /* * SCL=1 SDA=1 */ i2c_dir_out(); i2c_delay(CLOCK_HIGH_TIME/6); i2c_data(I2C_DATA_HIGH); i2c_clk(I2C_CLOCK_HIGH); i2c_delay(CLOCK_HIGH_TIME); /* * SCL=1 SDA=0 */ i2c_data(I2C_DATA_LOW); i2c_delay(START_CONDITION_HOLD_TIME); /* * SCL=0 SDA=0 */ i2c_clk(I2C_CLOCK_LOW); i2c_delay(CLOCK_LOW_TIME); } /* generate i2c stop condition */ void i2c_stop(void) { i2c_dir_out(); /* * SCL=0 SDA=0 */ i2c_clk(I2C_CLOCK_LOW); i2c_data(I2C_DATA_LOW); i2c_delay(CLOCK_LOW_TIME*2); /* * SCL=1 SDA=0 */ i2c_clk(I2C_CLOCK_HIGH); i2c_delay(CLOCK_HIGH_TIME*2); /* * SCL=1 SDA=1 */ i2c_data(I2C_DATA_HIGH); i2c_delay(STOP_CONDITION_HOLD_TIME); i2c_dir_in(); } /* write a byte to the i2c interface */ void i2c_outbyte(unsigned char x) { int i; i2c_dir_out(); for (i = 0; i < 8; i++) { if (x & 0x80) { i2c_data(I2C_DATA_HIGH); } else { i2c_data(I2C_DATA_LOW); } i2c_delay(CLOCK_LOW_TIME/2); i2c_clk(I2C_CLOCK_HIGH); i2c_delay(CLOCK_HIGH_TIME); i2c_clk(I2C_CLOCK_LOW); i2c_delay(CLOCK_LOW_TIME/2); x <<= 1; } i2c_data(I2C_DATA_LOW); i2c_delay(CLOCK_LOW_TIME/2); /* * enable input */ i2c_dir_in(); } /* read a byte from the i2c interface */ unsigned char i2c_inbyte(void) { unsigned char aBitByte = 0; int i; /* Switch off I2C to get bit */ i2c_disable(); i2c_dir_in(); i2c_delay(CLOCK_HIGH_TIME/2); /* Get bit */ aBitByte |= i2c_getbit(); /* Enable I2C */ i2c_enable(); i2c_delay(CLOCK_LOW_TIME/2); for (i = 1; i < 8; i++) { aBitByte <<= 1; /* Clock pulse */ i2c_clk(I2C_CLOCK_HIGH); i2c_delay(CLOCK_HIGH_TIME); i2c_clk(I2C_CLOCK_LOW); i2c_delay(CLOCK_LOW_TIME); /* Switch off I2C to get bit */ i2c_disable(); i2c_dir_in(); i2c_delay(CLOCK_HIGH_TIME/2); /* Get bit */ aBitByte |= i2c_getbit(); /* Enable I2C */ i2c_enable(); i2c_delay(CLOCK_LOW_TIME/2); } i2c_clk(I2C_CLOCK_HIGH); i2c_delay(CLOCK_HIGH_TIME); /* * we leave the clock low, getbyte is usually followed * by sendack/nack, they assume the clock to be low */ i2c_clk(I2C_CLOCK_LOW); return aBitByte; } /*#--------------------------------------------------------------------------- *# *# FUNCTION NAME: i2c_getack *# *# DESCRIPTION : checks if ack was received from ic2 *# *#--------------------------------------------------------------------------*/ int i2c_getack(void) { int ack = 1; /* * enable output */ i2c_dir_out(); /* * Release data bus by setting * data high */ i2c_data(I2C_DATA_HIGH); /* * enable input */ i2c_dir_in(); i2c_delay(CLOCK_HIGH_TIME/4); /* * generate ACK clock pulse */ i2c_clk(I2C_CLOCK_HIGH); #if 0 /* * Use PORT PB instead of I2C * for input. (I2C not working) */ i2c_clk(1); i2c_data(1); /* * switch off I2C */ i2c_data(1); i2c_disable(); i2c_dir_in(); #endif /* * now wait for ack */ i2c_delay(CLOCK_HIGH_TIME/2); /* * check for ack */ if (i2c_getbit()) ack = 0; i2c_delay(CLOCK_HIGH_TIME/2); if (!ack) { if (!i2c_getbit()) /* receiver pulld SDA low */ ack = 1; i2c_delay(CLOCK_HIGH_TIME/2); } /* * our clock is high now, make sure data is low * before we enable our output. If we keep data high * and enable output, we would generate a stop condition. */ #if 0 i2c_data(I2C_DATA_LOW); /* * end clock pulse */ i2c_enable(); i2c_dir_out(); #endif i2c_clk(I2C_CLOCK_LOW); i2c_delay(CLOCK_HIGH_TIME/4); /* * enable output */ i2c_dir_out(); /* * remove ACK clock pulse */ i2c_data(I2C_DATA_HIGH); i2c_delay(CLOCK_LOW_TIME/2); return ack; } /*#--------------------------------------------------------------------------- *# *# FUNCTION NAME: I2C::sendAck *# *# DESCRIPTION : Send ACK on received data *# *#--------------------------------------------------------------------------*/ void i2c_sendack(void) { /* * enable output */ i2c_delay(CLOCK_LOW_TIME); i2c_dir_out(); /* * set ack pulse high */ i2c_data(I2C_DATA_LOW); /* * generate clock pulse */ i2c_delay(CLOCK_HIGH_TIME/6); i2c_clk(I2C_CLOCK_HIGH); i2c_delay(CLOCK_HIGH_TIME); i2c_clk(I2C_CLOCK_LOW); i2c_delay(CLOCK_LOW_TIME/6); /* * reset data out */ i2c_data(I2C_DATA_HIGH); i2c_delay(CLOCK_LOW_TIME); i2c_dir_in(); } /*#--------------------------------------------------------------------------- *# *# FUNCTION NAME: i2c_sendnack *# *# DESCRIPTION : Sends NACK on received data *# *#--------------------------------------------------------------------------*/ void i2c_sendnack(void) { /* * enable output */ i2c_delay(CLOCK_LOW_TIME); i2c_dir_out(); /* * set data high */ i2c_data(I2C_DATA_HIGH); /* * generate clock pulse */ i2c_delay(CLOCK_HIGH_TIME/6); i2c_clk(I2C_CLOCK_HIGH); i2c_delay(CLOCK_HIGH_TIME); i2c_clk(I2C_CLOCK_LOW); i2c_delay(CLOCK_LOW_TIME); i2c_dir_in(); } /*#--------------------------------------------------------------------------- *# *# FUNCTION NAME: i2c_write *# *# DESCRIPTION : Writes a value to an I2C device *# *#--------------------------------------------------------------------------*/ int i2c_write(unsigned char theSlave, void *data, size_t nbytes) { int error, cntr = 3; unsigned char bytes_wrote = 0; unsigned char value; unsigned long flags; spin_lock_irqsave(&i2c_lock, flags); do { error = 0; i2c_start(); /* * send slave address */ i2c_outbyte((theSlave & 0xfe)); /* * wait for ack */ if (!i2c_getack()) error = 1; /* * send data */ for (bytes_wrote = 0; bytes_wrote < nbytes; bytes_wrote++) { memcpy(&value, data + bytes_wrote, sizeof value); i2c_outbyte(value); /* * now it's time to wait for ack */ if (!i2c_getack()) error |= 4; } /* * end byte stream */ i2c_stop(); } while (error && cntr--); i2c_delay(CLOCK_LOW_TIME); spin_unlock_irqrestore(&i2c_lock, flags); return -error; } /*#--------------------------------------------------------------------------- *# *# FUNCTION NAME: i2c_read *# *# DESCRIPTION : Reads a value from an I2C device *# *#--------------------------------------------------------------------------*/ int i2c_read(unsigned char theSlave, void *data, size_t nbytes) { unsigned char b = 0; unsigned char bytes_read = 0; int error, cntr = 3; unsigned long flags; spin_lock_irqsave(&i2c_lock, flags); do { error = 0; memset(data, 0, nbytes); /* * generate start condition */ i2c_start(); /* * send slave address */ i2c_outbyte((theSlave | 0x01)); /* * wait for ack */ if (!i2c_getack()) error = 1; /* * fetch data */ for (bytes_read = 0; bytes_read < nbytes; bytes_read++) { b = i2c_inbyte(); memcpy(data + bytes_read, &b, sizeof b); if (bytes_read < (nbytes - 1)) i2c_sendack(); } /* * last received byte needs to be nacked * instead of acked */ i2c_sendnack(); /* * end sequence */ i2c_stop(); } while (error && cntr--); spin_unlock_irqrestore(&i2c_lock, flags); return -error; } /*#--------------------------------------------------------------------------- *# *# FUNCTION NAME: i2c_writereg *# *# DESCRIPTION : Writes a value to an I2C device *# *#--------------------------------------------------------------------------*/ int i2c_writereg(unsigned char theSlave, unsigned char theReg, unsigned char theValue) { int error, cntr = 3; unsigned long flags; spin_lock_irqsave(&i2c_lock, flags); do { error = 0; i2c_start(); /* * send slave address */ i2c_outbyte((theSlave & 0xfe)); /* * wait for ack */ if(!i2c_getack()) error = 1; /* * now select register */ i2c_dir_out(); i2c_outbyte(theReg); /* * now it's time to wait for ack */ if(!i2c_getack()) error |= 2; /* * send register register data */ i2c_outbyte(theValue); /* * now it's time to wait for ack */ if(!i2c_getack()) error |= 4; /* * end byte stream */ i2c_stop(); } while(error && cntr--); i2c_delay(CLOCK_LOW_TIME); spin_unlock_irqrestore(&i2c_lock, flags); return -error; } /*#--------------------------------------------------------------------------- *# *# FUNCTION NAME: i2c_readreg *# *# DESCRIPTION : Reads a value from the decoder registers. *# *#--------------------------------------------------------------------------*/ unsigned char i2c_readreg(unsigned char theSlave, unsigned char theReg) { unsigned char b = 0; int error, cntr = 3; unsigned long flags; spin_lock_irqsave(&i2c_lock, flags); do { error = 0; /* * generate start condition */ i2c_start(); /* * send slave address */ i2c_outbyte((theSlave & 0xfe)); /* * wait for ack */ if(!i2c_getack()) error = 1; /* * now select register */ i2c_dir_out(); i2c_outbyte(theReg); /* * now it's time to wait for ack */ if(!i2c_getack()) error |= 2; /* * repeat start condition */ i2c_delay(CLOCK_LOW_TIME); i2c_start(); /* * send slave address */ i2c_outbyte(theSlave | 0x01); /* * wait for ack */ if(!i2c_getack()) error |= 4; /* * fetch register */ b = i2c_inbyte(); /* * last received byte needs to be nacked * instead of acked */ i2c_sendnack(); /* * end sequence */ i2c_stop(); } while(error && cntr--); spin_unlock_irqrestore(&i2c_lock, flags); return b; } static int i2c_open(struct inode *inode, struct file *filp) { return 0; } static int i2c_release(struct inode *inode, struct file *filp) { return 0; } /* Main device API. ioctl's to write or read to/from i2c registers. */ static long i2c_ioctl(struct file *file, unsigned int cmd, unsigned long arg) { int ret; if(_IOC_TYPE(cmd) != ETRAXI2C_IOCTYPE) { return -ENOTTY; } switch (_IOC_NR(cmd)) { case I2C_WRITEREG: /* write to an i2c slave */ D(printk("i2cw %d %d %d\n", I2C_ARGSLAVE(arg), I2C_ARGREG(arg), I2C_ARGVALUE(arg))); mutex_lock(&i2c_mutex); ret = i2c_writereg(I2C_ARGSLAVE(arg), I2C_ARGREG(arg), I2C_ARGVALUE(arg)); mutex_unlock(&i2c_mutex); return ret; case I2C_READREG: { unsigned char val; /* read from an i2c slave */ D(printk("i2cr %d %d ", I2C_ARGSLAVE(arg), I2C_ARGREG(arg))); mutex_lock(&i2c_mutex); val = i2c_readreg(I2C_ARGSLAVE(arg), I2C_ARGREG(arg)); mutex_unlock(&i2c_mutex); D(printk("= %d\n", val)); return val; } default: return -EINVAL; } return 0; } static const struct file_operations i2c_fops = { .owner = THIS_MODULE, .unlocked_ioctl = i2c_ioctl, .open = i2c_open, .release = i2c_release, .llseek = noop_llseek, }; static int __init i2c_init(void) { static int res; static int first = 1; if (!first) return res; first = 0; /* Setup and enable the DATA and CLK pins */ res = crisv32_io_get_name(&cris_i2c_data, CONFIG_ETRAX_V32_I2C_DATA_PORT); if (res < 0) return res; res = crisv32_io_get_name(&cris_i2c_clk, CONFIG_ETRAX_V32_I2C_CLK_PORT); crisv32_io_set_dir(&cris_i2c_clk, crisv32_io_dir_out); return res; } static int __init i2c_register(void) { int res; res = i2c_init(); if (res < 0) return res; /* register char device */ res = register_chrdev(I2C_MAJOR, i2c_name, &i2c_fops); if (res < 0) { printk(KERN_ERR "i2c: couldn't get a major number.\n"); return res; } printk(KERN_INFO "I2C driver v2.2, (c) 1999-2007 Axis Communications AB\n"); return 0; } /* this makes sure that i2c_init is called during boot */ module_init(i2c_register); /****************** END OF FILE i2c.c ********************************/