Project import
diff --git a/Makefile b/Makefile
new file mode 100644
index 0000000..5e0a6be
--- /dev/null
+++ b/Makefile
@@ -0,0 +1,102 @@
+#
+# Copyright (c) 2010-2014 Nest, Inc.
+# All rights reserved.
+#
+# This document is the property of Nest. It is considered
+# confidential and proprietary information.
+#
+# This document may not be reproduced or transmitted in any form,
+# in whole or in part, without the express written permission of
+# Nest.
+#
+# Description:
+# This file is the make file for the Freescale UTP over USB MSC
+# tool, uuc.
+#
+
+BuildConfigSpecialized := No
+BuildProductSpecialized := No
+
+include pre.mak
+
+PackageName := uuc
+
+PackageExtension := tar.gz
+PackageSeparator := -
+
+PackagePatchArgs := -p1
+
+PackageArchive := $(PackageName)-$(PackageVersion).$(PackageExtension)
+PackageSourceDir := $(PackageName)$(PackageSeparator)$(PackageVersion)
+
+PackageBuildMakefile = $(call GenerateBuildPaths,Makefile)
+
+LicenseSourceFile := $(PackageSourceDir)/COPYING
+
+CleanPaths += $(PackageLicenseFile)
+
+UUIDDir := sw/tps/e2fsprogs
+UUIDIncDir = $(call GenerateResultPaths,$(UUIDDir),usr/include)
+UUIDLibDir = $(call GenerateResultPaths,$(UUIDDir),usr/lib)
+
+all: $(PackageDefaultGoal)
+
+# Generate the package license contents.
+
+$(LicenseSourceFile): source
+
+$(PackageLicenseFile): $(LicenseSourceFile)
+ $(copy-result)
+
+# Extract the source from the archive and apply patches, if any.
+
+$(PackageSourceDir): $(PackageArchive) $(PackagePatchPaths)
+ $(expand-and-patch-package)
+
+# Prepare the sources.
+
+.PHONY: source
+source: | $(PackageSourceDir)
+
+# Patch the sources, if necessary.
+
+.PHONY: patch
+patch: source
+
+# Generate the package build makefile.
+
+$(PackageBuildMakefile): | $(PackageSourceDir) $(BuildDirectory)
+ $(call create-links,$(CURDIR)/$(PackageSourceDir),$(BuildDirectory))
+
+# Configure the source for building.
+
+.PHONY: configure
+configure: source $(PackageBuildMakefile)
+
+# Build the source.
+#
+# We have to unset MAKEFLAGS since they confuse the package build otherwise.
+
+.PHONY: build
+build: configure | $(BuildDirectory)
+ $(Verbose)unset MAKEFLAGS && \
+ $(MAKE) -C $(BuildDirectory) \
+ CC="$(CC)" CXX="$(CXX)" AR=$(AR) NM=$(NM) RANLIB=$(RANLIB) STRIP=$(STRIP) \
+ CFLAGS="-I$(LinuxHeaderDir)" \
+ all
+
+# Stage the build to a temporary installation area.
+#
+# We have to unset MAKEFLAGS since they confuse the package build otherwise.
+
+.PHONY: stage
+stage: build | $(ResultDirectory)
+ $(Verbose)unset MAKEFLAGS && \
+ $(MAKE) -C $(BuildDirectory) DEST_DIR=$(ResultDirectory) install
+
+clean:
+ $(Verbose)$(RM) $(RMFLAGS) -r $(PackageSourceDir)
+ $(Verbose)$(RM) $(RMFLAGS) -r $(BuildDirectory)
+ $(Verbose)$(RM) $(RMFLAGS) -r $(ResultDirectory)
+
+include post.mak
diff --git a/uuc-3.0.35-4.1.0.tar.gz b/uuc-3.0.35-4.1.0.tar.gz
new file mode 100755
index 0000000..cebbbfc
--- /dev/null
+++ b/uuc-3.0.35-4.1.0.tar.gz
Binary files differ
diff --git a/uuc-3.0.35-4.1.0/Makefile b/uuc-3.0.35-4.1.0/Makefile
new file mode 100644
index 0000000..29ce91a
--- /dev/null
+++ b/uuc-3.0.35-4.1.0/Makefile
@@ -0,0 +1,20 @@
+CC=$(CROSS_COMPILE)gcc
+AR=$(CROSS_COMPILE)AR
+
+all: uuc sdimage
+
+uuc: uu.c
+ $(CC) uu.c -o uuc -lpthread
+
+sdimage: sdimage.c
+ $(CC) sdimage.c -o sdimage
+
+install:
+ mkdir -p $(DEST_DIR)
+ cp linuxrc $(DEST_DIR)
+ mkdir -p $(DEST_DIR)/usr/bin
+ cp uuc $(DEST_DIR)/usr/bin
+ cp sdimage $(DEST_DIR)/usr/bin
+clean:
+ rm -f uuc
+ rm -f sdimage
diff --git a/uuc-3.0.35-4.1.0/linuxrc b/uuc-3.0.35-4.1.0/linuxrc
new file mode 100755
index 0000000..7f1fdcc
--- /dev/null
+++ b/uuc-3.0.35-4.1.0/linuxrc
@@ -0,0 +1,15 @@
+#!/bin/sh
+#mkdir /sys /proc
+mount -t sysfs none /sys
+mount -t proc none /proc
+export PATH=/sbin:/bin:/usr/sbin:/usr/bin
+echo "Starting UTP"
+cd /home
+#disable turn off display
+mknod /dev/tty0 c 4 0
+#get up-to-date mount information
+ln -s /proc/mounts /etc/mtab
+echo "disable turn off display"
+echo -e "\033[9;0]" > /dev/tty0
+/etc/rc.d/init.d/udev start
+/usr/bin/uuc
diff --git a/uuc-3.0.35-4.1.0/sdimage.c b/uuc-3.0.35-4.1.0/sdimage.c
new file mode 100644
index 0000000..d41f2cc
--- /dev/null
+++ b/uuc-3.0.35-4.1.0/sdimage.c
@@ -0,0 +1,192 @@
+/*
+ * Copyright (C) 2009-2010 Freescale Semiconductor, Inc. All Rights Reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ */
+
+#include <stdio.h>
+#include <unistd.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <string.h>
+#include <stdlib.h>
+char *g_filedev;
+char *g_firmware;
+
+struct PART {
+ unsigned char boot;
+ unsigned char starthead;
+ unsigned char startsector;
+ unsigned char startcylinder;
+ unsigned char filesystem;
+ unsigned char endhead;
+ unsigned char endsector;
+ unsigned char endcylinder;
+ unsigned int start;
+ unsigned int count;
+} __attribute__ ((packed));
+struct MBR {
+ unsigned char resevered[446];
+ struct PART part[4];
+ unsigned short sign;
+} __attribute__ ((packed));
+
+struct DeviceInfo {
+ unsigned int u32ChipNum;
+ unsigned int u32DriverType;
+ unsigned int u32Tag;
+ unsigned int u32FirstSectorNumber;
+ unsigned int u32SectorCount;
+} __attribute__ ((packed));
+
+struct ConfigBlock {
+ unsigned int u32Sigature;
+ unsigned int u32PrimaryBootTag;
+ unsigned int u32SecondaryBootTags;
+ unsigned int u32NumCopies;
+ struct DeviceInfo aDriverInfo[10];
+} __attribute__ ((packed));
+
+int main(int argc, char **argv)
+{
+ int i = 0;
+ int devhandle;
+ int firmwarehandle;
+ struct MBR mbr;
+ struct ConfigBlock bcb;
+ char *buff;
+ struct stat filestat;
+
+ if (argc < 2) {
+ printf("sdimage -f <firmware.sb> -d </dev/mmcblk>\n");
+ return -1;
+ }
+ for (i = 0; i < argc; i++) {
+ if (strcmp(argv[i], "-f") == 0) {
+ g_firmware = argv[i + 1];
+ i++;
+ }
+ if (strcmp(argv[i], "-d") == 0) {
+ g_filedev = argv[i + 1];
+ i++;
+ }
+ }
+ if (g_firmware == NULL) {
+ printf("you need give -f <firmware file>\n");
+ return -1;
+ }
+ if (g_filedev == NULL) {
+ printf("you need give -d <dev file> \n");
+ return -1;
+ }
+
+ devhandle = open(g_filedev, O_RDWR);
+ if (devhandle < 0) {
+ printf("can't open file %s\n", g_filedev);
+ return -1;
+ }
+
+ firmwarehandle = open(g_firmware, O_RDWR);
+ if (firmwarehandle < 0) {
+ printf("can't open file %s\n", g_firmware);
+ return -1;
+ }
+ if (stat(g_firmware, &filestat)) {
+ printf("stat %s error\n", g_firmware);
+ return -1;
+ }
+ if (read(devhandle, &mbr, sizeof(mbr)) < sizeof(mbr)) {
+ printf("read block 0 fail");
+ return -1;
+ }
+
+ if (mbr.sign != 0xAA55) {
+ printf("Check MBR signature fail 0x%x\n", mbr.sign);
+ return -1;
+ }
+
+ for (i = 0; i < 4; i++) {
+ if (mbr.part[i].filesystem == 'S')
+ break;
+ }
+
+ if (i == 4) {
+ printf("Can't found boot stream partition\n");
+ return -1;
+ }
+
+ if ((mbr.part[i].count * 512) < (2 * filestat.st_size + 1)) {
+ printf("firmare partition is too small\n");
+ return -1;
+ }
+
+ memset(&bcb, 0, sizeof(bcb));
+ bcb.u32Sigature = 0x00112233;
+ bcb.u32PrimaryBootTag = 1;
+ bcb.u32SecondaryBootTags = 2;
+ bcb.u32NumCopies = 2;
+
+ bcb.aDriverInfo[0].u32ChipNum = 0;
+ bcb.aDriverInfo[0].u32DriverType = 0;
+ bcb.aDriverInfo[0].u32Tag = bcb.u32PrimaryBootTag;
+ bcb.aDriverInfo[0].u32FirstSectorNumber = mbr.part[i].start + 1;
+
+ bcb.aDriverInfo[1].u32ChipNum = 0;
+ bcb.aDriverInfo[1].u32DriverType = 0;
+ bcb.aDriverInfo[1].u32Tag = bcb.u32SecondaryBootTags;
+ bcb.aDriverInfo[1].u32FirstSectorNumber =
+ bcb.aDriverInfo[0].u32FirstSectorNumber
+ + ((filestat.st_size + 511) / 512);
+
+ lseek(devhandle, mbr.part[i].start * 512, SEEK_SET);
+ if (write(devhandle, &bcb, sizeof(bcb)) != sizeof(bcb)) {
+ printf("write bcb error\n");
+ return -1;
+ }
+
+ buff = malloc(filestat.st_size);
+ if (buff == NULL) {
+ printf("malloc fail\n");
+ return -1;
+ }
+
+ if (read(firmwarehandle, buff, filestat.st_size) != filestat.st_size) {
+ printf("read firmware fail\n");
+ return -1;
+ }
+
+ printf("write first firmware\n");
+
+ lseek(devhandle, (mbr.part[i].start + 1) * 512, SEEK_SET);
+ if (write(devhandle, buff, filestat.st_size) != filestat.st_size) {
+ printf("first firmware write fail\n");
+ return -1;
+ }
+
+ printf("write second firmware\n");
+
+ lseek(devhandle, bcb.aDriverInfo[1].u32FirstSectorNumber * 512,
+ SEEK_SET);
+ if (write(devhandle, buff, filestat.st_size) != filestat.st_size) {
+ printf("second firmware write fail\n");
+ return -1;
+ }
+ free(buff);
+ close(devhandle);
+ close(firmwarehandle);
+ printf("done\r\n");
+ return 0;
+}
diff --git a/uuc-3.0.35-4.1.0/uu.c b/uuc-3.0.35-4.1.0/uu.c
new file mode 100644
index 0000000..0dbbe94
--- /dev/null
+++ b/uuc-3.0.35-4.1.0/uu.c
@@ -0,0 +1,763 @@
+/*
+ * iMX utp decode program
+ *
+ * Copyright 2010-2013 Freescale Semiconductor, Inc.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ */
+
+#define _GNU_SOURCE
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <syscall.h>
+#include <stdint.h>
+#include <fcntl.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+#include <string.h>
+#include <malloc.h>
+#include <errno.h>
+#include <stdarg.h>
+#include <sys/wait.h>
+#include <signal.h>
+#include <pthread.h>
+#include <linux/reboot.h>
+#include <sys/reboot.h>
+/* mxc SoC will enable watchdog at USB recovery mode
+ * so, the user must service watchdog
+ */
+#include <linux/watchdog.h>
+
+#define UTP_DEVNODE "/dev/utp"
+#define UTP_TARGET_FILE "/tmp/file.utp"
+
+#define UTP_FLAG_COMMAND 0x00000001
+#define UTP_FLAG_DATA 0x00000002
+#define UTP_FLAG_STATUS 0x00000004 //indicate an error happens
+#define UTP_FLAG_REPORT_BUSY 0x10000000
+
+
+#pragma pack(1)
+
+#define PACKAGE "uuc"
+#define VERSION "0.4"
+
+char *utp_firmware_version = "2.6.31";
+char *utp_sn = "000000000000";
+char *utp_chipid = "370000A5";
+/* for utp ioctl */
+#define UTP_IOCTL_BASE 'U'
+#define UTP_GET_CPU_ID _IOR(UTP_IOCTL_BASE, 0, int)
+
+#define NEED_TO_GET_CHILD_PID 1
+/*
+ * this structure should be in sync with the same in
+ * $KERNEL/drivers/usb/gadget/fsl_updater.c
+ */
+struct utp_message {
+ uint32_t flags;
+ size_t size;
+ union {
+ struct {
+ uint64_t payload;
+ char command[1];
+ };
+ struct {
+ size_t bufsize;
+ uint8_t data[1];
+ };
+ uint32_t status;
+ };
+};
+#pragma pack()
+
+static int utp_file = -1;
+static FILE *utp_file_f = NULL;
+
+static inline char *utp_answer_type(struct utp_message *u)
+{
+ if (!u)
+ return "UNKNOWN";
+ if (u->flags & UTP_FLAG_STATUS)
+ return "Non-success";
+ if (u->flags & UTP_FLAG_DATA)
+ return "Data";
+ if (u->flags & UTP_FLAG_REPORT_BUSY)
+ return "Busy";
+ if (u->flags & UTP_FLAG_COMMAND)
+ return "Command ?!";
+ return "Success";
+}
+
+/*
+ * utp_mk_devnode
+ *
+ * Parse the /sys entry to find major and minor for device
+ * If/when found, create device node with type 'type'
+ *
+ * Example: utp_mk_devnode("block", "sda", "/dev/scsi-disk-0", S_IFBLK)
+ */
+static int utp_mk_devnode(char *class, char *name, char *node, int type)
+{
+ char sys[256];
+ char devnode[20]; /* major:minor */
+ int major, minor;
+ char *colon;
+ int len, f, rc = -EINVAL;
+
+ if (access(node, F_OK) == 0) {
+ printf("UTP: file/device node %s already exists\n", node);
+ return 0;
+ }
+
+ snprintf(sys, sizeof(sys), "/sys/%s/%s/dev", class, name);
+ f = open(sys, O_RDONLY);
+ if (f >= 0) {
+ memset(devnode, 0, sizeof(devnode));
+ len = read(f, devnode, sizeof(devnode));
+ if (len >= 0) {
+ sscanf(devnode, "%d:%d", &major, &minor);
+ printf("%s: creating node '%s' with %d+%d\n", __func__, node, major, minor);
+ unlink(node);
+ rc = mknod(node, type | 0666, makedev(major, minor));
+ }
+ close(f);
+ }
+ return rc;
+}
+
+/*
+ * utp_run
+ *
+ * Start the subshell and execute the command passed
+ */
+static utp_run(char *command, ... )
+{
+ int r;
+ char cmd[1024];
+ va_list vptr;
+
+ va_start(vptr, command);
+ vsnprintf(cmd, sizeof(cmd), command, vptr);
+ va_end(vptr);
+
+ printf("UTP: executing \"%s\"\n", cmd);
+ return system(cmd);
+}
+
+/*
+ * utp_send_busy
+ *
+ * report the busy state to the kernel state machine
+ */
+static void utp_send_busy(int u)
+{
+ struct utp_message w;
+
+ w.flags = UTP_FLAG_REPORT_BUSY;
+ w.size = sizeof(w);
+ write(u, &w, w.size);
+}
+
+/*
+ * utp_partition_mmc
+ *
+ * chat with fdisk to create bootable partition of type 0x53 and extended one
+ */
+static int utp_partition_mmc(char *disk)
+{
+ char fc[50];
+ int i;
+ char shell_cmd[256];
+ int fdisk;
+ FILE *fdisk_f;
+
+ sprintf(shell_cmd, "fdisk %s", disk);
+ fdisk_f = popen(shell_cmd, "w");
+ if (fdisk_f < 0)
+ return errno;
+
+ fdisk = fileno(fdisk_f);
+ for (i = 4; i >= 1 ; i--) {
+ sprintf(fc, "d\n%d\n", i);
+ write(fdisk, fc, strlen(fc));
+ }
+
+ sprintf(fc, "n\np\n1\n1\n+16M\n");
+ write(fdisk, fc, strlen(fc));
+
+ sprintf(fc, "n\np\n2\n\n\n");
+ write(fdisk, fc, strlen(fc));
+
+ sprintf(fc, "t\n1\n0x%X\n\n", 0x53);
+ write(fdisk, fc, strlen(fc));
+
+ write(fdisk, "w\nq\n", 2);
+
+ pclose(fdisk_f);
+
+ return 0;
+}
+
+/*
+ * utp_do_selftest
+ *
+ * perform some diagnostics
+ *
+ * TBW
+ */
+static int utp_do_selftest(void)
+{
+ return 0;
+}
+/*
+ * Put the command which needs to send busy first
+ * And the host will send poll for getting its return value
+ * later, we call these kinds of commands as Asynchronous Commands.
+ */
+static int utp_can_busy(char *command)
+{
+ char *async[] ={
+ "$ ", "frf", "pollpipe", NULL,
+ };
+ char **ptr;
+
+ ptr = async;
+ while (*ptr) {
+ if (strncmp(command, *ptr, strlen(*ptr)) == 0)
+ return 1;
+ ptr++;
+ }
+ return 0;
+}
+#ifdef NEED_TO_GET_CHILD_PID
+/* for pipe */
+#define READ 0
+#define WRITE 1
+static pid_t child_pid = -1;
+static int utp_flush(void)
+{
+ int pstat;
+ int ret = 0;
+ pid_t pid;
+ if (utp_file >= 0) {
+ fflush(NULL);
+ ret = close(utp_file);
+ do{
+ pid = waitpid(child_pid, &pstat, 0); /* wait for child finished */
+ }while (pid == -1 && errno == EINTR);
+ printf("UTP: closing the file\n");
+ }
+ utp_file = -1;
+ return ret;
+}
+pid_t popen2(const char *command, int *infp, int *outfp)
+{
+ int p_stdin[2], p_stdout[2];
+ pid_t pid;
+
+ if (pipe(p_stdin) != 0 || pipe(p_stdout) != 0)
+ return -1;
+
+ pid = fork();
+
+ if (pid < 0)
+ return pid;
+ else if (pid == 0){
+ close(p_stdin[WRITE]);
+ if (infp == NULL)
+ close(p_stdin[READ]);
+ else
+ dup2(p_stdin[READ], READ);
+ close(p_stdout[READ]);
+ if (outfp == NULL)
+ close(p_stdout[WRITE]);
+ else
+ dup2(p_stdout[WRITE], WRITE);
+
+ execl("/bin/sh", "sh", "-c", command, NULL);
+ perror("execl");
+ exit(1);
+ }
+
+ if (infp == NULL)
+ close(p_stdin[WRITE]);
+ else
+ *infp = p_stdin[WRITE];
+
+ if (outfp == NULL)
+ close(p_stdout[READ]);
+ else
+ *outfp = p_stdout[READ];
+
+ close(p_stdin[READ]);
+ close(p_stdout[WRITE]);
+ return pid;
+}
+int utp_pipe(char *command, ... )
+{
+ int r, infp;
+ char shell_cmd[1024];
+ va_list vptr;
+ va_start(vptr, command);
+ vsnprintf(shell_cmd, sizeof(shell_cmd), command, vptr);
+ va_end(vptr);
+
+ child_pid = popen2(shell_cmd, &infp, NULL);
+ if (child_pid < 0){
+ printf("the fork is failed \n");
+ return -1;
+ }
+ utp_file = infp;
+ printf("pid is %d, UTP: executing \"%s\"\n",child_pid, shell_cmd);
+ return 0;
+}
+int utp_poll_pipe()
+{
+ int ret = 0, cnt = 0xFFFF;
+ while(ret == 0 && cnt > 0){
+ ret = is_child_dead();
+ usleep(10000);
+ cnt--;
+ }
+
+ if(ret == 0)
+ return 1;//failure
+ else
+ return 0;//Success
+}
+
+
+#else
+static int utp_flush(void)
+{
+ int ret;
+ if (utp_file_f) {
+ printf("UTP: waiting for pipe to close\n");
+ ret = pclose(utp_file_f);
+ }
+ else if (utp_file >= 0) {
+ printf("UTP: closing the file\n");
+ ret = close(utp_file);
+ }
+ utp_file_f = NULL;
+ utp_file = -1;
+ printf("UTP: files were flushed.\n");
+ return ret;
+}
+static int utp_pipe(char *command, ... )
+{
+ int r;
+ char shell_cmd[1024];
+ va_list vptr;
+
+ va_start(vptr, command);
+ vsnprintf(shell_cmd, sizeof(shell_cmd), command, vptr);
+ va_end(vptr);
+
+ utp_file_f = popen(shell_cmd, "w");
+ utp_file = fileno(utp_file_f);
+
+ return utp_file_f ? 0 : errno;
+}
+#endif
+/*
+ * utp_handle_command
+ *
+ * handle the command from MSC driver
+ * command can be:
+ * ?
+ * !<type>
+ * $ <shell_command>
+ * wfs/wff <X> write firmware to SD/flash
+ * wrs/wrf <X> write rootfs to SD/flash
+ * frs/frf <X> format partition for root on SD/flash
+ * erase <X> erase partition on flash
+ * read not implemented yet
+ * write not implemented yet
+ */
+static struct utp_message *utp_handle_command(int u, char *cmd, unsigned long long payload)
+{
+ struct utp_message *w = NULL;
+ char devnode[50]; /* enough to fit /dev/mmcblk0p99 */
+ char sysnode[50]; /* -"- -"- mmcblk0/mmcblk0p99 */
+ uint32_t flags, status;
+ char *data = NULL;
+ int f;
+ size_t size;
+
+ printf("UTP: received command '%s'\n", cmd);
+
+ /* defaults */
+ status = 0;
+ flags = 0;
+ size = 0;
+
+ /* these are asynchronous commands and need to send busy */
+ if (utp_can_busy(cmd)){
+ utp_send_busy(u);
+ }
+
+ if (strcmp(cmd, "?") == 0) {
+ /* query */
+ flags = UTP_FLAG_DATA;
+ data = malloc(256);
+ sprintf(data,
+ "<DEVICE>\n"
+ " <FW>%s</FW>\n"
+ " <DCE>%s</DCE>\n"
+ " <SN>%s</SN>"
+ " <CID>%s</CID>"
+ " <VID>%04X</VID>"
+ " <PID>%04X</PID>"
+ "</DEVICE>\n", utp_firmware_version, VERSION, utp_sn, utp_chipid, 0x66F, 0x37FF);
+ size = (strlen(data) + 1 ) * sizeof(data[0]);
+ }
+
+ else if (cmd[0] == '!') {
+ /* reboot the system, and the ACK has already sent out */
+ if (cmd[1] == '3') {
+ sync();
+ kill(-1, SIGTERM);
+ sleep(1);
+ kill(-1, SIGKILL);
+
+ reboot(LINUX_REBOOT_CMD_RESTART);
+ return NULL;
+ }
+ }
+
+ else if (strncmp(cmd, "$ ", 2) == 0) {
+ status = utp_run(cmd + 2);
+ if (status)
+ flags = UTP_FLAG_STATUS;
+ }
+ else if ((strcmp(cmd,"wff") == 0) || (strcmp(cmd, "wfs") == 0)) {
+ /* Write firmware - to flash or to SD, no matter */
+ utp_file = open(UTP_TARGET_FILE, O_CREAT | O_TRUNC | O_WRONLY, 0666);
+ }
+
+ else if (strcmp(cmd, "fff") == 0) {
+ /* perform actual flashing of the firmware to the NAND */
+ utp_flush();
+ if (utp_mk_devnode("class/mtd", "mtd1", "/dev/mtd1", S_IFCHR) >= 0 &&
+ utp_mk_devnode("class/mtd", "mtd0", "/dev/mtd0", S_IFCHR) >= 0) {
+ utp_run("kobs-ng -v -d %s", UTP_TARGET_FILE);
+ }
+ }
+ else if (strcmp(cmd, "ffs") == 0) {
+ /* perform actual flashing of the firmware to the SD */
+ utp_flush();
+
+ /* partition the card */
+ if (!status && utp_mk_devnode("block", "mmcblk0", "/dev/mmc", S_IFBLK) >= 0) {
+ status = utp_partition_mmc("/dev/mmc");
+ /* waiting for partition table to settle */
+ sleep(5);
+ }
+
+ /* write data to the first partition */
+ if (!status && utp_mk_devnode("block", "mmcblk0/mmcblk0p1", "/dev/mmc0p1", S_IFBLK) >= 0) {
+ utp_run("dd if=/dev/zero of=/dev/mmc0p1 bs=512 count=4");
+ utp_run("dd if=%s of=/dev/mmc0p1 ibs=512 seek=4 conv=sync,notrunc", UTP_TARGET_FILE);
+ }
+
+ if (status)
+ flags = UTP_FLAG_STATUS;
+ }
+
+ else if (strncmp(cmd, "mknod", 5) == 0) {
+ int devtype = S_IFCHR;
+ char *class, *item, *type, *node;
+
+ class = strtok(cmd + 6, " \t,;");
+ printf("class = '%s'\n", class);
+ item = strtok(NULL, " \t,;");
+ printf("item = '%s'\n", item);
+ node = strtok(NULL, " \t,;");
+ printf("node = %s\n", node);
+ type = strtok(NULL, " \t,;");
+ printf("type = %s\n", type);
+ if (!node && item)
+ sprintf(devnode, "/dev/%s", item);
+ else
+ strcpy(devnode, node);
+ if (type && (strcmp(type, "block") == 0 || strcmp(type, "blk") == 0))
+ devtype = S_IFBLK;
+ printf("UTP: running utp_mk_devnode(%s,%s,%s,0x%x)\n",
+ class, item, devnode, devtype);
+ status = utp_mk_devnode(class, item, devnode, devtype);
+ if (status)
+ flags = UTP_FLAG_STATUS;
+ }
+
+ else if (strncmp(cmd, "wrf", 3) == 0) {
+ /* Write rootfs to flash */
+ printf("UTP: writing rootfs to flash, mtd #%c, size %lld\n",
+ cmd[3], payload);
+
+ /* ensure that device node is here */
+ snprintf(devnode, sizeof(devnode), "/dev/mtd%c", cmd[3]);
+ utp_mk_devnode("class/mtd", devnode + 5, devnode, S_IFCHR);
+
+ /* then start ubiformat and redirect its input */
+ status = utp_pipe("ubiformat %s -f - -S %lld", devnode, payload);
+ if (status)
+ flags = UTP_FLAG_STATUS;
+ }
+
+ else if (strncmp(cmd, "pipe", 4) == 0) {
+ status = utp_pipe(cmd + 5);
+ if (status)
+ flags = UTP_FLAG_STATUS;
+ }
+
+ else if (strncmp(cmd, "pollpipe", 8) == 0) {
+ printf("UTP: poll pipe.\n");
+ status = utp_poll_pipe();
+ if (status)
+ flags = UTP_FLAG_STATUS;
+ }
+
+ else if (strncmp(cmd, "wrs", 3) == 0) {
+ /* Write rootfs to the SD */
+ printf("UTP: writing rootfs to SD card, mmc partition #%c, size %lld\n",
+ cmd[3], payload);
+
+ /* ensure that device node is here */
+ snprintf(devnode, sizeof(devnode), "/dev/mmcblk0p%c", cmd[3]);
+ snprintf(sysnode, sizeof(sysnode), "mmcblk0/mmcblk0p%d", cmd[3]);
+ utp_mk_devnode("block", sysnode, devnode, S_IFBLK);
+
+ if (payload % 1024)
+ printf("UTP: WARNING! payload %% 1024 != 0, the rest will be skipped");
+
+ status = utp_pipe("dd of=%s bs=1K", devnode);
+ if (status)
+ flags = UTP_FLAG_STATUS;
+ }
+
+
+ else if (strcmp(cmd, "frf") == 0 || strcmp(cmd, "frs") == 0) {
+ /* perform actual flashing of the rootfs to the NAND/SD */
+ status = utp_flush();
+ if (status)
+ flags = UTP_FLAG_STATUS;
+ }
+
+ else if (strncmp(cmd, "untar.", 6) == 0) {
+ status = utp_pipe("tar %cxv -C %s", cmd[6], cmd + 8);
+ if (status)
+ flags = UTP_FLAG_STATUS;
+ }
+
+ else if (strncmp(cmd, "read", 4) == 0) {
+ f = open(cmd + 5, O_RDONLY);
+ if (f < 0) {
+ flags = UTP_FLAG_STATUS;
+ status = errno;
+ } else {
+ size = lseek(f, 0, SEEK_END); /* get the file size */
+ lseek(f, 0, SEEK_SET);
+
+ data = malloc(size);
+ if (!data) {
+ flags = UTP_FLAG_STATUS;
+ status = -ENOMEM;
+ } else {
+ read(f, data, size);
+ flags = UTP_FLAG_DATA;
+ }
+ }
+ }
+
+ else if (strcmp(cmd, "send") == 0) {
+ utp_file = open(UTP_TARGET_FILE, O_TRUNC | O_CREAT | O_WRONLY, 0666);
+ }
+
+ else if (strncmp(cmd, "save", 4) == 0) {
+ close(utp_file);
+ rename(UTP_TARGET_FILE, cmd + 5);
+ }
+
+
+ else if (strcmp(cmd, "selftest") == 0) {
+ status = utp_do_selftest();
+ if (status)
+ flags = UTP_FLAG_STATUS;
+ }
+
+ else {
+ printf("UTP: Unknown command received, ignored\n");
+ flags = UTP_FLAG_STATUS;
+ status = -EINVAL;
+ }
+
+ w = malloc(size + sizeof(*w));
+ if (!w) {
+ printf("UTP: Could not allocate %d+%d bytes!\n", size, sizeof(*w));
+ return NULL;
+ }
+
+ memset(w, 0, sizeof(*w) + size);
+ w->flags = flags;
+ w->size = size + sizeof(*w);
+ if (flags & UTP_FLAG_DATA) {
+ w->bufsize = size;
+ memcpy(w->data, data, size);
+ }
+ if (flags & UTP_FLAG_STATUS)
+ w->status = status;
+ if (data)
+ free(data);
+ return w;
+}
+
+/*
+ * Check the process is dead
+ */
+#define NAME_MAX 30
+int is_child_dead(void)
+{
+ FILE *fh;
+ char path[NAME_MAX + 1];
+ sprintf(path, "/proc/%u/status", (unsigned int)child_pid);
+ if ((fh = fopen(path, "r"))){
+ char buf[1024];
+ while (fgets(buf, sizeof(buf) -1, fh)){
+ if (!strncmp(buf, "State:", 6))
+ {
+ char *p = buf + 6;
+ while (*p == '\t'){
+ p++;
+ continue;
+ }
+ if (*p == 'Z'){
+ printf("Process status polling: %s is in zombie.\n",path);
+ fclose(fh);
+ return 1;
+ }
+ break;
+ }
+ }
+ }
+ else{
+ printf("Process polling: can't open %s, maybe the process %u has been killed already\n",path,child_pid);
+ return 1;
+ }
+
+ fclose(fh);
+ return 0;
+}
+
+
+void feed_watchdog(void *arg)
+{
+ int res;
+ int *fd = arg;
+ while(1) {
+ res = ioctl(*fd, WDIOC_KEEPALIVE);
+ if (res)
+ printf("ioctl WDIOC_KEEPALIVE error L%d, %s\n", __LINE__, strerror(errno));
+ printf("%s\n", __func__);
+ sleep(60);
+ }
+}
+
+int main(void)
+{
+ int u = -1, wdt_fd = -1, r, need_watchdog = 0;
+ int watchdog_timeout = 127; /* sec */
+ int cpu_id = 50;
+ struct utp_message *uc, *answer;
+ char env[256];
+ pthread_t a_thread;
+ void *thread_result;
+
+ printf("%s %s [built %s %s]\n", PACKAGE, VERSION, __DATE__, __TIME__);
+ /* set stdout unbuffered, what is the usage??? */
+// setvbuf(stdout, NULL, _IONBF, 0);
+ uc = malloc(sizeof(*uc) + 0x10000);
+
+ mkdir("/tmp", 0777);
+
+ setenv("FILE", UTP_TARGET_FILE, !0);
+
+ printf("UTP: Waiting for device to appear\n");
+ while (utp_mk_devnode("class/misc", "utp", UTP_DEVNODE, S_IFCHR) < 0) {
+ putchar('.');
+ sleep(1);
+ }
+ u = open(UTP_DEVNODE, O_RDWR);
+ r = ioctl(u, UTP_GET_CPU_ID, &cpu_id);
+ if (r)
+ printf("cpu id get error:L%d, %s\n", __LINE__, strerror(errno));
+ else{
+ switch (cpu_id) {
+ case 23:
+ case 25:
+ case 28:
+ case 50:
+ need_watchdog = 0;
+ break;
+ case 35:
+ case 51:
+ case 53:
+ need_watchdog = 1;
+ break;
+ default:
+ need_watchdog = 0;
+ }
+ printf("cpu_id is %d\n", cpu_id);
+ if (need_watchdog){
+ if (utp_mk_devnode("class/misc", "watchdog", "/dev/watchdog", S_IFCHR)){
+ printf("The watchdog is not configured, needed by mx35/mx51/mx53 \n");
+ printf("%d, %s\n", __LINE__, strerror(errno));
+ } else{
+ wdt_fd = open("/dev/watchdog", O_RDWR);
+ /* set the MAX timeout */
+ r = ioctl(wdt_fd, WDIOC_SETTIMEOUT, &watchdog_timeout);
+ if (r)
+ printf("%d, %s\n", __LINE__, strerror(errno));
+ r = pthread_create(&a_thread, NULL, (void *)feed_watchdog, (void *)(&wdt_fd));
+ if (r != 0) {
+ perror("Thread creation failed");
+ exit(EXIT_FAILURE);
+ }
+ }
+ }
+ }
+
+ for(;;) {
+ r = read(u, uc, sizeof(*uc) + 0x10000);
+ if (uc->flags & UTP_FLAG_COMMAND) {
+ answer = utp_handle_command(u, uc->command, uc->payload);
+ if (answer) {
+ printf("UTP: sending %s to kernel for command %s.\n", utp_answer_type(answer), uc->command);
+ write(u, answer, answer->size);
+ free(answer);
+ }
+ }else if (uc->flags & UTP_FLAG_DATA) {
+ write(utp_file, uc->data, uc->bufsize);
+ }else {
+ printf("UTP: Unknown flag %x\n", uc->flags);
+ }
+ }
+
+ /* should never be here */
+ return 0;
+}
+
diff --git a/uuc.patches/uuc-0001-fix-includes.patch b/uuc.patches/uuc-0001-fix-includes.patch
new file mode 100644
index 0000000..3c52ab1
--- /dev/null
+++ b/uuc.patches/uuc-0001-fix-includes.patch
@@ -0,0 +1,12 @@
+diff -Naur a/sdimage.c b/sdimage.c
+--- a/sdimage.c 2014-07-28 10:44:24.900046829 -0700
++++ b/sdimage.c 2014-07-28 10:45:34.108632190 -0700
+@@ -21,6 +21,8 @@
+ #include <sys/types.h>
+ #include <sys/stat.h>
+ #include <fcntl.h>
++#include <string.h>
++#include <stdlib.h>
+ char *g_filedev;
+ char *g_firmware;
+
diff --git a/uuc.url b/uuc.url
new file mode 100644
index 0000000..fd00a19
--- /dev/null
+++ b/uuc.url
@@ -0,0 +1 @@
+https://www.freescale.com/webapp/sps/download/license.jsp?colCode=L3.0.35_4.1.0_ER_SOURCE_BSP&appType=file2&location=null&DOWNLOAD_ID=null
diff --git a/uuc.version b/uuc.version
new file mode 100644
index 0000000..8fc2e4f
--- /dev/null
+++ b/uuc.version
@@ -0,0 +1 @@
+3.0.35-4.1.0
