#include <linux/module.h>

#include <linux/kernel.h> #include <linux/fs.h> #include <linux/errno.h> #include <linux/types.h> #include <linux/fcntl.h> #include <linux/cdev.h> #include <linux/version.h> #include <linux/vmalloc.h> #include <linux/ctype.h> #include <linux/pagemap.h> #include <linux/delay.h> #include <linux/miscdevice.h>

#include <mach/regs-gpio.h>

#include <mach/gpio.h> #include <mach/hardware.h> #include <mach/map.h> #include <asm/io.h> #include <asm/irq.h> #include <asm/signal.h> #include <asm/uaccess.h> #include <plat/regs-timer.h> #include <plat/gpio-cfg.h> #include <mach/gpio-bank-n.h>

#define DEVICE_NAME "yzh_temper"

#define DQ_input  s3c_gpio_cfgpin(S3C64XX_GPN(8),S3C64XX_GPN_INPUT(8))

#define DQ_output s3c_gpio_cfgpin(S3C64XX_GPN(8),S3C64XX_GPN_OUTPUT(8))

#define DQ_set_up s3c_gpio_cfgpin(S3C64XX_GPN(8),S3C_GPIO_PULL_UP)

#define DQ_set_down  s3c_gpio_cfgpin(S3C64XX_GPN(8),S3C_GPIO_PULL_DOWN) #define DQ_set_none s3c_gpio_cfgpin(S3C64XX_GPN(8),S3C_GPIO_PULL_NONE)

unsigned int DQ_read(void) {  unsigned int temp;    temp = __raw_readl(S3C64XX_GPNDAT);  temp = temp & (1 << 8);    return temp; }

void DQ_set(unsigned int value)

{  unsigned int temp;    temp = __raw_readl(S3C64XX_GPNDAT);  temp &= ~(1 << 8);  temp |= (value << 8);  __raw_writel(temp,S3C64XX_GPNDAT); } 

static void temper_reset(void)

{  unsigned int level = 1;

 DQ_output;

   DQ_set(1);  udelay(20);  DQ_set(0);  udelay(480);  DQ_set(1);  udelay(60);      DQ_input;  level = DQ_read();  printk("%x  \n\r",level);  udelay(480);  DQ_output;  DQ_set(1);  }

static void temper_byte_program(unsigned char dat) {  int i;  DQ_output;    for(i=0;i<8;i++)  {        DQ_set(1);  //start write   udelay(2);    DQ_set(0);          if(dat & 0x01)   {    DQ_set(1);   }   else   {    DQ_set(0);   }   udelay(60);   dat >>= 1;    }  DQ_set(1); }   unsigned int temper_byte_read(void) {  int j;  unsigned int result = 0;

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

 {   DQ_output;   DQ_set(0);   udelay(2);   DQ_set(1);   udelay(4);      DQ_set(0);   udelay(2);    DQ_set(1);   udelay(8);      result >>= 1;   DQ_input;   if(DQ_read() == 0)   {    result &= ~0x80;   }   else   {    result |= 0x80;   }   udelay(50);  }  DQ_output;  DQ_set(1);  return result; }    int temper_init(void) {  unsigned int value_h;  unsigned int value_l;  unsigned int total;    temper_reset();  temper_byte_program(0xcc);  temper_byte_program(0x44);  mdelay(30);    temper_reset();  temper_byte_program(0xcc);  temper_byte_program(0xbe);    value_l = temper_byte_read();  value_h = temper_byte_read();    // printk("value:  %x %x \n\r",value_l,value_h);    value_h <<= 8;

 total = value_h | value_l;

// printk("the temper_value:  %x \n\r",total);    return total;    }

void temper_test(void)

{  int i;  int ret;    for(i=0;i<10;i++)  {   ret = temper_init();       mdelay(500);  } }

 

static int temper_open(struct inode *inode, struct file *filp) {  temper_reset(); // temper_test();  printk("the 18b20 has reset \n\r");   return 0; }

static int temper_release(struct inode *inode, struct file *filp) {  printk("the 18b20 has released \n\r");    return 0; }

ssize_t temper_read(struct file *filp, char __user *buffer, size_t count, loff_t *ppos)

{  int value;  int err;    value = temper_init();

 err = copy_to_user(buffer,&value,sizeof(value));

 return min(sizeof(value),count);   }

static struct file_operations temper_fps = {

 .owner = THIS_MODULE,  .open = temper_open,  .read = temper_read,  .release = temper_release, };

static struct miscdevice temper_misc = {

 .minor = MISC_DYNAMIC_MINOR,  .name = DEVICE_NAME,  .fops = &temper_fps, };

static int temper_init_up(void)

{  int ret;    ret = misc_register(&temper_misc);  printk("18b20 module has up \n\r");    return ret; }

static void temper_exit_remove(void)

{  misc_deregister(&temper_misc);  printk("18b20 module has remove\n\r"); }

module_init(temper_init_up); module_exit(temper_exit_remove);

MODULE_LICENSE("GPL");