pciback1.c

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

//test motion control card
//	test how to read and write I/O mem and I/O port region!finish
#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 <linux/time.h>
#include "pciioctl.h"
#define IK_VENDOR 0x10b5
#define IK_DEVICE 0x9050
#define DRV_NAME "IK220"
static RT_TASK task_one;
MODULE_LICENSE("GPL");
EXPORT_NO_SYMBOLS;
u32 IK_IOBASE;
unsigned long tv_now;
unsigned long tv_just;
//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);

unsigned long io_base1,io_base2,mem_base1,mem_base2;
/*
	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,i;
	long addr;
	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);
	}

	io_base1=pci_resource_start(dev,2);
	io_base2=pci_resource_end(dev,2);
	printk("long =%lx ",io_base2);
	printk("long%x-%x =%ld ",io_base2,io_base1,io_base2-io_base1+1);

	mem_base1=pci_resource_start(dev,0);
	mem_base2=pci_resource_end(dev,0);
	printk("longmem =%lx \t",mem_base1);
	printk("longmem%x-%x =%ld\n ",mem_base2,mem_base1,mem_base2-mem_base1+1);

	if(check_mem_region(mem_base1,200))
	{
		printk("erro!!!!!!!!!");
		return -1;
	}
		request_mem_region(mem_base1,200,DRV_NAME);	
		
	if(check_region(io_base1,0x10))
	{
		printk("error");
		return -1;
	}	
		request_region(io_base1,0x10,DRV_NAME);	
		outl(0x400,io_base1+10);
	ionum=100;
	for(i=0;i<10;i++)
	{
		ionum=inw(io_base1);
		if(ionum!=0)
			printk("in=%d",ionum);
	}
		outw(100,io_base1+300);
		ionum=inw(io_base1+300);	
		printk("in=%d i=%d",ionum,i);
	
		
		addr=ioremap(mem_base1,0x10);
		writel(0x1111,addr+0x10);
		ionum=readl(addr+0x10);
	
		printk("mem=%x i=%d",ionum,i);

	return 0;
}

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

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)
	{
		tv_now=rt_get_time_ns();
		printk("now in rt_task\t us=%ld",tv_now-tv_just);
		tv_just=tv_now;
		rt_task_wait_period();
	}
}

static int __init IK_init_module(void)
{
//	struct pci_dev *matroxdev; 
	int result=register_chrdev(140,"PCI_IK",&IK_fops);
		tv_just=rt_get_time_ns();
	rt_task_init(&task_one,IK_task,0,10000,0,1,0);
	rt_set_oneshot_mode();
	start_rt_timer(1);
	
//	matroxdev=pci_find_slot(0x02,0x50);
//	printk("irq=%d\t",matroxdev->irq);
//	printk("vendor=%x\tdevice=%x\t",matroxdev->vendor,matroxdev->device);

	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);