/* 51 SIOCSIFMTU -- Set mtu of a network interface. */
error_t
S_iioctl_siocsifmtu (io_t port,
ifname_t ifnam,
int mtu)
{
struct sock_user *user = begin_using_socket_port (port);
error_t err = 0;
struct device *dev;
if (!user)
return EOPNOTSUPP;
dev = get_dev (ifnam);
if (!user->isroot)
err = EPERM;
if (!dev)
err = ENODEV;
else if (mtu <= 0)
err = EINVAL;
else
{
if (dev->change_mtu)
dev->change_mtu (dev, mtu);
else
dev->mtu = mtu;
notifier_call_chain (&netdev_chain, NETDEV_CHANGEMTU, dev);
}
__mutex_unlock (&global_lock);
end_using_socket_port (user);
return err;
}
/*
* Dump crash to file (typically FAT file on SD/MMC).
*/
static int crashdump(Elf32_Ehdr *elfhdr_addr)
{
int rc;
block_dev_desc_t *dev_desc=NULL;
rc = wait_for_mmc();
if (rc == 0) {
dev_desc = get_dev("mmc", CONFIG_SD_FAT_DEV_NUM); /* mmc 1 */
rc = fat_register_device(dev_desc, CONFIG_SD_FAT_PART_NUM); /* part 1 */
if (rc != 0) {
printf("crashdump: fat_register_device failed %d\n",
rc);
return -1;
}
if(find_dump_file_name() < MAX_PREFIX)
rc = dump_elf(elfhdr_addr, crash_filename);
else
printf("Number of dumps have reached maximum on SD card: %d\n", MAX_PREFIX);
}
if (rc != 0)
printf("crashdump: error writing dump to %s\n", crash_filename);
return rc;
}
/* Get some sockaddr type of info. */
static kern_return_t
siocgifXaddr (io_t port,
ifname_t ifnam,
sockaddr_t *addr,
enum siocgif_type type)
{
struct sock_user *user = begin_using_socket_port (port);
error_t err = 0;
struct device *dev;
struct sockaddr_in *sin = (struct sockaddr_in *) addr;
uint32_t addrs[4];
if (!user)
return EOPNOTSUPP;
dev = get_dev (ifnam);
if (!dev)
err = ENODEV;
else if (user->sock->sk->family != AF_INET)
err = EINVAL;
else
{
sin->sin_family = AF_INET;
inquire_device (dev, &addrs[0], &addrs[1], &addrs[2], &addrs[3]);
sin->sin_addr.s_addr = addrs[type];
}
__mutex_unlock (&global_lock);
end_using_socket_port (user);
return err;
}
void fb_mmc_erase(const char *cmd, char *response)
{
int ret;
block_dev_desc_t *dev_desc;
disk_partition_t info;
/* initialize the response buffer */
response_str = response;
dev_desc = get_dev("mmc", CONFIG_FASTBOOT_FLASH_MMC_DEV);
if (!dev_desc || dev_desc->type == DEV_TYPE_UNKNOWN) {
error("invalid mmc device\n");
fastboot_fail("invalid mmc device");
return;
}
ret = get_partition_info_efi_by_name(dev_desc, cmd, &info);
if (ret) {
error("cannot find partition: '%s'\n", cmd);
fastboot_fail("cannot find partition");
return;
}
erase_image(dev_desc, &info, cmd);
}
static void
set_pri_req(int fd, int pri_req)
{
struct fw_devlstreq *data;
struct fw_devinfo *devinfo;
u_int32_t max, reg, old;
int i;
data = get_dev(fd);
#define BUGET_REG 0xf0000218
for (i = 0; i < data->info_len; i++) {
devinfo = &data->dev[i];
if (!devinfo->status)
continue;
reg = read_write_quad(fd, devinfo->eui, BUGET_REG, 1, 0);
printf("%d %08x:%08x, %08x",
devinfo->dst, devinfo->eui.hi, devinfo->eui.lo, reg);
if (reg > 0 && pri_req >= 0) {
old = (reg & 0x3f);
max = (reg & 0x3f00) >> 8;
if (pri_req > max)
pri_req = max;
printf(" 0x%x -> 0x%x\n", old, pri_req);
read_write_quad(fd, devinfo->eui, BUGET_REG, 0, pri_req);
} else {
static int check_update_file(void)
{
int ret, dev;
block_dev_desc_t *dev_desc;
char *sdev = getenv("mmcdev");
dev = (int)((char)sdev[0] - '0');
dev_desc = get_dev("mmc", dev);
if (dev_desc == NULL) {
printf("Failed to find %s:%d\n", "mmc", dev);
return -1;
}
ret = fat_register_device(dev_desc, 0);
if (ret) {
printf("Failed to register %s: 0:0\n","mmc");
ret = fat_register_device(dev_desc, 1);
if (ret) {
printf("Failed to register %s: 0:1\n","mmc");
return -1;
}
}
ret = fat_exists("update.zip");
if(ret == 0) {
printf("not find update.zip, ret=%d\n", ret);
return -1;
}
printf("is card update, ret=%d\n", ret);
return 0;
}
int do_cconfig_ls (cmd_tbl_t *cmdtp, int flag, int argc, char *argv[])
{
int ret;
int dev=0;
int part=1;
char *ep;
block_dev_desc_t *dev_desc=NULL;
if (argc < 3) {
printf ("usage: cconfigls <interface> <dev>\n");
return (0);
}
dev = (int)simple_strtoul (argv[2], &ep, 16);
dev_desc=get_dev(argv[1],dev);
if (dev_desc==NULL) {
puts ("\n** Invalid boot device **\n");
return 1;
}
if (*ep) {
if (*ep != ':') {
puts ("\n** Invalid boot device, use `dev' **\n");
return 1;
}
part = (int)simple_strtoul(++ep, NULL, 16);
}
if (cconfig_register_device(dev_desc,part)!=0) {
printf ("\n** Unable to use %s %d:%d for cconfigls **\n",argv[1],dev,part);
return 1;
}
ret = file_cconfig_ls();
if(ret!=0)
printf("No Chumby config FS detected\n");
return (ret);
}
int do_cconfig_fsinfo (cmd_tbl_t *cmdtp, int flag, int argc, char *argv[])
{
int dev=0;
int part=1;
char *ep;
struct config_area ca;
block_dev_desc_t *dev_desc=NULL;
if (argc < 4) {
printf ("usage: cconfiginfo <interface> <dev> <info>\n");
return (0);
}
dev = (int)simple_strtoul (argv[2], &ep, 16);
dev_desc=get_dev(argv[1],dev);
if (dev_desc==NULL) {
puts ("\n** Invalid boot device **\n");
return 1;
}
if (*ep) {
if (*ep != ':') {
puts ("\n** Invalid boot device, use `dev' **\n");
return 1;
}
part = (int)simple_strtoul(++ep, NULL, 16);
}
if (cconfig_register_device(dev_desc,part)!=0) {
printf ("\n** Unable to use %s %d:%d for cconfiginfo **\n",argv[1],dev,part);
return 1;
}
if(file_cconfig_detectfs(&ca)) {
printf("No cconfig partition found\n");
return 1;
}
if(!strcmp(argv[3], "active")) {
printf("Active partition: %d\n", ca.active_index);
return ca.active_index;
}
else if(!strcmp(argv[3], "updating")) {
printf("Updating? %d\n", ca.updating);
return ca.updating;
}
else if(!strcmp(argv[3], "offset")) {
printf("Partition 1 offset: %d\n", ca.p1_offset);
return ca.p1_offset;
}
else if(!strcmp(argv[3], "version")) {
printf("Config version %d.%d.%d.%d\n",
ca.area_version[0], ca.area_version[1],
ca.area_version[2], ca.area_version[3]);
return ca.area_version[0] << 24 | ca.area_version[1] << 16
| ca.area_version[2] << 8 | ca.area_version[3];
}
else {
printf("Unrecognized info type '%s'\n", argv[3]);
return 0;
}
}
int do_fat_fsinfo (cmd_tbl_t *cmdtp, int flag, int argc, char *argv[])
{
int dev=0;
int part=1;
char *ep;
block_dev_desc_t *dev_desc=NULL;
if (argc < 2) {
printf ("usage: fatinfo <interface> <dev[:part]>\n");
return (0);
}
dev = (int)simple_strtoul (argv[2], &ep, 16);
dev_desc=get_dev(argv[1],dev);
if (dev_desc==NULL) {
puts ("\n** Invalid boot device **\n");
return 1;
}
if (*ep) {
if (*ep != ':') {
puts ("\n** Invalid boot device, use `dev[:part]' **\n");
return 1;
}
part = (int)simple_strtoul(++ep, NULL, 16);
}
if (fat_register_device(dev_desc,part)!=0) {
printf ("\n** Unable to use %s %d:%d for fatinfo **\n",argv[1],dev,part);
return 1;
}
return (file_fat_detectfs ());
}
/* 16 SIOCSIFFLAGS -- Set flags of a network interface. */
kern_return_t
S_iioctl_siocsifflags (io_t port,
ifname_t ifnam,
short flags)
{
struct sock_user *user = begin_using_socket_port (port);
error_t err = 0;
struct device *dev;
if (!user)
return EOPNOTSUPP;
dev = get_dev (ifnam);
if (!user->isroot)
err = EPERM;
else if (!dev)
err = ENODEV;
else
{
err = dev_change_flags (dev, flags);
if (!err)
err = ethernet_change_flags (dev, flags);
}
__mutex_unlock (&global_lock);
end_using_socket_port (user);
return err;
}
API_EXPORTED
gt_bool GT_StartAcquisition( const char* device_name )
{
struct gtec_device* gtdev;
gtdev = get_dev(device_name, NULL);
if (!gtdev)
return GT_FALSE;
if (gtdev->running)
return GT_FALSE;
gtdev->running = 1;
pthread_create(&(gtdev->thid), NULL, update_thread, gtdev);
if (!gtdev->conf.slave_mode) {
clock_gettime(CLOCK_REALTIME, &org);
pthread_mutex_lock(&acqlock);
acquiring = 1;
pthread_cond_broadcast(&acqcond);
pthread_mutex_unlock(&acqlock);
}
return GT_TRUE;
}
API_EXPORTED
int GT_GetData( const char* device_name, unsigned char* buffer, gt_size num_samples )
{
unsigned int last, j, s, ns;
struct gtec_device* gtdev;
float* data = (float*)buffer;
int idev = 0;
gtdev = get_dev(device_name, &idev);
if (!gtdev)
return -1;
ns = num_samples/(sizeof(*data)*17);
last = gtdev->lastsample;
/*if (ns+last > 1024)
ns = 1024 - last;
if (ns <= 0)
exit(EXIT_FAILURE);
num_samples = ns * (sizeof(*data)*17);*/
for (s=0; s<ns; s++) {
for (j=0; j<16; j++)
data[s*17 + j] = get_analog_val(s+last, idev*16+j);
data[s*17+16] = get_trigger_val(s+last, idev);
}
gtdev->lastsample += ns;
return num_samples;
}
int fat_fsload_file (char * file_name,unsigned int ddr_addr)
{
long size;
unsigned long count;
block_dev_desc_t *dev_desc=NULL;
int dev=0;
int part=1;
dev_desc = get_dev("sunxi_flash",dev);
if (dev_desc == NULL) {
puts("\n** Invalid boot device **\n");
return -1;
}
if (fat_register_device(dev_desc,part)!=0) {
printf("\n** Unable to use %s %d:%d for fatload **\n",
"sunxi_flash", dev, part);
return -1;
}
count = 0;
size = file_fat_read(file_name, (unsigned char *)ddr_addr, count);
if(size==-1) {
printf("\n** Unable to read \"%s\" from %s %d:%d **\n",
file_name, "sunxi_flash", dev, part);
return -1;
}
return size;
}
static void
list_dev(int fd)
{
struct fw_devlstreq *data;
struct fw_devinfo *devinfo;
struct eui64 eui;
char addr[EUI64_SIZ], hostname[40];
int i;
data = (struct fw_devlstreq *)malloc(sizeof(struct fw_devlstreq));
if (data == NULL)
err(EX_SOFTWARE, "%s:data malloc", __func__);
get_dev(fd, data);
printf("%d devices (info_len=%d)\n", data->n, data->info_len);
printf("node EUI64 status hostname\n");
for (i = 0; i < data->info_len; i++) {
devinfo = &data->dev[i];
fweui2eui64(&devinfo->eui, &eui);
eui64_ntoa(&eui, addr, sizeof(addr));
if (eui64_ntohost(hostname, sizeof(hostname), &eui))
hostname[0] = 0;
printf("%4d %s %6d %s\n",
(devinfo->status || i == 0) ? devinfo->dst : -1,
addr,
devinfo->status,
hostname
);
}
free((void *)data);
}
static int initUsbDevice(void)
{
/* start USB */
if (usb_stop() < 0) {
debug ("Stop USB failed\n");
return FALSE;
}
if (usb_init() < 0) {
debug ("Init USB failed\n");
return FALSE;
}
current_usb_storage_device = usb_stor_scan(0);
if (current_usb_storage_device == -1) {
debug ("No USB device found. Not initialized?\n");
return FALSE;
}
stor_dev = get_dev("usb", current_usb_storage_device);
if (stor_dev == NULL) {
debug ("usb get uknown device type\n");
return FALSE;
}
return TRUE;
}
static void
set_pri_req(int fd, u_int32_t pri_req)
{
struct fw_devlstreq *data;
struct fw_devinfo *devinfo;
struct eui64 eui;
char addr[EUI64_SIZ];
u_int32_t max, reg, old;
int i;
data = (struct fw_devlstreq *)malloc(sizeof(struct fw_devlstreq));
if (data == NULL)
err(EX_SOFTWARE, "%s:data malloc", __func__);
get_dev(fd, data);
#define BUGET_REG 0xf0000218
for (i = 0; i < data->info_len; i++) {
devinfo = &data->dev[i];
if (!devinfo->status)
continue;
reg = read_write_quad(fd, devinfo->eui, BUGET_REG, 1, 0);
fweui2eui64(&devinfo->eui, &eui);
eui64_ntoa(&eui, addr, sizeof(addr));
printf("%d %s, %08x",
devinfo->dst, addr, reg);
if (reg > 0) {
old = (reg & 0x3f);
max = (reg & 0x3f00) >> 8;
if (pri_req > max)
pri_req = max;
printf(" 0x%x -> 0x%x\n", old, pri_req);
read_write_quad(fd, devinfo->eui, BUGET_REG, 0, pri_req);
} else {
void timer_reset(tim_t tim)
{
lpc23xx_timer_t *dev = get_dev(tim);
dev->TCR |= 2;
asm("nop");
dev->TCR &= ~(2);
}
void print_partion_info(void)
{
block_dev_desc_t *dev_desc;
disk_partition_t info;
int pnum = 0;
int i;
unsigned long long start;
unsigned long long size;
dev_desc = get_dev("mmc", CONFIG_FASTBOOT_FLASH_MMC_DEV);
if (!dev_desc || dev_desc->type == DEV_TYPE_UNKNOWN) {
error("invalid mmc device\n");
fastboot_fail("invalid mmc device");
return;
}
pnum = get_partition_num(dev_desc);
for (i = 1; i <= pnum; i++) {
if (get_partition_info(dev_desc, i, &info))
break;
start = (unsigned long long)info.start * info.blksz;
size = (unsigned long long)info.size * info.blksz;
printf("part %3d::%12s\t start 0x%08llx, size 0x%08llx\n",
i, info.name, start, size);
}
}
API_EXPORTED
gt_bool GT_StopAcquisition( const char* device_name )
{
struct gtec_device* gtdev;
int retval = GT_FALSE;
gtdev = get_dev(device_name, NULL);
if (!gtdev)
return GT_FALSE;
pthread_mutex_lock(>dev->updatelock);
if (!gtdev->running)
retval = GT_FALSE;
else {
gtdev->running = 0;
pthread_cond_signal(>dev->cond);
}
pthread_mutex_unlock(>dev->updatelock);
pthread_join(gtdev->thid, NULL);
if (!gtdev->conf.slave_mode) {
pthread_mutex_lock(&acqlock);
acquiring = 0;
pthread_mutex_unlock(&acqlock);
}
return retval;
}
static int do_ext4_ls(cmd_tbl_t *cmdtp, int flag, int argc, char *const argv[])
{
const char *filename = "/";
int dev;
unsigned long part = 1;
char *ep;
struct ext_filesystem *fs;
int part_length;
if (argc < 3)
return cmd_usage(cmdtp);
dev = (int)simple_strtoul(argv[2], &ep, 16);
ext4_dev_desc = get_dev(argv[1], dev);
if (ext4_dev_desc == NULL) {
printf("\n** Block device %s %d not supported\n", argv[1], dev);
return 1;
}
if (init_fs(ext4_dev_desc))
return 1;
fs = get_fs();
if (*ep) {
if (*ep != ':') {
puts("\n** Invalid boot device, use `dev[:part]' **\n");
return 1;
}
part = simple_strtoul(++ep, NULL, 16);
}
if (argc == 4)
filename = argv[3];
part_length = ext4fs_set_blk_dev(fs->dev_desc, part);
if (part_length == 0) {
printf("** Bad partition - %s %d:%lu **\n", argv[1], dev, part);
ext4fs_close();
return 1;
}
if (!ext4fs_mount(part_length)) {
printf("** Bad ext2 partition or disk - %s %d:%lu **\n",
argv[1], dev, part);
ext4fs_close();
return 1;
}
if (ext4fs_ls(filename)) {
printf("** Error ext2fs_ls() **\n");
ext4fs_close();
return 1;
};
ext4fs_close();
deinit_fs(fs->dev_desc);
return 0;
}
int timer_clear(tim_t tim, int channel)
{
if (tim >= TIMER_NUMOF || channel >= TIMER_CHAN_NUMOF) {
return -1;
}
get_dev(tim)->MCR &= ~(1 << (channel * 3));
return 0;
}
/**
* Dump registers
*/
void
regdump(const bool use_i2c, const int bus)
{
LidarLite * g_dev = get_dev(use_i2c, bus);
printf("regdump @ %p\n", g_dev);
g_dev->print_registers();
exit(0);
}
/**
* Print a little info about the driver.
*/
void
info(const bool use_i2c, const int bus)
{
LidarLite * g_dev = get_dev(use_i2c, bus);
printf("state @ %p\n", g_dev);
g_dev->print_info();
exit(0);
}
int do_fat_fsload (cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
{
long size;
unsigned long offset;
unsigned long count;
char buf [12];
block_dev_desc_t *dev_desc=NULL;
int dev=0;
int part=1;
char *ep;
if (argc < 5) {
printf( "usage: fatload <interface> <dev[:part]> "
"<addr> <filename> [bytes]\n");
return 1;
}
dev = (int)simple_strtoul(argv[2], &ep, 16);
dev_desc = get_dev(argv[1],dev);
if (dev_desc == NULL) {
puts("\n** Invalid boot device **\n");
return 1;
}
if (*ep) {
if (*ep != ':') {
puts("\n** Invalid boot device, use `dev[:part]' **\n");
return 1;
}
part = (int)simple_strtoul(++ep, NULL, 16);
}
if (fat_register_device(dev_desc,part)!=0) {
printf("\n** Unable to use %s %d:%d for fatload **\n",
argv[1], dev, part);
return 1;
}
offset = simple_strtoul(argv[3], NULL, 16);
if (argc == 6)
count = simple_strtoul(argv[5], NULL, 16);
else
count = 0;
#ifdef DEBUG
printf("offset = %x\n", (int)offset);
#endif
size = file_fat_read(argv[4], (unsigned char *)offset, count);
if(size==-1) {
printf("\n** Unable to read \"%s\" from %s %d:%d **\n",
argv[4], argv[1], dev, part);
return 1;
}
debug("\n%ld bytes read\n", size);
sprintf(buf, "%lX", size);
setenv("filesize", buf);
return 0;
}
int do_ext2ls (cmd_tbl_t *cmdtp, int flag, int argc, char *argv[])
{
char *filename = "/";
int dev=0;
int part=1;
char *ep;
block_dev_desc_t *dev_desc=NULL;
int part_length;
if (argc < 3) {
printf ("Usage:\n%s\n", cmdtp->usage);
return(1);
}
dev = (int)simple_strtoul (argv[2], &ep, 16);
//printf("argv[1] = %s dev =%d",argv[1],dev);
dev_desc = get_dev(argv[1],dev);
if (dev_desc == NULL) {
printf ("\n** Block device %s %d not supported\n", argv[1], dev);
return(1);
}
if (*ep) {
if (*ep != ':') {
puts ("\n** Invalid boot device, use `dev[:part]' **\n");
return(1);
}
part = (int)simple_strtoul(++ep, NULL, 16);
}
if (argc == 4) {
filename = argv[3];
}
PRINTF("Using device %s %d:%d, directory: %s\n", argv[1], dev, part, filename);
if ((part_length = ext2fs_set_blk_dev(dev_desc, part)) == 0) {
printf ("** Bad partition - %s %d:%d **\n", argv[1], dev, part);
ext2fs_close();
return(1);
}
if (!ext2fs_mount(part_length)) {
printf ("** Bad ext2 partition or disk - %s %d:%d **\n", argv[1], dev, part);
ext2fs_close();
return(1);
}
if (ext2fs_ls (filename)) {
printf ("** Error ext2fs_ls() **\n");
ext2fs_close();
return(1);
};
ext2fs_close();
return(0);
}
static int dev_stor_index(block_dev_desc_t *dd)
{
int i, type;
type = dev_stor_type(dd);
for (i = 0; i < specs[type].max_dev; i++)
if (dd == get_dev(specs[type].name, i))
return i;
return (specs[type].max_dev);
}
/**
* Find apbdev.
* @param ven_id vendor ID
* @param dev_id device ID
* @return slotnumber or -1
*/
static inline int find_apbdev_slotnum(uint8_t ven_id, uint16_t dev_id) {
apb_slot_t *pslotbase = (apb_slot_t *) APB_BASE;
size_t cur_slotnum;
for (cur_slotnum = 0; cur_slotnum < APB_QUANTITY; cur_slotnum++) {
if ((ven_id == get_ven(pslotbase[cur_slotnum].id_reg))
&& (dev_id == get_dev(pslotbase[cur_slotnum].id_reg))) {
return cur_slotnum;
}
}
return -1;
}
/* this will do terrible things if len + ipheader + devheader > dev->mtu */
static int
packet_sendto (volatile struct sock *sk, unsigned char *from, int len,
int noblock,
unsigned flags, struct sockaddr_in *usin, int addr_len)
{
struct sk_buff *skb;
struct device *dev;
struct sockaddr saddr;
/* check the flags. */
if (flags) return (-EINVAL);
if (len < 0) return (-EINVAL);
/* get and verify the address. */
if (usin)
{
if (addr_len < sizeof (saddr))
return (-EINVAL);
/* verify_area (VERIFY_WRITE, usin, sizeof (saddr));*/
memcpy_fromfs (&saddr, usin, sizeof(saddr));
}
else
return (-EINVAL);
skb = sk->prot->wmalloc (sk, len+sizeof (*skb), 0, GFP_KERNEL);
/* this shouldn't happen, but it could. */
if (skb == NULL)
{
PRINTK (("packet_sendto: write buffer full?\n"));
return (-EAGAIN);
}
skb->lock = 0;
skb->mem_addr = skb;
skb->mem_len = len + sizeof (*skb);
skb->sk = sk;
skb->free = 1;
saddr.sa_data[13] = 0;
dev = get_dev (saddr.sa_data);
if (dev == NULL)
{
sk->prot->wfree (sk, skb->mem_addr, skb->mem_len);
return (-ENXIO);
}
/* verify_area (VERIFY_WRITE, from, len);*/
memcpy_fromfs (skb+1, from, len);
skb->len = len;
skb->next = NULL;
if (dev->up)
dev->queue_xmit (skb, dev, sk->priority);
else
kfree_skb (skb, FREE_WRITE);
return (len);
}
int timer_set_absolute(tim_t tim, int channel, unsigned int value)
{
if (tim >= TIMER_NUMOF || channel >= TIMER_CHAN_NUMOF) {
return -1;
}
lpc23xx_timer_t *dev = get_dev(tim);
dev->MR[channel] = value;
dev->MCR |= (1 << (channel * 3));
return 0;
}
int
do_fat_fswrite (cmd_tbl_t *cmdtp, int flag, int argc, char *argv[])
{
long size;
unsigned long offset;
unsigned long count;
char buf[12];
block_dev_desc_t *dev_desc=NULL;
int dev=0;
int part=1;
char *ep;
if (argc < 6) {
printf ("usage: fatwrite <interface> <dev[:part]> "
"<addr> <filename> <bytes>\n");
return 1;
}
dev = (int)simple_strtoul (argv[2], &ep, 16);
dev_desc=get_dev(argv[1],dev);
if (dev_desc==NULL) {
puts ("\n** Invalid device **\n");
return 1;
}
if (*ep) {
if (*ep != ':') {
puts ("\n** Invalid device, use `dev[:part]' **\n");
return 1;
}
part = (int)simple_strtoul(++ep, NULL, 16);
}
if (fat_register_device(dev_desc,part)!=0) {
printf ("\n** Unable to use %s %d:%d for fatwrite **\n",
argv[1],dev,part);
return 1;
}
offset = simple_strtoul (argv[3], NULL, 16);
count = simple_strtoul (argv[5], NULL, 16);
size = file_fat_write(argv[4], (unsigned char *)offset, count);
if (size <= 0) {
printf("\n** Unable to write\"%s\" to %s %d:%d **\n",
argv[4],argv[1],dev,part);
return 1;
}
printf ("\n%ld bytes written\n", size);
sprintf(buf, "%lX", size);
setenv("filesize", buf);
return 0;
}
