头文件
#ifndef _E2PROM_H_
#define _E2PROM_H_
#define E2PROM_MAGIC 'e'
#define E2PROM_WRITE_READ _IOWR( E2PROM_MAGIC, 0, unsigned char )
#define E2PROM_MAXNR 1
#endif
源代码文件
//////////////////////////////////////////////////////////////////////////
// FILE : e2prom.c
// DATE : 09/02/2010
// DESCRIPTION : tamedia e2prom driver source
// OS : Linux
// AUTHOR : rui
//////////////////////////////////////////////////////////////////////////
#include <linux/init.h>
#include <linux/slab.h>
#include <linux/irq.h>
#include <linux/poll.h>
#include <linux/delay.h>
#include <linux/module.h>
#if !defined(CONFIG_TANGOX)
#error "Unsupport architecture (TANGOX only)."
#elif defined(CONFIG_TANGO2_SMP863X) && (EM86XX_REVISION < 4)
#error "Unsupport Tango2 (ES4 or above) or Tango3 chip."
#endif /* */
#include <asm/io.h>
#ifdef CONFIG_TANGO2
#include <asm/tango2/tango2api.h>
#elif defined(CONFIG_TANGO3)
#include <asm/tango3/tango3api.h>
#endif /* */
#include "e2prom.h"
#define GPIO_IIC_SCL 0
#define GPIO_IIC_SDA 1
#define I2C_AT24CXX_ADDRESS 0xa0
#define I2C_AT24C02_MAXSIZE 0xff
#define SCL_H { em86xx_gpio_write( GPIO_IIC_SCL, 1 ) ; }
#define SCL_L { em86xx_gpio_write( GPIO_IIC_SCL, 0 ) ; }
#define SDA_H { em86xx_gpio_write( GPIO_IIC_SDA, 1 ) ; }
#define SDA_L { em86xx_gpio_write( GPIO_IIC_SDA, 0 ) ; }
#define SDA_IN { em86xx_gpio_setdirection ( GPIO_IIC_SDA, GPIO_INPUT ) ; }
#define SDA_OUT { em86xx_gpio_setdirection ( GPIO_IIC_SDA, GPIO_OUTPUT ) ; }
#define WHILE_SDA_HIGH (em86xx_gpio_read( GPIO_IIC_SDA ) == 1 )
MODULE_DESCRIPTION ( "EM86xx/SMP86xx tamedia e2prom m41t81 driver\n" ) ;
MODULE_AUTHOR ( "rui" ) ;
MODULE_LICENSE ( "GPL" ) ;
#define E2PROM_DEV_NAME "e2prom"
static int major = 221 ;
module_param( major, int, 0 ) ;
unsigned int ByteDelayTimeout = 0x1000 ;
unsigned int BitDelayTimeout = 0x200 ;
static void ByteDelay ( void ) ;
static void BitDelay ( void ) ;
static int e2prom_open ( struct inode *, struct file * ) ;
static int e2prom_release ( struct inode *, struct file * ) ;
static int e2prom_read ( struct file *, char *, size_t, loff_t * ) ;
static int e2prom_write ( struct file *, const char *, size_t, loff_t * ) ;
static int e2prom_ioctl ( struct inode *, struct file *, unsigned int,unsigned long ) ;
static void InterfaceInit ( void ) ;
static void I2C_Start ( void ) ;
static void I2C_Stop ( void ) ;
static void I2C_Ack ( void ) ;
static void I2C_Nack ( void ) ;
struct e2prom_private
{
spinlock_t lock ;
int ref_cnt ;
unsigned char address ;
} ;
static struct e2prom_private e2prom_priv ;
static struct file_operations e2prom_fops =
{
.owner = THIS_MODULE,
.open = e2prom_open,
.read = e2prom_read,
.write = e2prom_write,
.ioctl = e2prom_ioctl,
.release =e2prom_release,
} ;
static void I2C_Start ()
{
SDA_OUT ;
SDA_H ;
BitDelay () ;
SCL_H ;
BitDelay () ;
SDA_L ;
BitDelay () ;
SCL_L ;
BitDelay () ;
}
static void I2C_Stop ()
{
SDA_OUT ;
SDA_L ;
BitDelay () ;
SCL_H ;
BitDelay () ;
SDA_H ;
BitDelay () ;
}
static void I2C_Ack()
{
SDA_OUT ;
SDA_L ;
BitDelay () ;
SCL_H ;
BitDelay () ;
SCL_L ;
BitDelay () ;
}
static void I2C_Nack ()
{
SDA_OUT ;
SDA_H ;
BitDelay () ;
SCL_H ;
BitDelay () ;
SCL_L ;
BitDelay () ;
}
static char Write_I2C_Byte ( char byte )
{
char i ;
SDA_OUT ;
for ( i = 0 ; i < 8 ; i++ )
{
if ( (byte & 0x80) == 0x80 )
{
SDA_H ;
}
else
{
SDA_L ;
}
BitDelay () ;
SCL_H ;
BitDelay () ;
SCL_L ;
byte <<= 1 ;
}
return 1 ;
}
static char Read_I2C_Byte ( void )
{
char i, buff = 0 ;
for ( i = 0 ; i < 8 ; i++ )
{
SDA_OUT ;
SDA_H ;
BitDelay () ;
SCL_H ;
BitDelay () ;
SDA_IN ;
if ( WHILE_SDA_HIGH )
{
buff |= 0x01 ;
}
if ( i < 7 )
{
buff <<= 1 ;
}
SCL_L ;
BitDelay () ;
}
return buff ;
}
static void ByteDelay ( void )
{
volatile unsigned int dwTimeout ;
dwTimeout = ByteDelayTimeout ;
while ( --dwTimeout )
{
asm ( "nop" ) ;
}
}
static void BitDelay ( void )
{
volatile unsigned int dwTimeout ;
dwTimeout = BitDelayTimeout ;
while ( --dwTimeout )
{
asm ( "nop" ) ;
}
}
static void InterfaceInit ( void )
{
em86xx_gpio_setdirection ( GPIO_IIC_SDA, GPIO_OUTPUT ) ;
em86xx_gpio_setdirection ( GPIO_IIC_SCL, GPIO_OUTPUT ) ;
em86xx_gpio_write ( GPIO_IIC_SDA, 1 ) ;
em86xx_gpio_write ( GPIO_IIC_SCL, 1 ) ;
ByteDelay () ;
ByteDelay () ;
ByteDelay () ;
I2C_Start () ;
Write_I2C_Byte ( I2C_AT24CXX_ADDRESS ) ;
I2C_Ack () ;
Write_I2C_Byte ( 0x0c ) ;
I2C_Ack () ;
Write_I2C_Byte ( 0x00 ) ;
I2C_Ack () ;
I2C_Stop () ;
}
static int e2prom_open ( struct inode *inode_ptr, struct file *fptr )
{
printk( "--------------------------------------------\n" ) ;
if ( e2prom_priv.ref_cnt != 0 )
{
printk ( "%s: exclusive access only\n", E2PROM_DEV_NAME ) ;
return -EIO ;
}
e2prom_priv.ref_cnt++ ;
e2prom_priv.address = 0x00 ;
fptr->f_op = &e2prom_fops ;
fptr->private_data = (void *) &e2prom_priv ;
return 0 ;
}
static int e2prom_release ( struct inode *inode_ptr, struct file *fptr )
{
struct e2prom_private *priv = (struct e2prom_private *) fptr->private_data ;
priv->ref_cnt-- ;
priv->address = 0x00 ;
return 0 ;
}
static int e2prom_read (struct file *fptr, char *buffer, size_t count, loff_t * fp)
{
struct e2prom_private *priv = (struct e2prom_private *) fptr->private_data ;
unsigned char data[I2C_AT24C02_MAXSIZE] = { 0x00, } ;
int i = 0;
printk( "e2prom_read : address : 0x%x\n", priv->address ) ;
if ( count <= 0 )
{
printk ( "e2prom_read : read size must big than 0 .\n" ) ;
return -EIO ;
}
if ( priv->address + count >= I2C_AT24C02_MAXSIZE )
{
printk ( "e2prom_read : read size overflow e2prom size .\n" ) ;
count = I2C_AT24C02_MAXSIZE - priv->address ;
}
spin_lock ( &priv->lock ) ;
I2C_Start () ;
Write_I2C_Byte ( I2C_AT24CXX_ADDRESS ) ;
I2C_Ack () ;
Write_I2C_Byte ( priv->address ) ;
I2C_Ack () ;
I2C_Start () ;
Write_I2C_Byte ( I2C_AT24CXX_ADDRESS + 1 ) ;
I2C_Ack () ;
for ( i = 0; i < count; i++ )
{
data[i] = Read_I2C_Byte () ;
I2C_Ack () ;
printk( "0x%x ", data[i] ) ;
}
Read_I2C_Byte () ;
I2C_Nack () ;
I2C_Stop () ;
spin_unlock ( &priv->lock ) ;
printk( "\n" ) ;
if ( i == 0 )
{
return -EFAULT ;
}
if ( copy_to_user ( buffer, (char *) &data, count ) )
{
printk ( "e2prom_read : copy_to_user failed .\n" ) ;
return -EFAULT ;
}
printk( "buffer : 0x%x, 0x%x, 0x%x, 0x%x\n", buffer[0], buffer[1], buffer[2], buffer[3] ) ;
return count ;
}
static int e2prom_write ( struct file *fptr, const char *buffer, size_t size, loff_t * fp )
{
struct e2prom_private *priv = (struct e2prom_private *) fptr->private_data ;
unsigned char data[I2C_AT24C02_MAXSIZE] = { 0x00, } ;
int i = 0;
printk( "e2prom_write : address : 0x%x\n", priv->address ) ;
if ( size <= 0 )
{
printk ( "e2prom_read : read size must big than 0 .\n" ) ;
return -EIO ;
}
if ( priv->address + size > I2C_AT24C02_MAXSIZE )
{
printk ( "e2prom_read : read size overflow e2prom size .\n" ) ;
size = I2C_AT24C02_MAXSIZE - priv->address ;
}
if ( copy_from_user ( (char *) data, buffer, size ) )
{
printk( "e2prom_write : copy_from_user failed. \n" ) ;
return -EFAULT ;
}
spin_lock ( &priv->lock ) ;
I2C_Start () ;
Write_I2C_Byte ( I2C_AT24CXX_ADDRESS ) ;
I2C_Ack () ;
Write_I2C_Byte ( priv->address ) ;
I2C_Ack () ;
for ( i = 0; i < size; i++ )
{
printk( "0x%x ", data[i] ) ;
Write_I2C_Byte ( data[i] ) ;
I2C_Ack () ;
}
I2C_Stop () ;
spin_unlock ( &priv->lock ) ;
printk( "\n" ) ;
if ( i == 0 )
{
return -EFAULT ;
}
return size ;
}
static int e2prom_ioctl ( struct inode *inode, struct file *fptr, unsigned int cmd, unsigned long arg )
{
struct e2prom_private *priv = (struct e2prom_private *) fptr->private_data ;
priv->address = (unsigned char)arg ;
if ( priv->address >= I2C_AT24C02_MAXSIZE || priv->address < 0x00 )
{
printk( "e2prom_ioctl : the address you specificed is overflow e2prom area .\n" ) ;
return -EFAULT ;
}
return 0 ;
}
static int e2prom_init ( void )
{
int status = 0 ;
memset ( &e2prom_priv, 0, sizeof (struct e2prom_private) ) ;
InterfaceInit () ;
spin_lock_init ( &e2prom_priv.lock ) ;
e2prom_priv.ref_cnt = 0 ;
e2prom_priv.address = 0x00 ;
status = register_chrdev (major, E2PROM_DEV_NAME, &e2prom_fops) ;
if ( status < 0 )
{
printk ( "e2prom_init : cannot get major number .\n" ) ;
return status ;
}
else if ( major == 0 )
{
major = status ;
}
return 0 ;
}
static void e2prom_exit ( void )
{
unregister_chrdev ( major, E2PROM_DEV_NAME) ;
}
module_init ( e2prom_init ) ;
module_exit ( e2prom_exit ) ;
makefile
kerdir=/root/8655/smp86xx_kernel_source_R2.6.22-19/linux-2.6.22.19/
obj-m := e2prom.o
modules:
$(MAKE) -C $(kerdir) M=$(shell pwd) modules
clean:
rm -rf *.o *~ core .depend .*.cmd *.ko *.mod.c .tmp_versions
测试程序
#include <string.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/ioctl.h>
#include <fcntl.h>
#include <linux/types.h>
#include <time.h>
#include <sys/time.h>
#include <iostream>
#include <stdlib.h>
#include "e2prom.h"
using namespace std ;
int main (int argc, char *argv[])
{
int fd ;
unsigned char dataA[4] = { 0xaa, 0xbb, 0xcc, 0xdd } ;
unsigned char dataB[4] = { 0x00, } ;
unsigned char address = 0x00 ;
fd = open ( "/dev/e2prom", O_RDWR ) ;
if ( fd == -1 )
{
printf( "Open device e2prom failed .\n" ) ;
return false ;
}
if ( ioctl( fd, E2PROM_WRITE_READ, address ) < 0 )
{
printf( "ioctl failed .\n" ) ;
close ( fd ) ;
return false ;
}
if ( write ( fd, (char*)dataA, 4 ) != 4 )
{
printf( "Write device e2prom failed .\n" ) ;
close ( fd ) ;
return false ;
}
if ( ioctl( fd, E2PROM_WRITE_READ, address ) < 0 )
{
printf( "ioctl failed .\n" ) ;
close ( fd ) ;
return false ;
}
if ( read ( fd, dataB, 4 ) != 4 )
{
printf( "Read device e2prom failed .\n" ) ;
close ( fd ) ;
return false ;
}
printf( "dataB : 0x%x, 0x%x, 0x%x, 0x%x\n", dataB[0], dataB[1], dataB[2], dataB[3] ) ;
close ( fd ) ;
return EXIT_SUCCESS ;
}