#define __NO_VERSION__
#ifndef __KERNEL__
#define __KERNEL__
#endif
#ifndef MODULE
#define MODULE
#endif
#include <linux/module.h>
#include <linux/config.h>
#ifdef CONFIG_SMP
#define __SMP__
#endif
MODULE_LICENSE("GPL");

#include <linux/version.h>
#include <linux/kernel.h>
#include <linux/fs.h>
#include <linux/mm.h>
#include <asm/uaccess.h>
#include <stdio.h>
#include <linux/types.h>
#include <linux/sched.h>
#include <linux/pm.h>
#include <linux/init.h>
#include <linux/miscdevice.h>
#include <linux/delay.h>
#include <linux/poll.h>
#include <linux/spinlock.h>
#include <linux/irq.h>
#include <linux/delay.h>
#include <asm/hardware.h>
#include <asm/arch/cpu_s3c2410.h>
#include <asm/io.h>
#include <asm/arch/S3C2410.h>

static int spi_open(struct inode *inode, struct file *file);
static int spi_release(struct inode *inode, struct file *filp);
static ssize_t spi_write(struct file *filp, const char *buf, size_t count);
static ssize_t spi_read(struct file *filp, char *buf, size_t count);

static struct file_operations spi_fops = 
{
   owner: THIS_MODULE,
   write: spi_write,
   read: spi_read,
   open: spi_open,
   release: spi_release,
};

#define DEVICE_NAME "SPI"
#define SPI_MAJOR 201
#define SPI_MINOR 0
int TXData[16];
int result;

static int __init spi_init(void)
{   
   result = register_chrdev(201, "SPI", &spi_fops);
   if (result < 0) 
   {
      cleanup_module();
      return result;
   }
   else
   {
      printk("The major is:%d\n",result);
      return 0;
   }
}

static void __exit spi_cleanup(void)
{
   unregister_chrdev(SPI_MAJOR, "SPI");
   printk(DEVICE_NAME " unloaded\n");
}

static int spi_open(struct inode *inode, struct file *file)
{
   MOD_INC_USE_COUNT;
   GPACON&=0xfeffff;
   GPBUP|=0x600;
   GPBCON=(GPECON&0xc3ffff)|0x140000;
   GPEUP|=0x3fe0;
   GPECON=(GPECON&0xf00003ff)|0x0a800000;
   GPFUP|=0x05;
   GPFCON=(GPFCON&0xffcc)|0x0011;
   GPGUP|=0x0804;
   GPGCON=(GPGCON&0xff3fffcf)|0x00000030;
   GPHUP|=0x030;
   GPHCON=(GPHCON&0xfff0ff)|0x000500;
   SPPRE0=0x05;
   SPCON0=(SPCON0&0x80)|0x1f;
   SPPIN0=(SPPIN0&0xF8)|0x02;
   GPADAT|=0x010000;
   GPBDAT|=0x600;
   return 0;
}

static int spi_release(struct inode *inode, struct file *filp)
{
   MOD_DEC_USE_COUNT;
   return 0;
}

static ssize_t spi_write(struct file *filp, const char *buf, size_t count)
{
   int i,k,dout[4];
   if(*(buf+24)==0)
   {
      for(i=0;i<2;i++)
      {
         TXData[i]=*(buf+i*4);
      }
      if(SPSTA0&0x01)
      {
         for(i=0;i<2;i++)
         {
            if(i%2==0)
            {
               GPBDAT&=0xbff;
            }
            SPTDAT0=TXData[i];
            while(!SPSTA0)
            {}
            if((i+1)%2==0)
            {
               GPBDAT|=0x400;
            }
         }
      }
   }
   else
   {
      GPFDAT&=0xfa;
      GPHDAT&=0xfcf;
      for(k=0;k<4;k++)
      {
         dout[k]=*(buf+4*(k+2));
      }
      if(dout[0]&0x01)
      {
         GPFDAT|=0x04;
      }
      else
      {
         GPFDAT&=0xfb;
      }
      if(dout[1]&0x01)
      {
         GPFDAT|=0x01;
      }
      else
      {
         GPFDAT&=0xfe;
      }
      if(dout[2]&0x01)
      {
         GPHDAT|=0x020;
      }
      else
      {
         GPHDAT&=0xfdf;
      }
      if(dout[3]&0x01)
      {
         GPHDAT|=0x010;
      }
      else
      {
         GPHDAT&=0xfef;
      }
   }
   return count;
}

static ssize_t spi_read(struct file *filp, char *buf, size_t count)
{   
   int j,l,din[6];
   GPBDAT&=0xdff;
   if(SPSTA0&0x01)
   {
      SPTDAT0=0x10;
      while(!SPSTA0)
      {}
   }
   if(SPSTA0&0x01)
   {
      SPTDAT0=0x74;
      while(!SPSTA0)
      {}
   }
   if(SPSTA0&0x01)
   {
      for(j=0;j<16;j=j+2)
      {
         SPTDAT0=0x86+8*j/2;
         while(!SPSTA0)
         {}
         SPTDAT0=0;
         while(!SPSTA0)
         {}
         if(SPSTA0&0x01)
         {
            *(buf+j)=SPRDAT0;
         }
         while(!SPSTA0)
         {}
         if(SPSTA0&0x01)
         {
            *(buf+j+1)=SPRDAT0;
         }
         while(!SPSTA0)
         {}
      }
   }
   GPBDAT|=0x200;
   for(j=0;j<6;j++)
   {
      l=GPEDAT>>5;
      l&=0x003f;
      l=l>>j;
      l&=0x01;
      if(l&0x01)
      {
         *(buf+16+j)=1;
      }
      else
      {
         *(buf+16+j)=0;
      }
   }
   return count;
}

module_init(spi_init);
module_exit(spi_cleanup);