/*FPGA1 driver by Xue, Zhenwu*/

#define __NO_VERSION__

#ifndef MODULE
#define MODULE
#endif

#ifndef __KERNEL__
#define __KERNEL__
#endif

#include <linux/config.h>
#include <linux/module.h>
#include <linux/version.h>
#include <linux/kernel.h>   
#include <linux/fs.h>      
#include <linux/types.h>
#include <linux/slab.h>
#include <asm/io.h>
#include <asm/errno.h>
#include "fpga1_drv.h"

static unsigned int fpga1_proc_numbers = 0;
static major_number = 248;
int Debug = 0;

int fpga1_open(struct inode *inode, struct file *file)
{	
  if(fpga1_proc_numbers == 0){
    VA_FPGA1_DIVIDER = (unsigned long *)ioremap(PA_FPGA1_DIVIDER, 4);
    VA_PLL1700_SET_REG = (unsigned long *)ioremap(PA_PLL1700_SET_REG, 4);
    VA_PCM3006_SET_REG = (unsigned long *)ioremap(PA_PCM3006_SET_REG, 4);
    VA_AUDIO_MOD_SWITCH = (unsigned long *)ioremap(PA_AUDIO_MOD_SWITCH, 4);
    VA_AUDIO_MOD_STATE = (unsigned long *)ioremap(PA_AUDIO_MOD_STATE, 4);
    
    VA_ADSP_CNTL = (unsigned long *)ioremap(PA_ADSP_CNTL, 4);
    VA_ADSP_VPORT_CNTL = (unsigned long *)ioremap(PA_ADSP_VPORT_CNTL, 4);
    VA_ADSP_MCBSP_CNTL = (unsigned long *)ioremap(PA_ADSP_MCBSP_CNTL, 4);
    VA_BDSP_CNTL = (unsigned long *)ioremap(PA_BDSP_CNTL, 4);
    VA_BDSP_VPORT_CNTL = (unsigned long *)ioremap(PA_BDSP_VPORT_CNTL, 4);
    VA_BDSP_MCBSP_CNTL = (unsigned long *)ioremap(PA_BDSP_MCBSP_CNTL, 4);

    if(Debug>0){
      printk("<0>VA_FPGA1_DIVIDER = 0x%08X\n", VA_FPGA1_DIVIDER);
      printk("<0>VA_PLL1700_SET_REG = 0x%08X\n", VA_PLL1700_SET_REG);
      printk("<0>VA_PCM3006_SET_REG = 0x%08X\n", VA_PCM3006_SET_REG);
      printk("<0>VA_AUDIO_MOD_SWITCH = 0x%08X\n", VA_AUDIO_MOD_SWITCH);
      printk("<0>AUDIO_MOD_STATE = 0x%08X\n", VA_AUDIO_MOD_STATE);

      printk("<0>VA_ADSP_CNTL = 0x%08X\n", VA_ADSP_CNTL);
      printk("<0>VA_ADSP_VPORT_CNTL = 0x%08X\n", VA_ADSP_VPORT_CNTL);
      printk("<0>VA_ADSP_MCBSP_CNTL = 0x%08X\n", VA_ADSP_MCBSP_CNTL);
      printk("<0>VA_BDSP_CNTL = 0x%08X\n", VA_BDSP_CNTL);
      printk("<0>VA_BDSP_VPORT_CNTL = 0x%08X\n", VA_BDSP_VPORT_CNTL);
      printk("<0>VA_BDSP_MCBSP_CNTL = 0x%08X\n", VA_BDSP_MCBSP_CNTL);
    }
    fpga1_proc_numbers = 1;
    return 0;
  }else{
    return -1;   
  }
}

int fpga1_ioctl(struct inode *inode, struct file *filp,
                 unsigned int cmd, unsigned long arg)
{
   int ret;
   unsigned long* arg_pt = (unsigned long*) arg;
   unsigned long value;

   if(fpga1_proc_numbers == 0){
     return -1;
   }

   value = arg_pt[0];

   if(Debug>0){
     printk("<1>Argument is 0X%08X\n", value);
   }

   switch(cmd){
     case SET_FPGA1_DIVIDER:
       ret = writel(value, VA_FPGA1_DIVIDER);
       break;
     case SET_PLL1700_SET_REG:
       ret = writel(value, VA_PLL1700_SET_REG);
       break;
     case SET_PCM3006_SET_REG:
       ret = writel(value, VA_PCM3006_SET_REG);
       break;
     case SET_AUDIO_MOD_SWITCH:
       ret = writel(value, VA_AUDIO_MOD_SWITCH);
       break;
     case GET_AUDIO_MOD_STATE:
       ret = readl(VA_AUDIO_MOD_STATE);
       break;
    
     case SET_ADSP_CNTL:
       ret = writel(value, VA_ADSP_CNTL);
       break;
     case SET_ADSP_VPORT_CNTL:
       ret = writel(value, VA_ADSP_VPORT_CNTL);
       break;
     case SET_ADSP_MCBSP_CNTL:
       ret = writel(value, VA_ADSP_MCBSP_CNTL);
       break;     
     case SET_BDSP_CNTL:
       ret = writel(value, VA_BDSP_CNTL);
       break;
     case SET_BDSP_VPORT_CNTL:
       ret = writel(value, VA_BDSP_VPORT_CNTL);
       break;
     case SET_BDSP_MCBSP_CNTL:
       ret = writel(value, VA_BDSP_MCBSP_CNTL);
       break;     

     default:
       ret = -1;
       break;
   }

   return ret;
}

int fpga1_release(struct inode *inode,struct file *file)
{
  if(fpga1_proc_numbers == 1){
    iounmap(VA_FPGA1_DIVIDER);
    iounmap(VA_PLL1700_SET_REG);
    iounmap(VA_PCM3006_SET_REG);
    iounmap(VA_AUDIO_MOD_SWITCH);
    iounmap(VA_AUDIO_MOD_STATE);

    iounmap(VA_ADSP_CNTL);
    iounmap(VA_ADSP_VPORT_CNTL);
    iounmap(VA_ADSP_MCBSP_CNTL);
    iounmap(VA_BDSP_CNTL);
    iounmap(VA_BDSP_VPORT_CNTL);
    iounmap(VA_BDSP_MCBSP_CNTL);

    fpga1_proc_numbers = 0;
    return 0;
  }else{
    return -1;
  }
}

struct file_operations fpga1_fops = {
  open:    fpga1_open,
  ioctl:   fpga1_ioctl,
  release: fpga1_release 
};

int init_module()
{
  int ret;
  
  ret = register_chrdev(major_number, "fpga1", &fpga1_fops);

  if(ret<0){
    printk("<1>Error: This major number has been used by another device!\n");
    ret -1;
  }else
    printk("<1>Info: Device fpga1 initialized!\n");
    return 0;
} 

void cleanup_module()
{
  if(major_number>=0)
    unregister_chrdev(major_number, "fpga1");
}

MODULE_PARM(Debug, "i");