linux proc驱动，就内核2.6版本的，新内核版本3.0+不适用

linux驱动源码
linux proc驱动
sys/proc
实测可用，亲测

#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/fs.h>
#include <linux/types.h>
#include <linux/gpio.h>
#include <linux/proc_fs.h>
#include <asm/uaccess.h>
#include <mach/soc.h>
#include <mach/gpio.h>
#include <nx_type.h>
#include <nx_ecid.h>
#include "built_version.h"

extern int sha1_hash(char *source, int len, int buf[5]);

static unsigned char bl_version[3];
static unsigned int auth_param[4];
static struct proc_dir_entry *auth_proc_entry = NULL;
static struct proc_dir_entry *ecid_proc_entry = NULL;
static struct proc_dir_entry *kversion_proc_entry = NULL;
static struct proc_dir_entry *uversion_proc_entry = NULL;
static struct proc_dir_entry *gpio_proc_entry = NULL;


static int __init uboot_version(char *param)
{
    
    
	sscanf(param, "%u.%u.%u", 
				&bl_version[0], &bl_version[1], &bl_version[2]);
}
__setup("version=", uboot_version);

static int __init auth_setup(char *param)
{
    
    
	char buf[64];
	char *p, *q;
	int i;
	U32 magic[4];	

	NX_ECID_GetECID(magic);	

	strcpy(buf, param);
	q = buf;
	memset(param, 0, strlen(param));

	for(i = 0; i < 4; i++){
    
    
		p = strchr(q, ','); 
		if(p != NULL){
    
    
			*p = 0;
		}
		auth_param[i] = simple_strtoul(q, NULL, 0);
		if(p != NULL){
    
    
			q = p + 1;
		}
		auth_param[i] ^= auth_param[0];
		auth_param[i] ^= magic[0];
	}

	return 0;
}
__setup("auth=", auth_setup);

unsigned int crypto_auth_param(unsigned char index)
{
    
    
	return auth_param[index];
}

EXPORT_SYMBOL(crypto_auth_param);

void crypto_auth_ecid(unsigned int ecid[])
{
    
    
	NX_ECID_GetECID(ecid);	
}

EXPORT_SYMBOL(crypto_auth_ecid);

int auth_proc_read(char *page, char **start, off_t off,
			  int count, int *eof, void *data)
{
    
    
	int len;
	U32 magic[4];	

	NX_ECID_GetECID(magic);	

	len = sprintf(page, "%d", !(auth_param[0] ^ magic[0]));

	return len;
}

int ecid_proc_read(char *page, char **start, off_t off,
			  int count, int *eof, void *data)
{
    
    
	int len;
	U32 magic[4];	

	NX_ECID_GetECID(magic);	

	len = sprintf(page, "%08x %08x %08x %08x", 
			  magic[3], magic[2] ,magic[1] ,magic[0]);

	return len;
}

int uboot_version_proc_read(char *page, char **start, off_t off,
			  				int count, int *eof, void *data)
{
    
    
	int len;

	len = sprintf(page, "%u.%u.%u", 
					bl_version[0], bl_version[1], bl_version[2]);

	return len;
}

int kernel_version_proc_read(char *page, char **start, off_t off,
			  				int count, int *eof, void *data)
{
    
    
	int len;

	len = sprintf(page, "%s", BUILT_VERSION);

	return len;
}

int set_gpio_proc_write(struct file *file, const char __user *buffer,
			   unsigned long count, void *data)
{
    
    
	int ionum, iostate;
	char context[16];

	if(count > 15) {
    
    
		return -EFAULT;
	} 
	
	memset(context, 0, 16);
	if(copy_from_user(context, buffer, count)){
    
    
		return -EFAULT;
	}
	if(sscanf(context, "%d,%d", &ionum, &iostate) == 2) {
    
    
		nxp_soc_gpio_set_out_value(ionum, iostate);
	}

	return count;
}
			   
static int __init crypto_auth_init(void)
{
    
    
	U32 magic[4];	

	NX_ECID_GetECID(magic);	
	if(auth_param[0] ^ magic[0]){
    
    
		nxp_soc_gpio_set_io_func(16, 0);
		nxp_soc_gpio_set_io_dir(16, 1);
		nxp_soc_gpio_set_out_value(16, 1);
		nxp_soc_gpio_set_io_func(17, 0);
		nxp_soc_gpio_set_io_dir(17, 1);
		nxp_soc_gpio_set_out_value(17, 1);
	}

	auth_proc_entry = create_proc_entry("valid", 0666, NULL);

	if (auth_proc_entry) {
    
    
		auth_proc_entry->read_proc = auth_proc_read;
	}

	ecid_proc_entry = create_proc_entry("ecid", 0666, NULL);

	if (ecid_proc_entry) {
    
    
		ecid_proc_entry->read_proc = ecid_proc_read;
	}

	uversion_proc_entry = create_proc_entry("uversion", 0666, NULL);

	if (uversion_proc_entry) {
    
    
		uversion_proc_entry->read_proc = uboot_version_proc_read;
	}

	kversion_proc_entry = create_proc_entry("kversion", 0666, NULL);

	if (kversion_proc_entry) {
    
    
		kversion_proc_entry->read_proc = kernel_version_proc_read;
	}

	gpio_proc_entry = create_proc_entry("setgpio", 0666, NULL);

	if (gpio_proc_entry) {
    
    
		gpio_proc_entry->write_proc = set_gpio_proc_write;
	}

	return 0;	
}

static void __exit crypto_auth_exit(void)
{
    
    
	if (auth_proc_entry) {
    
    
		remove_proc_entry("valid", NULL);
	}
	if (ecid_proc_entry) {
    
    
		remove_proc_entry("ecid", NULL);
	}
	if (uversion_proc_entry) {
    
    
		remove_proc_entry("uversion", NULL);
	}
	if (kversion_proc_entry) {
    
    
		remove_proc_entry("kversion", NULL);
	}
	if (gpio_proc_entry) {
    
    
		remove_proc_entry("setgpio", NULL);
	}
}

module_init(crypto_auth_init);
module_exit(crypto_auth_exit);

MODULE_AUTHOR("?????");
MODULE_DESCRIPTION("CRYPTO AUTH DRIVER");
MODULE_LICENSE("GPL");