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