linux at24c64驱动,ARM11 GPIO口模拟I2C驱动AT24C08

简单的测试通信时序

#include

#include

#include

#include

#include

#include

#include

#include

#include

#include

#include

#include

#include

#include

#include

#include

#include

#include

#include

#include

#include

#include

#include

#include

#define write_cmd 0xa0

#define read_cmd 0xa1

#define SDA_output  s3c_gpio_cfgpin(S3C64XX_GPB(6),S3C_GPIO_OUTPUT)

#define SDA_input   s3c_gpio_cfgpin(S3C64XX_GPB(6),S3C_GPIO_INPUT)

//#define SDA_output  s3c_gpio_cfgpin(S3C64XX_GPB(6),S3C64XX_GPB_OUTPUT(6))

//#define SDA_input   s3c_gpio_cfgpin(S3C64XX_GPB(6),S3C64XX_GPB_INPUT(6))

#define SCLK_output s3c_gpio_cfgpin(S3C64XX_GPB(5),S3C64XX_GPB_OUTPUT(5))

#define DEVICE_NAME "yzh_eeprom"

void SDA_set(unsigned int value)

{

int temp;

temp = __raw_readl(S3C64XX_GPBDAT);

temp &= ~(1<<6);

temp |= (value << 6);

__raw_writel(temp,S3C64XX_GPBDAT);

}

unsigned int Get_SDA(void)

{

int tmp;

tmp = __raw_readl(S3C64XX_GPBDAT);

tmp = tmp & (1 << 6);

return tmp;

}

void SCLK_set(unsigned int value)

{

int tp;

tp = __raw_readl(S3C64XX_GPBDAT);

tp &= ~(1<<5);

tp |= (value << 5);

__raw_writel(tp,S3C64XX_GPBDAT);

}

void AT_eeprom_start(void)

{

SDA_output;

SCLK_output;

SDA_set(1);

SCLK_set(1);

mdelay(1);

SDA_set(0);

mdelay(2);

SCLK_set(0);

udelay(10);

}

void AT_eeprom_stop(void)

{

SDA_output;

SCLK_output;

SCLK_set(1);

SDA_set(0);

mdelay(1);

SDA_set(1);

mdelay(2);

SCLK_set(0);

udelay(10);

}

void master_noack(void)

{

SDA_output;

SCLK_output;

SDA_set(1);

mdelay(3);

SCLK_set(0);

mdelay(2);

SCLK_set(1);

SCLK_set(0);

mdelay(2);

}

unsigned int master_get_ack(void)

{

int ack;

SDA_output;

SCLK_output;

SDA_set(1);

SCLK_set(0);

mdelay(3);

SDA_input;

SCLK_set(1);

mdelay(5);

ack = Get_SDA();

SCLK_set(0);

return ack;

}

void AT_eeprom_byte_program(unsigned int dat)

{

int i;

SDA_output;

SCLK_output;

SDA_set(1);

for(i=0; i<8; i++)

{

if(dat & 0x80)

{

SDA_set(1);

}

else

{

SDA_set(0);

}

// udelay(100);

SCLK_set(1);

udelay(100);

SCLK_set(0);

dat <<= 1;

}

}

unsigned int AT_eeprom_byte_read(void)

{

int j;

unsigned int result = 0;

SCLK_output;

SDA_input;

SCLK_set(0);

udelay(10);

for(j=0; j<8; j++)

{

result <<= 1;

SCLK_set(0);

udelay(10);

SCLK_set(1);

udelay(10);

//  result |= Get_SDA();

if(Get_SDA() == 0)

{

result &= ~0x01;

}

else

{

result |= 0x01;

}

}

return result;

}

void AT_eeprom_write(unsigned int addr,unsigned int dat)

{

int ack_flag =1;

AT_eeprom_start();

udelay(200);

AT_eeprom_byte_program(write_cmd);

udelay(200);

ack_flag = master_get_ack();

printk("write_1: %x \n",ack_flag);

if(ack_flag == 0)

{

AT_eeprom_byte_program(addr);

ack_flag = master_get_ack();

printk("write_2: %x \n",ack_flag);

if(ack_flag == 0)

{

AT_eeprom_byte_program(dat);

ack_flag = master_get_ack();

printk("write_3: %x \n",ack_flag);

if(ack_flag == 0)

{

AT_eeprom_stop();

udelay(200);

}

}

}

}

unsigned int AT_eeprom_read(unsigned int address)

{

int ack_read = 1;

unsigned int read_value = 0;

AT_eeprom_start();

udelay(200);

AT_eeprom_byte_program(write_cmd);

udelay(200);

ack_read = master_get_ack();

printk("read_1: %x \n",ack_read);

if(ack_read == 0)

{

AT_eeprom_byte_program(address);

ack_read = master_get_ack();

printk("read_2: %x \n",ack_read);

if(ack_read == 0)

{

AT_eeprom_start();

udelay(100);

AT_eeprom_byte_program(read_cmd);

ack_read = master_get_ack();

printk("read_3: %x \n",ack_read);

if(ack_read == 0)

{

read_value = AT_eeprom_byte_read();

master_noack();

AT_eeprom_stop();

udelay(100);

}

}

}

return read_value;

}

void eeprom_test(void)

{

unsigned int last_value = 0;

AT_eeprom_write(0x01,0x11);

last_value = AT_eeprom_read(0x01);

printk("eeprom_value1: %x \n\r",last_value);

AT_eeprom_write(0x01,0x22);

last_value = AT_eeprom_read(0x01);

printk("eeprom_value2: %x \n\r",last_value);

AT_eeprom_write(0x01,0x33);

last_value = AT_eeprom_read(0x01);

printk("eeprom_value3: %x \n\r",last_value);

}

static int eeprom_open(struct inode *inode, struct file *filp)

{

printk("the eeprom module has opened \n\r");

eeprom_test();

return 0;

}

static int eeprom_release(struct inode *inode, struct file *filp)

{

printk("the eeprom module has release \n\r");

return 0;

}

static struct file_operations eeprom_fops = {

.open = eeprom_open,

.release = eeprom_release,

};

static struct miscdevice eeprom_misc = {

.minor = MISC_DYNAMIC_MINOR,

.name = DEVICE_NAME,

.fops = &eeprom_fops,

};

static int eeprom_init(void)

{

int ret;

ret = misc_register(&eeprom_misc);

printk("the eeprom module has up \n\r");

return ret;

}

static void eeprom_exit(void)

{

misc_deregister(&eeprom_misc);

printk("the eeprom module has exit \n\r");

}

module_init(eeprom_init);

module_exit(eeprom_exit);

MODULE_LICENSE("GPL");