dnw for linux(ubuntu opensuse federaテストに合格)
転載は作者を保留してください!
ailinty
DNWに迫害されてwindowsの下でよくシリアルのハングアップを招きます.
コンピュータのブルースクリーンなどの不良反応の影響、私はLINUX操作を転用します
DNWは6410ボードのダウンロードを実現した.
ARM 6410 for linux USB駆動
ドライバソース:
Makefile
ドライバコンパイル方法:(カーネルソースがインストールされていることを確認してください)
make -C/lib/modules/`uname -r`/build M=`pwd` modules
secbulkを生成する.ko、ロードすればいい
insmod secbulk.ko
次にminicomを使用してシリアルポート情報を表示し、ヒントに従ってダウンロードします.
dnwソースコード(gccでコンパイルしてください)
コンパイル後gcc-o dnw dnwを生成する.c
使用シヨウ:dnw rootfs_qt.img(ダウンロードファイルシステムと仮定)
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(ダウンロードファイルシステムと仮定)