dnw for linux(ubuntu opensuse federaテストに合格)


転載は作者を保留してください! 
ailinty   
 
DNWに迫害されてwindowsの下でよくシリアルのハングアップを招きます.
コンピュータのブルースクリーンなどの不良反応の影響、私はLINUX操作を転用します
DNWは6410ボードのダウンロードを実現した.
ARM 6410 for linux USB駆動
ドライバソース:
#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;
        __u8    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!
"); 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!
"); 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!
"); 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...
"); 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!
"); 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!
"); 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
"); 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
"); } module_init(secbulk_init); module_exit(secbulk_exit); MODULE_LICENSE("GPL");

Makefile
obj-m := secbulk.o
secbulk-m := secbulk.o

ドライバコンパイル方法:(カーネルソースがインストールされていることを確認してください)
make -C/lib/modules/`uname -r`/build M=`pwd` modules
secbulkを生成する.ko、ロードすればいい
insmod secbulk.ko
次にminicomを使用してシリアルポート情報を表示し、ヒントに従ってダウンロードします.
dnwソースコード(gccでコンパイルしてください)
#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 <filename>
"); return 1; } int fd = open(argv[1], O_RDONLY); if(-1 == fd) { printf("Can not open file - %s
", argv[1]); return 1; } struct stat file_stat; if( -1 == fstat(fd, &file_stat) ) { printf("Get file size filed!
"); return 1; } file_buffer = (char*)malloc(file_stat.st_size+10); if(NULL == file_buffer) { printf("malloc failed!
"); goto error; } if( file_stat.st_size != read(fd, file_buffer+8, file_stat.st_size)) { printf("Read file failed!
"); goto error; } printf("file name : %s
", argv[1]); printf("file size : %d bytes
", file_stat.st_size); int fd_dev = open(dev, O_WRONLY); if( -1 == fd_dev) { printf("Can not open %s
", 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...
"); 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!
"); 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
"); return 0; error: if(-1!=fd_dev) close(fd_dev); if(fd != -1) close(fd); if( NULL!=file_buffer ) free(file_buffer); return -1; }

コンパイル後gcc-o dnw dnwを生成する.c
使用シヨウ:dnw rootfs_qt.img(ダウンロードファイルシステムと仮定)