jni學習實例（一）-a7105模塊驅動之driver

#include <linux/module.h>
#include <linux/init.h>
#include <linux/device.h>
#include <linux/errno.h>
#include <linux/err.h>
#include <linux/kernel.h>
#include <linux/kmemcheck.h>
#include <linux/ctype.h>
#include <linux/delay.h>
#include <linux/idr.h>
#include <linux/sched.h>
#include <linux/slab.h>
#include <linux/interrupt.h>
#include <linux/platform_device.h>
#include <linux/signal.h>
#include <linux/miscdevice.h>
#include <asm/uaccess.h>

#include <linux/time.h>
#include <linux/timer.h>
#include <linux/ktime.h>

#include <mach/sys_config.h>
#include <mach/gpio.h>
#include <linux/clk.h>
#include <linux/gpio.h>
#include <linux/input.h>
#include <asm/irq.h>
#ifdef CONFIG_HAS_EARLYSUSPEND
	#include <linux/earlysuspend.h>
#endif

#include "a7105-spi_moni.c"
#if 0
static unsigned int time_delay;
struct timer_list a7105_timer;

static void a7105_timer_func(unsigned long data)
{
	printk("%s,%d\n",__func__,__LINE__);
	a7105_send_receive();
	//a7105_receive();
    mod_timer(&a7105_timer, jiffies +  time_delay);
}
#endif

//文件的寫函數
static ssize_t a7105_write(struct file *filp, const char __user *buffer,
             size_t count, loff_t *ppos)
{
	u8 TxBuf[64];
	int i = 0;
	
	if (count >= sizeof(TxBuf))
		return -2;
	
	pr_err("%s,%d\n",__func__,__LINE__);
    if( copy_from_user( &TxBuf, buffer, count ) ) //
    {
		printk("Can't Send Data !");
		return -EFAULT;
    }
	for(i=0; i<count;i++)
	{
		pr_err("%s,%d,%x\n",__func__,__LINE__,TxBuf[i]);
	}
	a7105_send(TxBuf);
    printk("OK! \n");
    return(10);
}

//文件的讀函數
static ssize_t a7105_read(struct file *filp, char __user *buffer,
              size_t count, loff_t *ppos)
{
	u8 RxBuf[8];
	int i = 0;
	
	pr_err("%s,%d\n",__func__,__LINE__);

	
	a7105_receive(RxBuf);
	for(i=0; i<8;i++)
	{
		pr_err("%s,%d,%x\n",__func__,__LINE__,RxBuf[i]);
	}
	if (copy_to_user(buffer, &RxBuf, sizeof(RxBuf))) {
			return -EFAULT;
	}
    printk("read \n");
    return (10);
}


static int a7105_open(struct inode *node, struct file *file)
{
	pr_err("%s,%d\n",__func__,__LINE__);
	initRF();
	return 0;
}

static int a7105_release(struct inode *node, struct file *file)
{
  pr_err("%s,%d\n",__func__,__LINE__);
  return 0;
}
static struct file_operations a7105_fops = {
  .owner = THIS_MODULE,
  .open = a7105_open,
  .write = a7105_write,
  .read = a7105_read,
  .release = a7105_release,
};

static struct miscdevice a7105_device = {
	.minor = MISC_DYNAMIC_MINOR,
	.name = "a7105_spi_moni",
	.fops = &a7105_fops,
};

static int __init a7105_spi_moni_probe(struct platform_device *pdev)
{
	int res;
	if(fetch_sysconfig_para()<0)
	{
		pr_err("fetch_sysconfig_para is failed!\n");
		return -1;
	}
#if 0
	printk("%s,%d\n",__func__,__LINE__);
	
	initRF();
	
	time_delay = 2*HZ;
	
	init_timer(&a7105_timer);
	a7105_timer.function = a7105_timer_func;
	mod_timer(&a7105_timer, jiffies +  time_delay );
	//send_and_receive();
#endif
	
	printk("%s,%d\n",__func__,__LINE__);
	
	res = misc_register(&a7105_device);
	if (res) {
		pr_err("%s: a7105_device register failed\n", __FUNCTION__);
	}
	
	return res;
}

static int a7105_spi_moni_suspend(struct platform_device *pdev, pm_message_t message)
{
	printk("%s,%d\n",__func__,__LINE__);
    return 0;
}

static int a7105_spi_moni_resume(struct platform_device *pdev)
{
	pr_err("%s,%d\n",__func__,__LINE__);
    return 0;
}

static int a7105_spi_moni_remove(struct platform_device *pdev)
{
	
	return 0;
}


static struct platform_device a7105_spi_moni_device = { 
    .name = "a7105_spi_moni",
	.id = -1,
};

static struct platform_driver a7105_spi_moni_driver = {
	.driver		= {
		.name	= "a7105_spi_moni",
		.owner	= THIS_MODULE,
	},

    .probe      = a7105_spi_moni_probe,
    .remove     = a7105_spi_moni_remove,
    .suspend    = a7105_spi_moni_suspend,
    .resume     = a7105_spi_moni_resume,
};

static int __init a7105_spi_moni_init(void) {
	int ret = 0;
	
	printk("%s,%d\n",__func__,__LINE__);
	ret = platform_device_register(&a7105_spi_moni_device);
	if (ret == 0) {
		ret = platform_driver_register(&a7105_spi_moni_driver);
	}
	if(ret){
        pr_err("ERR: platform_driver_probe failed\n");
        return -1;
    }
	return 0;
	
}

static void __exit a7105_spi_moni_exit(void) {
	platform_driver_unregister(&a7105_spi_moni_driver);
	platform_device_unregister(&a7105_spi_moni_device);
}

module_init(a7105_spi_moni_init);
module_exit(a7105_spi_moni_exit);


MODULE_DESCRIPTION("a7105 demo driver");
MODULE_AUTHOR("eken liujun");
MODULE_LICENSE("GPL");