backup.c

个人根据海德汉平面光栅Windows下的程序编写得Linux下的驱动程去源码

#ifndef __KERNEL__
#	define __KERNEL__
#endif
#ifndef MODULE
#	define MODULE
#endif
#define __NO_VERSION__
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/errno.h>
#include <linux/pci.h>
#include <math.h>
#include <asm/io.h>
#include <asm/segment.h>
#include <linux/fs.h>
#include <linux/init.h>
#include <linux/delay.h>
#include <linux/poll.h>
#include <asm/uaccess.h>
#include <rtai_sched.h>
#include <rtai_leds.h>
#include <rtai_fifos.h>
#include <rtai_shm.h>
#include <linux/ioctl.h>
#include "pciioctl.h"
#define IK_VENDOR 0x8086
#define IK_DEVICE 0x24c5
#define DRV_NAME "IK220"
static RT_TASK task_one;
MODULE_LICENSE("GPL");
EXPORT_NO_SYMBOLS;

u32 IK_IOBASE;

//read_write_t IK_read(struct inode *inode,struct file *filp,char *buf,count_t count);
//read_write_t IK_write(struct inode *inode,struct file *filp,char *buf,count_t count);
int IK_open(struct inode *inode,struct file *filp);
int IK_release(struct inode *inode,struct file *filp);
int IK_ioctl(struct inode *inode,struct file *filp,unsigned int cmd,unsigned long arg);

/*
	file operations for user to control kernel module
*/

static struct file_operations IK_fops=
{
	owner:		THIS_MODULE,
//	read:		IK_read,
//	write:		IK_write,
	open:		IK_open,
	release:	IK_release,
	ioctl:		IK_ioctl,
};

int IK_open(struct inode *inode,struct file *filp)
{
	MOD_INC_USE_COUNT;
	printk("now open the device\n");
	return 0;
}	

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

/*
	ioctls
*/

int IK_ioctl(struct inode *inode,struct file *filp,unsigned int cmd,unsigned long arg)
{
	int ret=0;
	switch(cmd) {
//	#ifdef IK_DEBUG
		case IK_IOCHARDRESET:
		while(MOD_IN_USE)
			MOD_DEC_USE_COUNT;
		MOD_INC_USE_COUNT;
//	#endif
		case IK_IOCSTART:
			sample_period=1000000000;
			rt_task_make_periodic_relative_ns(&task_one,0,sample_period);		
			ret=1;
			break;
		case IK_IOCSTOP:
			rt_task_suspend(&task_one);
			ret=2;
			break;
		case IK_IOCREAD:
			break;
		default:
			return -ENOTTY;
	}
	return ret;
}

/*
	PCI drivers for getting IK_card informations
*/
	
static struct pci_device_id IK_pci_tbl[] __initdata={
	{IK_VENDOR,IK_DEVICE,PCI_ANY_ID,PCI_ANY_ID,0,0,0},
	{0,}
};

/*	
	Get card informations get iobase port address,memory address,
	configure port address...
	Initialize registers
*/
static int __init IK_probe(struct pci_dev *dev,const struct pci_device_id *id)
{	
	int ionum;
	if(pci_enable_device(dev))
		return -EIO;	
	printk("irq=%d",dev->irq);
	for(ionum=0;ionum<6;ionum++)
	{
		IK_IOBASE=pci_resource_start(dev,ionum);
		if(IK_IOBASE!=0)
			printk("IOBASE%d=%x ",ionum,IK_IOBASE);
	}
	return 0;
}

/*
	Free memory space 
	Unregisting all...
*/
static void __devexit IK_remove(struct pci_dev *dev)
{
	printk("remove device irq=%d\n",dev->irq);
}

static struct pci_driver IK_driver={
	name:DRV_NAME,
	id_table:IK_pci_tbl,
	probe:IK_probe,
	remove:__devexit_p(IK_remove),
};

/*
 *	Task for get x,y axis data and save them in memory 
 *	or put them to user space and do control with the data 
 */

static void IK_task(int fifo)
{
	while(1)
	{
		printk("now in rt_task\t");
		rt_task_wait_period();
	}
}

static int __init IK_init_module(void)
{
	int result=register_chrdev(140,"PCI_IK",&IK_fops);
	rt_task_init(&task_one,IK_task,0,10000,0,1,0);
	rt_set_oneshot_mode();
	start_rt_timer(1);
	if(result<0)
	{
	 	printk("PCI_IK:can't register"); 
	 	return result;
	}
	else
		return pci_module_init(&IK_driver);
}
static void __exit IK_cleanup_module(void)
{
	unregister_chrdev(140,"PCI_IK");
	pci_unregister_driver(&IK_driver);
	printk("test finished!");

}	

module_init(IK_init_module);
module_exit(IK_cleanup_module);