pci16in16out/0040755000000000000000000000000007355303323011733 5ustar rootrootpci16in16out/distribution/0040755000000000000000000000000007355274545014467 5ustar rootrootpci16in16out/distribution/Readme.txt0100644000000000000000000000171607355274545016427 0ustar rootrootHere is the linux driver of Decision PCI 8in8out card. And this driver is tested well on the kernel with version 2.2.14. To decompress the file: tar -xvzf pci8in8outdist.tgz After you decompress the pci8in8outdist.tgz file, do the following steps: ->1.Login as root. ->2.chmod +x install ->3.chmod +x uninstall ->4.install After you run 4th step , you will see "Register Successful", then it will build a device node in "/dev" named "/dev/dpci8in8out". If you want to remove the driver , please run the 5th step. 5.uninstall Note: You can compile "test.c". It tests output of Decision 8in8out card. Another "test1.c" is used to test input. There are 2 function on this driver: int Write8In8OutPort(int file_desc,char data); - Use to send data. Where: file_desc data - the value to send char Read8In8OutPort(int file_desc); - Use to get data. Where: file_desc - is the file handle For more information please see the dpci8in8out.h pci16in16out/distribution/dpci8in8out.h0100644000000000000000000000065607355274545017022 0ustar rootroot #ifndef DPCI8IN8OUT_H #define DPCI8IN8OUT_H #include #define dpci8in8out_major 163 #define MAXCARD 4 #define REGIONLENGTH 8 #define DPCI8IN8OUT_WRITE_PORT _IOW(dpci8in8out_major, 0 , char) #define DPCI8IN8OUT_READ_PORT _IOR(dpci8in8out_major, 1 , char) #define DEVICE_NAME "dpci8in8out" char Read8In8OutPort(int file_desc); int Write8In8OutPort(int file_desc,char data); #endif pci16in16out/distribution/dpci8in8outlib.c0100644000000000000000000000052307355274545017475 0ustar rootroot#include "dpci8in8out.h" #include /* ioctl */ int Write8In8OutPort(int file_desc, char value) { int ret_val; ret_val = ioctl(file_desc, DPCI8IN8OUT_WRITE_PORT, value); return ret_val; } char Read8In8OutPort(int file_desc) { char ret_val; ioctl(file_desc, DPCI8IN8OUT_READ_PORT, &ret_val); return ret_val; } pci16in16out/distribution/test.c0100644000000000000000000000127007355274545015607 0ustar rootroot#include "dpci8in8out.h" #include "dpci8in8outlib.c" #include #include /* open */ #include /* exit */ #include /* Main - Call the ioctl functions */ main() { int file_desc, i,count=0; char buf[255]; char b=1; char *msg = "Message passed by ioctl\n"; sprintf(buf,"/dev/%s0\0",DEVICE_NAME); file_desc = open(buf, O_RDONLY); if (file_desc < 0) { printf ("Can't open device file: %s\n", buf); exit(-1); } Write8In8OutPort(file_desc,0x0); do{ Write8In8OutPort(file_desc,b); b=b<<1; count++; if(count%8==0) b=1; sleep(1); } while(count<1000); close(file_desc); } pci16in16out/distribution/test1.c0100644000000000000000000000112007355274545015662 0ustar rootroot#include "dpci8in8out.h" #include "dpci8in8outlib.c" #include #include /* open */ #include /* exit */ #include #include /* Main - Call the ioctl functions */ main() { int file_desc,data,i,j=0; char buf[255]; sprintf(buf,"/dev/%s0\0",DEVICE_NAME); file_desc = open(buf, O_RDONLY); if (file_desc < 0) { printf ("Can't open device file: %s\n", buf); exit(-1); } Write8In8OutPort(file_desc,0x65); printf("I write 0x65\n"); printf("I read %02x\n",Read8In8OutPort(file_desc)); close(file_desc); } pci16in16out/distribution/install0100755000000000000000000000113407355274545016057 0ustar rootroot#!/bin/sh module="dpci8in8out" device="dpci8in8out" group="root" mode="664" major="163" # invoke insmod with all arguments we got /sbin/insmod -f $module.o $* || exit 1 #major=`cat /proc/devices | awk "\\$2==\"$module\" {print \\$1}"` # Remove stale nodes and replace them, then give gid and perms # Usually the script is shorter, it's scull that has several devices in it. rm -f /dev/${device}[0-3] mknod /dev/${device}0 c $major 0 mknod /dev/${device}1 c $major 1 mknod /dev/${device}2 c $major 2 mknod /dev/${device}3 c $major 3 chgrp $group /dev/${device}[0-3] chmod $mode /dev/${device}[0-3] pci16in16out/distribution/uninstall0100755000000000000000000000026207355274545016423 0ustar rootroot#!/bin/sh module="dpci8in8out" device="dpci8in8out" # invoke rmmod with all arguments we got /sbin/rmmod $module $* || exit 1 # Remove stale nodes rm -f /dev/${device}[0-3] pci16in16out/distribution/dpci8in8out.o0100644000000000000000000000676407355274545017037 0ustar rootrootELFh4( UEf@*%;} 1 t&ÐU  1UEPRR*9Et *t&;}fM vÐUE9Eu 1 ÐUEfU UE‹E fÍvUVSEM]f@*@t t']jEPVjEPVv؊U1e[^ÍvUWVSE1@P@Ѓ~h@&u vVh!hffƃ tRUF8$;Phj4;|hj4; E}~u}hqURhUhhhE})1;}j4C;|Eh@1e[^_ÐUS1;} j4C;|hhh]L801.01kernel_version=2.2.14-3.0author=Deltadescription=Decision PCI 8in/8out Card DriverDisabling CPUID Serial number...done. <3>This drive only can open one time. PCI 8in/8out card:I got a base %x dpci8in8out I can't find any Decision PCI 8in/8out card here!! PCI 8in/8out card: Total %d cards that I catched! PCI 8in/8out card:Register Successful PCI 8in/8out card:Unregister Successful!! GCC: (GNU) egcs-2.91.66 19990314/Linux (egcs-1.1.2 release).symtab.strtab.shstrtab.text.rel.text.data.rel.data.bss.note.modinfo.rodata.comment@! d h +@D 1 ( ;@Fn O  W=`pP   $88LKI[@l@z ~7 ] @.XS.>ERaqLdpci8in8out.cgcc2_compiled.cardsdpci8in8out_releasedpci8in8out_readdpci8in8out_writedpci8in8out_fopsdev_count.468rev__module_kernel_versiondpci8in8out_open__this_moduleBase_AddrMyreadMywritedpci8in8out_ioctl__put_user_1__module_author__module_descriptioninit_modulepcibios_presentpci_find_deviceprintkcheck_regionrequest_regionregister_chrdevrelease_regioncleanup_moduleunregister_chrdev"=Cr|Hkt "'7<EJOY!kv{""$$pci16in16out/Makefile0100644000000000000000000000152607355275047013407 0ustar rootroot# Comment/uncomment the following line to enable/disable debugging #DEBUG = y # Change it here or specify it on the "make" commandline INCLUDEDIR = /usr/include ifeq ($(DEBUG),y) DEBFLAGS = -O -g -DSPULL_DEBUG # "-O" is needed to expand inlines else DEBFLAGS = -O2 endif CFLAGS = -D__KERNEL__ -DMODULE -Wall $(DEBFLAGS) CFLAGS += -I$(INCLUDEDIR) # Extract version number from headers. VER = $(shell awk -F\" '/REL/ {print $$2}' $(INCLUDEDIR)/linux/version.h) TARGET = dpci16in16out OBJS = $(TARGET).o SRC = $(TARGET).c all: .depend $(TARGET).o install: mkdir -p /lib/modules/$(VER)/misc /lib/modules/misc install -c $(TARGET).o /lib/modules/$(VER)/misc install -c $(TARGET).o /lib/modules/misc clean: rm -f *.o *~ core .depend depend .depend dep: $(CC) $(CFLAGS) -M *.c > $@ ifeq (.depend,$(wildcard .depend)) include .depend endif pci16in16out/Readme.txt0100644000000000000000000000172407355275126013703 0ustar rootrootHere is the linux driver of Decision PCI 8in8out card. And this driver is tested well on the kernel with version 2.2.14. To decompress the file: tar -xvzf pci8in8outdist.tgz After you decompress the pci8in8outdist.tgz file, do the following steps: ->1.Login as root. ->2.chmod +x install ->3.chmod +x uninstall ->4.install After you run 4th step , you will see "Register Successful", then it will build a device node in "/dev" named "/dev/dpci16in16out". If you want to remove the driver , please run the 5th step. 5.uninstall Note: You can compile "test.c". It tests output of Decision 8in8out card. Another "test1.c" is used to test input. There are 2 function on this driver: int Write16In16OutPort(int file_desc,char data); - Use to send data. Where: file_desc data - the value to send char Read16In16OutPort(int file_desc); - Use to get data. Where: file_desc - is the file handle For more information please see the dpci8in8out.h pci16in16out/dpci16in16out.h0100644000000000000000000000067607355301512014424 0ustar rootroot #ifndef DPCI16IN16OUT_H #define DPCI16IN16OUT_H #include #define dpci16in16out_major 165 #define MAXCARD 4 #define REGIONLENGTH 8 #define DPCI16IN16OUT_WRITE_PORT _IOW(dpci16in16out_major, 0 , int) #define DPCI16IN16OUT_READ_PORT _IOR(dpci16in16out_major, 1 , int) #define DEVICE_NAME "dpci16in16out" int Read16In16OutPort(int file_desc); int Write16In16OutPort(int file_desc,int data); #endif pci16in16out/install0100755000000000000000000000114007355301525013322 0ustar rootroot#!/bin/sh module="dpci16in16out" device="dpci16in16out" group="root" mode="664" major="165" # invoke insmod with all arguments we got /sbin/insmod -f $module.o $* || exit 1 #major=`cat /proc/devices | awk "\\$2==\"$module\" {print \\$1}"` # Remove stale nodes and replace them, then give gid and perms # Usually the script is shorter, it's scull that has several devices in it. rm -f /dev/${device}[0-3] mknod /dev/${device}0 c $major 0 mknod /dev/${device}1 c $major 1 mknod /dev/${device}2 c $major 2 mknod /dev/${device}3 c $major 3 chgrp $group /dev/${device}[0-3] chmod $mode /dev/${device}[0-3] pci16in16out/sysdep.h0100644000000000000000000002060607355274545013431 0ustar rootroot /* * sysdep.h -- fixes some problems of portability in the range 1.2 - 2.0 * * kdev_t for kernels < 1.3.28 * do_gettimeofday for kernels < 1.3.46 * request_irq/free_irq/SA_SHIRQ for kernels < 1.3.70 * FMODE_READ/FMODE_WRITE for kernels < 1.3.46 * ioctl definitions for kernels < 1.3.42 * get_user/put_user for kernels < 1.3.0 * __*_ENDIAN for kernels < 1.3.19 * put_unaligned etc for kernels < 1.99.6 * readb etc. for kernels < 1.3.4 * add_timer fir kernels < 1.3.14 * typing for count in read/write to account for differences in 2.1 * typing for offset in lseek to account for differences in 2.1 * *********/ #ifndef _ORABOOK_SYSDEP_H #define _ORABOOK_SYSDEP_H #ifndef VERSION_CODE # define VERSION_CODE(vers,rel,seq) ( ((vers)<<16) | ((rel)<<8) | (seq) ) #endif #include /* this is needed for functions I use here */ /* * Macros to fake kdev_t with old kernels */ #if LINUX_VERSION_CODE < VERSION_CODE(1,3,28) # define kdev_t dev_t /* two conversion functions are defined in newer kernels */ # define kdev_t_to_nr(dev) (dev) # define to_kdev_t(dev) (dev) #endif /* * Reimplement do_gettimeofday (with less precision) for versions * not exporting the true code */ #if LINUX_VERSION_CODE < VERSION_CODE(1,3,46) /* * kernel headers already declare the function as non-static. * We reimplement it with another name, and #define it */ extern inline void redo_gettimeofday(struct timeval *tv) { unsigned long flags; save_flags(flags); cli(); *tv = xtime; restore_flags(flags); } #define do_gettimeofday(tv) redo_gettimeofday(tv) #endif /* * 1.3.70 changed the semantics of irq request/free to allow shared irq's */ #if LINUX_VERSION_CODE < VERSION_CODE(1,3,70) /* the preprocessor is able to handle recursive definitions */ # define request_irq(irq,fun,fla,nam,dev) request_irq(irq,fun,fla,nam) # define free_irq(irq,dev) free_irq(irq) # define SA_SHIRQ 0 /* doesn't exist */ #endif /* * FMODE_READ was introduced in 1.3.46. * Explicit numbers were used before then */ #if LINUX_VERSION_CODE < VERSION_CODE(1,3,46) # define FMODE_READ 1 # define FMODE_WRITE 2 #endif /* * 1.3.22 added the full featured ioctl bitmasks and macros * but with _IOC_READ and _IOC_WRITE swapped. * Earlier kernels defined some of them, but not all. * Besides, macros in 1.2.x are really ugly to read. * 1.3.32 added _IOC_TYPE * 1.3.42 fixed _IOC_READ and _IOC_WRITE * * The errors are understandable in experimental kernels, but * try to fix them here. I, for one, still run 1.3.30 and 1.3.41, * which used to be very stable kernels. At the time no drivers used * such macros, so nobody noticed the were buggy. Since I uses them here, * I want them right. */ #if LINUX_VERSION_CODE < VERSION_CODE(1,3,22) # define _IOC_NRBITS 8 # define _IOC_TYPEBITS 8 # define _IOC_SIZEBITS 14 # define _IOC_DIRBITS 2 # define _IOC_NRMASK ((1 << _IOC_NRBITS)-1) # define _IOC_TYPEMASK ((1 << _IOC_TYPEBITS)-1) # define _IOC_SIZEMASK ((1 << _IOC_SIZEBITS)-1) # define _IOC_DIRMASK ((1 << _IOC_DIRBITS)-1) # define _IOC_NRSHIFT 0 # define _IOC_TYPESHIFT (_IOC_NRSHIFT+_IOC_NRBITS) # define _IOC_SIZESHIFT (_IOC_TYPESHIFT+_IOC_TYPEBITS) # define _IOC_DIRSHIFT (_IOC_SIZESHIFT+_IOC_SIZEBITS) # define _IOC_DIR(nr) (((nr) >> _IOC_DIRSHIFT) & _IOC_DIRMASK) # define _IOC_NR(nr) (((nr) >> _IOC_NRSHIFT) & _IOC_NRMASK) # define _IOC_SIZE(nr) (((nr) >> _IOC_SIZESHIFT) & _IOC_SIZEMASK) #endif #if LINUX_VERSION_CODE < VERSION_CODE(1,3,32) # define _IOC_TYPE(nr) (((nr) >> _IOC_TYPESHIFT) & _IOC_TYPEMASK) #endif #if LINUX_VERSION_CODE < VERSION_CODE(1,3,42) # undef _IOC_NONE # undef _IOC_WRITE # undef _IOC_READ # define _IOC_NONE 0U # define _IOC_WRITE 1U # define _IOC_READ 2U #endif /******************************************************************* * 1.3.0 added the put_user size-independent macro. Copy it here * * This code (up to the next line of stars) comes from the kernel headers */ #if LINUX_VERSION_CODE < VERSION_CODE(1,3,0) #define put_user(x,ptr) __put_user((unsigned long)(x),(ptr),sizeof(*(ptr))) #define get_user(ptr) ((__typeof__(*(ptr)))__get_user((ptr),sizeof(*(ptr)))) /* * This is a silly but good way to make sure that * the __put_user function is indeed always optimized, * and that we use the correct sizes.. */ extern int bad_user_access_length(void); /* * dummy pointer type structure.. gcc won't try to do something strange * this way.. */ struct __segment_dummy { unsigned long a[100]; }; #define __sd(x) ((struct __segment_dummy *) (x)) #define __const_sd(x) ((const struct __segment_dummy *) (x)) static inline void __put_user(unsigned long x, void * y, int size) { switch (size) { case 1: __asm__ ("movb %b1,%%fs:%0" :"=m" (*__sd(y)) :"iq" ((unsigned char) x), "m" (*__sd(y))); break; case 2: __asm__ ("movw %w1,%%fs:%0" :"=m" (*__sd(y)) :"ir" ((unsigned short) x), "m" (*__sd(y))); break; case 4: __asm__ ("movl %1,%%fs:%0" :"=m" (*__sd(y)) :"ir" (x), "m" (*__sd(y))); break; default: bad_user_access_length(); } } static inline unsigned long __get_user(const void * y, int size) { unsigned long result; switch (size) { case 1: __asm__ ("movb %%fs:%1,%b0" :"=q" (result) :"m" (*__const_sd(y))); return (unsigned char) result; case 2: __asm__ ("movw %%fs:%1,%w0" :"=r" (result) :"m" (*__const_sd(y))); return (unsigned short) result; case 4: __asm__ ("movl %%fs:%1,%0" :"=r" (result) :"m" (*__const_sd(y))); return result; default: return bad_user_access_length(); } } /*******************************************************************/ #endif /* * __LITTLE_ENDIAN and friends missed the underscore before 1.3.19 */ #if LINUX_VERSION_CODE < VERSION_CODE(1,3,19) # ifdef LITTLE_ENDIAN # define __LITTLE_ENDIAN # define __LITTLE_ENDIAN_BITFIELD # endif # ifdef BIG_ENDIAN # define __BIG_ENDIAN # define __BIG_ENDIAN_BITFIELD # endif #endif /* * get_unaligned was only incroduced in 1.99.6, but asm-generic * has a C reimplementation for it. Here it is (just copied :) */ #if LINUX_VERSION_CODE < VERSION_CODE(1,99,6) # ifndef __i386__ # include /* memcpy */ # define get_unaligned(ptr) \ ({ __typeof__(*(ptr)) __tmp; \ memcpy(&__tmp, (ptr), sizeof(*(ptr))); __tmp; }) # define put_unaligned(val, ptr) \ ({ __typeof__(*(ptr)) __tmp = (val); \ memcpy((ptr), &__tmp, sizeof(*(ptr))); \ (void)0; }) # else # define get_unaligned(ptr) (*(ptr)) # define put_unaligned(val, ptr) ((void)( *(ptr) = (val) )) # endif /* i386 */ #endif /* * define readb etc. This is only valid for the Intel platform */ #if LINUX_VERSION_CODE < VERSION_CODE(1,3,4) #define readb(addr) (*(volatile unsigned char *) (addr)) #define readw(addr) (*(volatile unsigned short *) (addr)) #define readl(addr) (*(volatile unsigned int *) (addr)) #define writeb(b,addr) ((*(volatile unsigned char *) (addr)) = (b)) #define writew(b,addr) ((*(volatile unsigned short *) (addr)) = (b)) #define writel(b,addr) ((*(volatile unsigned int *) (addr)) = (b)) #define memset_io(a,b,c) memset((void *)(a),(b),(c)) #define memcpy_fromio(a,b,c) memcpy((a),(void *)(b),(c)) #define memcpy_toio(a,b,c) memcpy((void *)(a),(b),(c)) #endif /* * 2.1 (and the axp-diffs-2.0.x) changed from `int' to `unsigned long' * the count argument to read() and write(). Define a portable count_t */ #if defined(__alpha__) || (LINUX_VERSION_CODE >= VERSION_CODE(2,1,0)) # define count_t unsigned long # define read_write_t long #else # define count_t int # define read_write_t int #endif #if LINUX_VERSION_CODE < VERSION_CODE(1,3,14) # define add_timer(t) do {(t)->expires-=jiffies; add_timer(t);} while(0) #endif #endif /* _ORABOOK_SYSDEP_H */ pci16in16out/test.c0100644000000000000000000000130007355276127013060 0ustar rootroot#include "dpci16in16out.h" #include "dpci16in16outlib.c" #include #include /* open */ #include /* exit */ #include /* Main - Call the ioctl functions */ main() { int file_desc, i,count=0; char buf[255]; char b=1; char *msg = "Message passed by ioctl\n"; sprintf(buf,"/dev/%s0\0",DEVICE_NAME); file_desc = open(buf, O_RDONLY); if (file_desc < 0) { printf ("Can't open device file: %s\n", buf); exit(-1); } Write16In16OutPort(file_desc,0x0); do{ Write16In16OutPort(file_desc,b); b=b<<1; count++; if(count%8==0) b=1; sleep(1); } while(count<1000); close(file_desc); } pci16in16out/test1.c0100644000000000000000000000113707355302143013135 0ustar rootroot#include "dpci16in16out.h" #include "dpci16in16outlib.c" #include #include /* open */ #include /* exit */ #include #include /* Main - Call the ioctl functions */ main() { int file_desc,data,i,j=0; char buf[255]; sprintf(buf,"/dev/%s0\0",DEVICE_NAME); file_desc = open(buf, O_RDONLY); if (file_desc < 0) { printf ("Can't open device file: %s\n", buf); exit(-1); } Write16In16OutPort(file_desc,0x65); printf("I write 0x65\n"); j=Read16In16OutPort(file_desc); printf("I read %02x\n",j); close(file_desc); } pci16in16out/uninstall0100755000000000000000000000026607355276255013710 0ustar rootroot#!/bin/sh module="dpci16in16out" device="dpci16in16out" # invoke rmmod with all arguments we got /sbin/rmmod $module $* || exit 1 # Remove stale nodes rm -f /dev/${device}[0-3] pci16in16out/dpci16in16out.c0100644000000000000000000001504707355302451014420 0ustar rootroot #ifndef __KERNEL__ #define __KERNEL__ #endif #ifndef MODULE #define MODULE #endif #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include "dpci16in16out.h" #include "sysdep.h" #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,2,0) #include #endif /* I defined some macro for device_open function */ #define TYPE(dev) (MINOR(dev) >> 4) #define NUM(dev) (MINOR(dev) & 0x0f) #ifndef KERNEL_VERSION #define KERNEL_VERSION(a,b,c) ((a)*65536+(b)*256+(c)) #endif #ifndef DECISION_VENDOR_ID #define DECISION_VENDER_ID 0x6666 #endif #ifndef DECISION_DEVICE_ID #define DECISION_DEVICE_ID 0x1025 #endif static int cards; static char rev[2]; int Base_Addr[MAXCARD]; /*---------------------------------------------------------------------*/ int dpci16in16out_open(struct inode *inoder,struct file *flip) { /* int type= TYPE(inoder->i_rdev);*/ int num=NUM(inoder->i_rdev); if(num>=cards) return -ENODEV; MOD_INC_USE_COUNT; return 0; } /*---------------------------------------------------------------------*/ #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,2,0) static int dpci16in16out_release(struct inode *inoder,struct file *flip) #else static void dpci16in16out_release(struct inode *inoder,struct file *flip) #endif { MOD_DEC_USE_COUNT; #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,2,0) return 0; #endif } /*---------------------------------------------------------------------*/ #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,2,0) static ssize_t dpci16in16out_read(struct file *flip,char *buf,size_t count,loff_t *ptr) #else static int dpci16in16out_read(struct inode *inode,struct file *flip, char *buf,count_t count) #endif { int countt=0; #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,2,0) int num=MINOR(flip->f_dentry->d_inode->i_rdev); if(ptr!=&flip->f_pos) /* can't seek on this device */ return -ESPIPE; #else int num=NUM(inode->i_rdev); #endif if(num>=cards) return -EINVAL; buf[0]=inb(Base_Addr[num]); countt=1; return countt; } /*---------------------------------------------------------------------*/ #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,2,0) static ssize_t dpci16in16out_write(struct file *flip,const char *buf,size_t count,loff_t *ptr) #else static int dpci16in16out_write(struct inde *inode,struct file *flip,char *buf,count_t count) #endif { #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,2,0) if(ptr!=&flip->f_pos) /* can't seek on this device */ return -ESPIPE; #endif return 0; /* do nothing */ } /*---------------------------------------------------------------------*/ int Myread(int num,char *buf,int count) { int countt; buf[0]=inb(Base_Addr[num]); buf[1]=inb(Base_Addr[num]+1); countt=2; return countt; } /*---------------------------------------------------------------------*/ void Mywrite(int num,char *buf,int count) { outb(buf[0],Base_Addr[num]); outb(buf[1],Base_Addr[num]+1); } /*---------------------------------------------------------------------*/ int dpci16in16out_ioctl( struct inode *inode, struct file *file, unsigned int ioctl_num,/* The number of the ioctl */ unsigned long ioctl_param) /* The parameter to it */ { char param[4]; char *temp=(char *)ioctl_param; int num=NUM(inode->i_rdev); int data; switch (ioctl_num) { case DPCI16IN16OUT_WRITE_PORT: data=(int)temp; param[0]=(char)(data&0xff); param[1]=(char)((data&0xff00)>>8); printk("\nI got %d %d",param[0],param[1]); Mywrite(num,param,2); break; case DPCI16IN16OUT_READ_PORT: Myread(num,param,2); printk("\nI read %d %d",param[0],param[1]); put_user(param[0],temp); temp++; put_user(param[1],temp); break; default: break; } return 0; } /*---------------------------------------------------------------------*/ /*---------------------------------------------------------------------*/ static struct file_operations dpci16in16out_fops={ NULL, /* dpci16in16out_lseek, */ &dpci16in16out_read, &dpci16in16out_write, NULL, /* dpci16in16out_readdir */ NULL, /* dpci16in16out_select */ &dpci16in16out_ioctl , NULL, /* dpci16in16out_mmap */ &dpci16in16out_open, #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,2,0) NULL, /* flush*/ #endif &dpci16in16out_release, }; /*---------------------------------------------------------------------*/ /*---------------------------------------------------------------------*/ /*---------------------------------------------------------------------*/ /*---------------------------------------------------------------------*/ MODULE_AUTHOR("Delta"); MODULE_DESCRIPTION("Decision PCI 16in/16out Card Driver"); /*---------------------------------------------------------------------*/ /*---------------------------------------------------------------------*/ int init_module(void) { int index=0; struct pci_dev *dev = NULL; static int dev_count=0; int i; dev_count++; if(dev_count>1) { printk(KERN_ERR"This drive only can open one time.\n"); return -ENODEV; } #ifdef CONFIG_PCI if (!pci_present()) /* No PCI bus in this machine! */ #endif return -ENODEV; cards=0; printk("\nCheck!!"); while (index < MAXCARD && (dev = pci_find_device(DECISION_VENDER_ID, DECISION_DEVICE_ID,dev))) { Base_Addr[index]=dev->base_address[3] & PCI_BASE_ADDRESS_IO_MASK; printk("PCI 16in/16out card:I got a base %x\n",Base_Addr[index]); if(check_region(Base_Addr[index],REGIONLENGTH)>=0) request_region(Base_Addr[index],REGIONLENGTH,DEVICE_NAME); index++; } if((dev==NULL)&&(index<1)) { printk("\nI can't find any Decision PCI 16in/16out card here!!\n"); return -ENODEV; } printk("\nPCI 16in/16out card: Total %d cards that I catched!\n",index); cards=index; index=register_chrdev(dpci16in16out_major,DEVICE_NAME,&dpci16in16out_fops); if(index<0) { for(i=0;i /* ioctl */ int Write16In16OutPort(int file_desc, int value) { int ret_val; ret_val = ioctl(file_desc, DPCI16IN16OUT_WRITE_PORT, value); return ret_val; } int Read16In16OutPort(int file_desc) { int ret_val; ioctl(file_desc, DPCI16IN16OUT_READ_PORT, &ret_val); return ret_val; }