Linux 下的dnw驱动及工具源码

驱动层：
注意一定要用ubuntu原始版本的gcc编译，因为内核符号是使用原始gcc建立的，比如ubuntu 12.04的gcc为gcc4.6。 编译前gcc -v确认一下
Makefile

ifneq ($(KERNELRELEASE),)

obj-m := secbulk.o

else

KERNELDIR ?=/lib/modules/$(shell uname -r)/build

PWD := $(shell pwd)

modules:
    $(MAKE) -C $(KERNELDIR) M=$(PWD) modules

endif

clean:
    rm -rf *.o *.order *.depend .*.cmd *.ko *.mod.c .tmp_versions *.symvers

secbulk.c

#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/usb.h>
#include <linux/fs.h>
#include <linux/mutex.h>
#include <linux/slab.h>
#include <linux/uaccess.h>

#define SECBULK_MAJOR    102
#define SECBULK_MINOR    0
#define DRIVER_NAME    "secbulk"

#define BULKOUT_BUFFER_SIZE    512

struct secbulk_dev
{
    struct usb_device *udev;
    struct mutex io_mutex;
    char*    bulkout_buffer;
    unsigned char    bulk_out_endpointAddr;
};

static struct usb_class_driver secbulk_class;

static struct usb_device_id secbulk_table[]= {
    { USB_DEVICE(0x04e8, 0x1234)},
    { }
};

static struct usb_driver secbulk_driver;
static void secbulk_disconnect(struct usb_interface *interface)
{
    struct secbulk_dev *dev = NULL;
    printk(KERN_INFO "secbulk:secbulk disconnected!\n");
    dev = usb_get_intfdata(interface);
    if( NULL != dev )
        kfree(dev);
    usb_deregister_dev(interface, &secbulk_class);
    return;
}

static ssize_t secbulk_read(struct file *file, char __user *buf, size_t len, loff_t *loff)
{
    return -EPERM;
}

static ssize_t secbulk_write(struct file *file, const char __user *buf, size_t len, loff_t *loff)
{
    size_t to_write;
    struct secbulk_dev *dev = file->private_data;
    int ret;
    int actual_length;
    size_t total_writed;

    total_writed = 0;
    while(len > 0)
    {
        to_write = min(len, BULKOUT_BUFFER_SIZE);

        if(copy_from_user(dev->bulkout_buffer, buf+total_writed, to_write))
        {
            printk(KERN_ERR "secbulk:copy_from_user failed!\n");
            return -EFAULT;
        }

        ret = usb_bulk_msg(dev->udev, usb_sndbulkpipe(dev->udev, dev->bulk_out_endpointAddr),
                dev->bulkout_buffer,
                to_write,
                &actual_length,
                3*HZ);
        if(ret || actual_length!=to_write)
        {
            printk(KERN_ERR "secbulk:usb_bulk_msg failed!\n");
            return -EFAULT;
        }
        len -= to_write;
        total_writed += to_write;
    }
    return total_writed;
}

static int secbulk_open(struct inode *node, struct file *file)
{
    struct usb_interface *interface;
    struct secbulk_dev *dev;

    interface = usb_find_interface(&secbulk_driver, iminor(node));
    if(!interface)
        return -ENODEV;

    dev = usb_get_intfdata(interface);
    dev->bulkout_buffer = kzalloc(BULKOUT_BUFFER_SIZE, GFP_KERNEL);
    if(!(dev->bulkout_buffer))
        return -ENOMEM;
    if(!mutex_trylock(&dev->io_mutex))
        return -EBUSY;
    file->private_data = dev;
    return 0;
}

static int secbulk_release(struct inode *node, struct file *file)
{
    struct secbulk_dev *dev;

    dev = (struct secbulk_dev*)(file->private_data);
    kfree(dev->bulkout_buffer);
    mutex_unlock(&dev->io_mutex);
    return 0;
}

static struct file_operations secbulk_fops = {
    .owner     =    THIS_MODULE,
    .read     =    secbulk_read,
    .write    =    secbulk_write,
    .open =    secbulk_open,
    .release=    secbulk_release,
};

static struct usb_class_driver secbulk_class = {
    .name =     "secbulk%d",
    .fops =        &secbulk_fops,
    .minor_base=    100,
};

static int secbulk_probe(struct usb_interface *interface, const struct usb_device_id *id)
{
    int ret;
    struct secbulk_dev *dev;
    struct usb_host_interface *iface_desc;
    struct usb_endpoint_descriptor *endpoint;
    int i;

    printk(KERN_INFO "secbulk:secbulk probing...\n");

    dev = kzalloc(sizeof(*dev), GFP_KERNEL);
    if(!dev)
    {
        ret = -ENOMEM;
        goto error;
    }

    iface_desc = interface->cur_altsetting;
    for(i=0; i < iface_desc->desc.bNumEndpoints; i++)
    {
        endpoint = &(iface_desc->endpoint[i].desc);
        if(!dev->bulk_out_endpointAddr
        && usb_endpoint_is_bulk_out(endpoint))
        {
            printk(KERN_INFO "secbulk:bulk out endpoint found!\n");
            dev->bulk_out_endpointAddr = endpoint->bEndpointAddress;
            break;
        }
    }

    if(!(dev->bulk_out_endpointAddr))
    {
        ret = -EBUSY;
        goto error;
    }

    ret = usb_register_dev(interface, &secbulk_class);
    if(ret)
    {
        printk(KERN_ERR "secbulk: usb_register_dev failed!\n");
        return ret;
    }
    dev->udev = usb_get_dev(interface_to_usbdev(interface));

    usb_set_intfdata(interface, dev);

    mutex_init(&dev->io_mutex);
    return 0;
error:
    if(!dev)
        kfree(dev);
    return ret;
}

static struct usb_driver secbulk_driver= {
    .name=        "secbulk",
    .probe=        secbulk_probe,
    .disconnect=    secbulk_disconnect,
    .id_table=    secbulk_table,
    .supports_autosuspend=0,
};
static int __init secbulk_init(void)
{
    int result;
    printk(KERN_INFO "secbulk:secbulk loaded\n");
    result = usb_register(&secbulk_driver);
    if(result)
    {    printk(KERN_ERR "secbulk:usb_register failed: %d", result);
        return result;
    }
    return 0;
}

static void __exit secbulk_exit(void)
{
    usb_deregister(&secbulk_driver);
    printk(KERN_INFO "secbulk:secbulk unloaded\n");
}

module_init(secbulk_init);
module_exit(secbulk_exit);
MODULE_LICENSE("GPL");

应用层：

#include <stdio.h>
#include <stdlib.h>
#include <malloc.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
#include <fcntl.h>

const char* dev = "/dev/secbulk0";


int main(int argc, char* argv[])
{
    unsigned char* file_buffer = NULL;
    if( 2 != argc )
    {
        printf("Usage: dwn \n");
        return 1;
    }

    int fd = open(argv[1], O_RDONLY);
    if(-1 == fd)
    {
        printf("Can not open file - %s\n", argv[1]);
        return 1;
    }

    struct stat file_stat;
    if( -1 == fstat(fd, &file_stat) )
    {
        printf("Get file size filed!\n");
        return 1;
    }

    file_buffer = (char*)malloc(file_stat.st_size+10);
    if(NULL == file_buffer)
    {
        printf("malloc failed!\n");
        goto error;
    }
    if( file_stat.st_size != read(fd, file_buffer+8, file_stat.st_size))
    {
        printf("Read file failed!\n");
        goto error;
    }

    printf("file name : %s\n", argv[1]);
    printf("file size : %d bytes\n", file_stat.st_size);

    int fd_dev = open(dev, O_WRONLY);
    if( -1 == fd_dev)
    {
        printf("Can not open %s\n", dev);
        goto error;
    }

    *((unsigned long*)file_buffer) = 0x32000000;     //load address
    *((unsigned long*)file_buffer+1) = file_stat.st_size+10;    //file size
    unsigned short sum = 0;
    int i;
    for(i=8; i<file_stat.st_size+8; i++)
    {
        sum += file_buffer[i];
    }
    /*****************************/
    file_buffer [file_stat.st_size + 8] = sum & 0xff;
    file_buffer [file_stat.st_size + 9] = sum >> 8;
    /*****************************/
    printf("Writing data...\n");
    size_t remain_size = file_stat.st_size+10;
    size_t block_size = remain_size / 100;
    size_t writed = 0;
    while(remain_size>0)
    {
        size_t to_write = remain_size > block_size ? block_size:remain_size;
        if( to_write != write(fd_dev, file_buffer+writed, to_write))
        {
            printf("failed!\n");
            return 1;
        }
        remain_size -= to_write;
        writed += to_write;
        printf("\r%d%\t %d bytes     ", writed*100/(file_stat.st_size+10), writed);
        fflush(stdout);

    }

    printf("OK\n");
    return 0;

error:
    if(-1!=fd_dev) close(fd_dev);
    if(fd != -1) close(fd);
    if( NULL!=file_buffer )
        free(file_buffer);
    return -1;
}

参考：
http://www.cnblogs.com/qiaoge/archive/2012/03/29/2423776.html
http://blog.csdn.net/david_xtd/article/details/26088299