2014-04-12 i2c总线驱动程序__

实验描述：

i2c总线驱动程序

i2c设备驱动程序读写EEPROM

注意事项：

如何确定i2c总线编号：cat /sys/class/i2c-dev/i2c-0/name

内核版本：

Linux 2.6.38

开发板： 

 Mini 6410

i2c_my_bus.c

#include <linux/init.h>  
#include <linux/module.h>  
#include <linux/device.h>
#include <linux/cdev.h> 
#include <linux/i2c.h>
#include <linux/fs.h> 
#include <asm/uaccess.h>
#include <linux/delay.h>
#include <linux/clk.h>
#include <asm/irq.h>
#include <linux/time.h>
#include <linux/interrupt.h>
#include <linux/io.h>

#define PRINTK printk
//#define PRINTK(...) 
enum s3c6410_i2c_state {
	STATE_IDLE,
	STATE_START,
	STATE_READ,
	STATE_WRITE,
	STATE_STOP
};

struct s3c6410_i2c_regs {
	unsigned int iic_con;
	unsigned int iic_stat;
	unsigned int iic_add;
	unsigned int iic_ds;
	unsigned int iic_lc;
};

struct s3c6410_i2c{
	struct i2c_adapter adapter;
	spinlock_t		lock;
	wait_queue_head_t	wait;
	struct clk		*clk;
	enum s3c6410_i2c_state s3c6410_i2c_state;
	struct s3c6410_i2c_regs *s3c6410_i2c_regs;
	unsigned long *gpbcon;

	struct i2c_msg *msgs;
	int msn_num;
	int cur_msg;
	int cur_ptr;
	int state;
	int err;
};

struct  s3c6410_i2c my_s3c6410_i2c;

static void s3c6410_i2c_start(void)
{
	my_s3c6410_i2c.state = STATE_START;
	
	if (my_s3c6410_i2c.msgs->flags & I2C_M_RD) /* read */
	{
		my_s3c6410_i2c.s3c6410_i2c_regs->iic_ds		 = my_s3c6410_i2c.msgs->addr << 1;	//iic data store
		my_s3c6410_i2c.s3c6410_i2c_regs->iic_stat 	 = 0b10110000;	 // master receive, enable Tx/Rx, send start signal
	}
	else /* write */
	{
		my_s3c6410_i2c.s3c6410_i2c_regs->iic_ds		 = my_s3c6410_i2c.msgs->addr << 1;
		my_s3c6410_i2c.s3c6410_i2c_regs->iic_stat    = 0b11110000; 	// master transmit, enable Tx/Rx, send start signal
	}
}

static void s3c6410_i2c_stop(int err)
{
	my_s3c6410_i2c.state = STATE_STOP;
	my_s3c6410_i2c.err   = err;

	PRINTK("iic STATE_STOP, err = %d\n", err);

	if (my_s3c6410_i2c.msgs->flags & I2C_M_RD) /* read */
	{
		// master receive, enable Tx/Rx, send P signal
		my_s3c6410_i2c.s3c6410_i2c_regs->iic_stat = 0b10010000;
		my_s3c6410_i2c.s3c6410_i2c_regs->iic_con  = 0b10101111;
		ndelay(50);  	//wait
	}
	else 
	{
		// master transmit, enable Tx/Rx, send P signal?
		my_s3c6410_i2c.s3c6410_i2c_regs->iic_stat = 0b11010000;
		my_s3c6410_i2c.s3c6410_i2c_regs->iic_con  = 0b10101111;
		ndelay(50);  
	}

	/* wait the queue*/
	wake_up(&my_s3c6410_i2c.wait);
	
}

static int s3c6410_master_xfer(struct i2c_adapter * adapter, struct i2c_msg * msg, int num)
{	
	printk(KERN_ALERT"s3c6410_i2c_xfer time i2c_msg addr:%d, buf first:%d\n", msg->addr, msg->buf[0]);
	//we can get the messages;
	unsigned long timeout;
	
	/* send num messages*/
	my_s3c6410_i2c.msgs    = msg;
	my_s3c6410_i2c.msn_num = num;
	my_s3c6410_i2c.cur_msg = 0;
	my_s3c6410_i2c.cur_ptr = 0;
	my_s3c6410_i2c.err     = -ENODEV;

	s3c6410_i2c_start();

	timeout = wait_event_timeout(my_s3c6410_i2c.wait, (my_s3c6410_i2c.state == STATE_STOP), HZ * 5);
	if (0 == timeout)
	{
		printk("s3c6410_i2c_xfer time out\n");
		return -ETIMEDOUT;
	}
	else
	{
		return my_s3c6410_i2c.err;
	}
}

static u32 s3c6410_functionality (struct i2c_adapter * adapter)
{
	return I2C_FUNC_I2C | I2C_FUNC_SMBUS_EMUL | I2C_FUNC_PROTOCOL_MANGLING;
}

struct i2c_algorithm s3c6410_algorithm = {
	.master_xfer = s3c6410_master_xfer,
	.functionality = s3c6410_functionality,
};

static int isLastMsg(void)
{
	return (my_s3c6410_i2c.cur_msg == my_s3c6410_i2c.msn_num - 1);
}

static int isEndData(void)
{
	return (my_s3c6410_i2c.cur_ptr >= my_s3c6410_i2c.msgs->len);
}

static int isLastData(void)
{
	return (my_s3c6410_i2c.cur_ptr == (my_s3c6410_i2c.msgs->len - 1));
}

static irqreturn_t s3c6410_iic_xfer(int irq, void *dev)
{
	unsigned int iicSt;
	iicSt  = my_s3c6410_i2c.s3c6410_i2c_regs->iic_stat; 
	if(iicSt & 0b1000)
		printk("sorry Bus arbitration failed\n\r"); 

	switch (my_s3c6410_i2c.state)
	{
		case STATE_START : /* send S signal and device address, will produce interrupt and we will deal*/
		{
			PRINTK("Start\n");
			if (iicSt & 0b0001)	//check is ack
			{
				s3c6410_i2c_stop(-ENODEV);
				break;
			}
			if (isLastMsg() && isEndData())
			{
				s3c6410_i2c_stop(0);
				break;
			}

			//go to next state
			if (my_s3c6410_i2c.msgs->flags & I2C_M_RD) /* read */
			{
				my_s3c6410_i2c.state = STATE_READ;
				goto next_read;
			}
			else
			{
				my_s3c6410_i2c.state = STATE_WRITE;
			}	
		}

		case STATE_WRITE:
		{
			PRINTK("STATE_WRITE\n");
			if (iicSt & 0b0001)//if the last is ack, we will stop
			{
				s3c6410_i2c_stop(-ENODEV);
				break;
			}

			if (!isEndData())  //we still have messages to transmit
			{
				my_s3c6410_i2c.s3c6410_i2c_regs->iic_ds = my_s3c6410_i2c.msgs->buf[my_s3c6410_i2c.cur_ptr];//pointer the data buf
				PRINTK("cur:%d, len: %d, writeBuffer:%d\n", my_s3c6410_i2c.cur_ptr, my_s3c6410_i2c.msgs->len, my_s3c6410_i2c.msgs->buf[my_s3c6410_i2c.cur_ptr]);
				my_s3c6410_i2c.cur_ptr++;
				
				// we should wait a little time, which can enable data to be occureed int SDA
				ndelay(50);	
				my_s3c6410_i2c.s3c6410_i2c_regs->iic_con = 0b10101111;		// recover iic transmit
				break;				
			}
			else if (!isLastMsg())
			{
				//we will deal next message
				my_s3c6410_i2c.msgs++;
				my_s3c6410_i2c.cur_msg++;
				my_s3c6410_i2c.cur_ptr = 0;
				my_s3c6410_i2c.state = STATE_START;
				//send S signal and device address
				s3c6410_i2c_start();//we will do a new transmit
				break;
			}
			else
			{
				//last message and last data
				s3c6410_i2c_stop(0);
				break;				
			}
			break;
		}

		case STATE_READ:
		{

		//read data
			my_s3c6410_i2c.msgs->buf[my_s3c6410_i2c.cur_ptr] = my_s3c6410_i2c.s3c6410_i2c_regs->iic_ds;			
			PRINTK("cur:%d, len: %d, Read Buffer: %d\n", my_s3c6410_i2c.cur_ptr, my_s3c6410_i2c.msgs->len, my_s3c6410_i2c.msgs->buf[my_s3c6410_i2c.cur_ptr]);
			my_s3c6410_i2c.cur_ptr++;
next_read:	
			if (!isEndData()) //if we still have data to read, we should continue
			{
				if (isLastData())  //if this data is the last, we will have no ack
				{
					my_s3c6410_i2c.s3c6410_i2c_regs->iic_con = 0x00101111;   // diable ack signal
					PRINTK("last data no ack\n");
				}
				else
				{
					my_s3c6410_i2c.s3c6410_i2c_regs->iic_con = 0b10101111;   // recover iic transmit, next data we will receive ack
					PRINTK("last data have ack\n");
				}				
				break;
			}
			else if (!isLastMsg())
			{
				//we will deal next message
				my_s3c6410_i2c.msgs++;
				my_s3c6410_i2c.cur_msg++;
				my_s3c6410_i2c.cur_ptr = 0;
				my_s3c6410_i2c.state = STATE_START;
				//send S signal and device address
				s3c6410_i2c_start();
				break;
			}
			else
			{
				//last message and last data
				s3c6410_i2c_stop(0);
				break;							
			}
			break;
		}
		
		default: break;
	}

	//clear interrupt, so we can restore deal 
	my_s3c6410_i2c.s3c6410_i2c_regs->iic_con &= ~(1<<4);

	return IRQ_HANDLED;	
}

static int i2c_bus_init(void)  
{   
	strlcpy(my_s3c6410_i2c.adapter.name, "s3c6410-i2c", sizeof(my_s3c6410_i2c.adapter.name));
	my_s3c6410_i2c.adapter.algo = &s3c6410_algorithm;
	my_s3c6410_i2c.adapter.owner = THIS_MODULE;
	my_s3c6410_i2c.clk = clk_get(NULL, "i2c");
	clk_enable(my_s3c6410_i2c.clk);

	// set the hadware paramter
	my_s3c6410_i2c.gpbcon = (volatile unsigned long *)ioremap(0x7F008020, sizeof(unsigned int));  
	my_s3c6410_i2c.s3c6410_i2c_regs = ioremap(0x7F004000, sizeof(struct s3c6410_i2c_regs));//very impotant

	*my_s3c6410_i2c.gpbcon &= ~(0b1111 << 20 | 0b1111<<24);	//enable the i2cscl and i2csda
	*my_s3c6410_i2c.gpbcon |= (0b0010 << 20 | 0b0010<<24);
	my_s3c6410_i2c.s3c6410_i2c_regs->iic_con = (1<<7 ) | (0 << 6 ) | (1<<5 )  | (0xf<<3);
	my_s3c6410_i2c.s3c6410_i2c_regs->iic_add = 0x10;	
	my_s3c6410_i2c.s3c6410_i2c_regs->iic_stat = 0x10;	//enable Rx/Tx
	init_waitqueue_head(&my_s3c6410_i2c.wait);

	int err;
	err = request_irq(IRQ_IIC, s3c6410_iic_xfer, 0,  "s3c6410_iic_bus", 0);  
     	if(err){  
       		PRINTK(KERN_ALERT"can not obtain irq!\n");
		goto err_irq;
      	}  

	i2c_add_adapter(&my_s3c6410_i2c.adapter);
	PRINTK(KERN_ALERT"init!\n");
	return 0;  

err_irq:
	iounmap(my_s3c6410_i2c.s3c6410_i2c_regs);
	iounmap(my_s3c6410_i2c.gpbcon);
	clk_disable(my_s3c6410_i2c.clk);
	clk_put(my_s3c6410_i2c.clk);
	return err;
}  

static int i2c_bus_exit(void)  
{   
	iounmap(my_s3c6410_i2c.s3c6410_i2c_regs);
	iounmap(my_s3c6410_i2c.gpbcon);
	free_irq(IRQ_IIC, NULL);
	clk_disable(my_s3c6410_i2c.clk);
	clk_put(my_s3c6410_i2c.clk);
	i2c_del_adapter(&my_s3c6410_i2c.adapter);
	PRINTK(KERN_ALERT"exit!\n");
	return 0;  
}  
 
module_init(i2c_bus_init);  
module_exit(i2c_bus_exit);
MODULE_LICENSE("GPL");  
MODULE_DESCRIPTION("S3C6410 I2C Bus driver");
MODULE_AUTHOR("Books, <uppour@sina.cn>");