SamyGO for DUMMIES

2011-01-22T20:24:28Z

Marcelru:

How to enable Telnet on samsung TV's

2011-01-22T15:55:36Z

Marcelru:

[http://en.wikipedia.org/wiki/Telnet Telnet] is an old-style way of communication between computers. Many embedded systems, including many Samsung TV's (not all) rely on this tool to connect to the outside world through a command line interface (CLI). By default, the telnet functionality is not enabled in our Sammy's, so some actions are needed to switch it on.

If you are not familiar with flashing firmwares, patching binary files etc., I recommend to take some time to read and understand what you are doing first! THIS CAN BRICK YOUR DEVICE !!

Read on for a detailed HowTo of the steps to be taken :

==The Safe Way==
*Using [[SamyGO Telnet Enabler]] Samsung TV application, you can enable telnet of TV without changing firmware.
Enabling telnet with this program is not dangerous '''but''' with wrong telnet commands, still you have a chance to brick your TV.
Download this program to your USB Flash, then plug it into your TV. Using the Content Library from the Pup-Up menu, select USB, then under '''Game''' menu, select and start the SamyGO application once.
The TV will go black and then returns to the menu. This will enable your TV's telnet for one session only. When you reboot your TV (switch off and back on) you need to reopen telnet via the menus.
I advise you to use the Automated script if you plan to do some development on your TV. If you just want to have look how things work, the safe way is better.
[http://download.samygo.tv/SamyGO%20Content%20Library%20Applications/SamyGO%20Telnet%20Enabler%20v0.01.tar.gz Download SamyGO Telnet Enabler Program].

== Prerequisites ==
(if you do not have ALL of these: Google is your friend, at least for the software):

*a Samsung TV attached to your local network.
*a hex editor.
**Linux : okteta and many others
**Windows: flexhex, neo, and many others.
*a crc32 checksum calculator.
**Linux : okteta 0.3 or later, check, minicrc, etc...
**Windows: flexhex, be wary of little endian (byte-reversed) checksums, possibly others
*xor encryption/decryption software.
**Linux : okteta 0.3 or later, crypt-xor, [http://www.habets.pp.se/synscan/programs.php?prog=xor-analyze xor-analyze], etc...
**Windows: flexhex, possibly others
*a normal ASCII editor.
**Linux : emacs, vi, gedit and and many more.
**Windows: notepad (Or a word processor. Be careful to save in ascii mode, .txt format)
*a telnet client.

== Hacking the Firmware ==
To acquire telnet access to your tv, do the following:

*Download the firmware package for your tv from the Samsung website and unpack it. As an example in this HOWTO, the T-CHU7DEUC.exe file for a ue40b70xx is taken. This will also work on any other xor-encoded firmware. Just replace the T-CHU7DEUC in this howto with your firmware name. When working on a linux box, you can unpack it with wine, unrar, or p7zip (just run `7z x <exe>`).
*Decrypt exe.img.enc in the T-CHU7DEUC/image directory using an xor decrypter with key "T-CHU7DEUC" (the firmware root directory name) and name it exe.img
*Check the CRC32 checksum of your decrypted file (exe.img). It should match the checksum (8-digit hexadecimal number), <xxxxxxxx> given in validinfo.txt _exactly_:
*007_exe.img_xxxxxxxx*011_appdata.img_126fb41f
If the checksums don't match, check the following: Is the downloaded file not corrupted? Is your decryption flawless?
*Using a hex-editor, make the following changes to the contents of rc.local in the decrypted exe.img file: locate the lines:

export KF_LOG=/dev/null '''#Remove engine logging.'''
cd /mtd_exe/

./exeDSP

and replace just the text element marked '''bold''', as shown below:

export KF_LOG=/dev/null''';/etc/telnetd_start.sh&'''
cd /mtd_exe/

./exeDSP
-> For safety reasons it is recommended that you don't miss the "&" at the end ( this is not yet considered in the SamyGo Script YET! )

Make sure you do not change the length of the image file. To be on the safe side, replace any unprintable characters on the changed line with spaces, but _keep_ the linefeed (0x0a)

And remember: Think before you type.
*Re-calculate the CRC32 checksum for the updated image.
*Using a normal ASCII editor, update validinfo.txt in the T-CHU7DEUC/image directory with the new CRC information: Replace xxxxxxxx in this line with the newly calculated checksum (8 hexadecimal digits, be aware of leading zeros):
*007_exe.img_xxxxxxxx*011_appdata.img_126fb41f
*Encrypt exe.img again, using xor encryption with key "T-CHU7DEUC" and copy it into the T-CHU7DEUC/image directory. Name it "exe.img.enc"

=== Flash to TV ===
*Move the T-CHU7DEUC directory and all of its contents to an otherwise empty USB drive, plugin the USB drive into your TV and manually start the upgrade via the appropriate menu entry on your TV

=== Result ===
*After upgrade, open a shell and start a telnet session on your tv:

$ telnet aaa.bbb.ccc.ddd

with aaa.bbb.ccc.ddd your tv's IP-address. when prompted, log in as <root>
This is what you'll see, when connected:

$ telnet aaa.bbb.ccc.ddd
Trying aaa.bbb.ccc.ddd...
Connected to aaa.bbb.ccc.ddd.
Escape character is '^]'.

localhost login: root
-sh: id: not found
#
You can now start typing commands. For available commands visit the normal places: /bin, /sbin, /usr/bin and /usr/sbin

== Browsing the Firmware ==

Decoding the ''run.sh.enc'' script shows that a bunch of images may be present and will automatically be flashed if found. This includes the kernel, the root filesystem, the u-boot bootloader, and the aux filesystems (below). The former seem to require loading over the USB serial though?

The ''exe.img.enc'' file, once decrypted, can be mounted as a normal FAT filesystem. Under Linux, you can do:
$ mkdir exe-dir
$ sudo mount -o loop -t vfat exe.img.dec exe-dir/
$ ls exe-dir/
Comp_LIB/ EXE_IMG_VER JadeTarget prelink.conf samdrv.ko
ddr_margin Factory.dat JadeTarget.cfg rc.local SpecialItemNumber.txt
edid/ game_lib/ LifeScenario ReleaseInfo value.bin
exeDSP InfoLink/ prelink.cache $rfs_log.lo$ YWidget_LIB/

The ''appdata.img.enc'' file, once decrypted, is a normal squashfs image (albeit an old 3.0 version). So if attempts to loop mount this image fail with:
$ mkdir app-dir
$ sudo mount -o loop,ro -t squashfs appdata.img.dec app-dir/
mount: wrong fs type, bad option, bad superblock on /dev/loop/1,
$ dmesg | tail -n1
SQUASHFS error: Major/Minor mismatch, older Squashfs 3.0 filesystems are unsupported

Then you can use unsquashfs from [http://squashfs.sourceforge.net/ squashfs-tools] to unpack it:
$ unsquashfs appdata.img.dec
Parallel unsquashfs: Using 2 processors
2203 inodes (4374 blocks) to write

[===============================================/] 4374/4374 100%
created 2190 files
created 102 directories
created 13 symlinks
created 0 devices
created 0 fifos
$ ls squashfs-root/
APPDATA_IMG_VER Font/ lib/ resource/ widget/
Demo/ Images_960x540/ QPI_DTV_AUDIO.ts testPlay.ts

==Automated Way==
*If you know what you are doing and are simply looking for a tool that will do all of the hacking for you, then you can use [[SamyGO Firmware Patcher]].

SamyGO for DUMMIES

2011-01-16T11:52:28Z

Marcelru:

SamyGO for DUMMIES

2011-01-13T21:46:02Z

Marcelru:

SamyGO for DUMMIES

2011-01-12T22:05:48Z

Marcelru:

SamyGO for DUMMIES

2011-01-12T18:43:07Z

Marcelru:

SamyGO for DUMMIES

2011-01-11T22:50:51Z

Marcelru:

Marcelru:

Setting up a cross-compilation toolchain

2009-10-26T21:04:10Z

Marcelru: /* Building the toolchain on Linux */

This page is a brief summary of the cross-compilation discussion on the SamyGO forum. Main contributors to this information are Robbiesz and marcelru.
The information in this page pertains to the building of a toolchain, based on the source code as stored in the file 32B650.zip, available from Samsung.

We are still in the testing phase, for now, check out the forum discussion (topic: cross-compilation [http://forum.samygo.tv/viewtopic.php?f=5&t=34]). For more info, errors you may encounter, support for other Samsung toolchains, please refer to the forum, or better still, participate.

===Toolchains 101===
A toolchain is a set of executable programs that enables you to build (assemble, compile and link) your own executable programs from source code (typically C, C++, fortran or other programming languages). To build these executables, the source code needs to be translated into machine-readable code. This is what a toolchain does. The translation proceeds in three steps (well, you may think of it this way): translation into low-level code (compilation), translation to machine-readable code (assembly), combination with other code libraries (linking). Compilation/assembly mostly proceeds in a single go. So, for a toolchain you need at least three programs: a compiler, an assembler, and a linker. In almost all cases you will also need a C-library to link with.

Unlike source code, executables are machine-specific. That means that executables built for the Intel x86 architecture (the basis for most computers in the world today) will not run on other types of processors, for example the ARM architecture, the basis for many embedded systems. Our Sammys are ARM-based machines. To build executables for a Samsung TV on an x86-based machine, you will need a toolchain that runs on the x86-architecture and builds executable code for the ARM-architecture. This procedure is called cross-compilation, and requires a cross compilation toolchain. This wiki page deals with the installation of the toolchain provided by Samsung, on an x86, Linux or Windows (Cygwin) platform.
===The Samsung toolchain===
The source code for the Samsung ARM toolchain is available on the net, but needs some adjustments before it can be built. We will discuss that later.
The main parts are:
*GNU binutils (containing among other things an assembler and a linker)
*GCC, the GNU C/C++ compiler (and a host of other languages we will not use)
*Glibc, the GNU C library
*linux kernel sources, for operating system/processor specific details.

For the remainder of this wiki page, we will use the toolchain for the 32B650/32B550/... TV's as an example. The source code for this toolchain is stored in the file 32B650.zip [http://www.samsung.com/global/opensource/files/32B650.zip]. Download this file and store it in the directory where you want to build your toolchain.
Download the SamyGO patches that enable compilation of the toolchain here: [http://forum.samygo.tv/download/file.php?id=14]
===Building the toolchain on Linux===
Since most Linux distro's come standard with a full toolchain for building packages, building the cross-compilation toolchain on this platform is fairly straightforward, and proceeds in 6 stages (You will need approximately 2.5GB diskspace for the build).
====Source installation====
Unpack and install the source code files. This is done with the script install_sources.sh: edit paths and code versions to your liking:

#! /bin/sh
#
# install_sources.sh installs the source code for the toolchain for Samsung
# TV's, as found in the file 32B650.zip. Place this file together with the
# patches tarball (SamyGO-toolchain_fc11_patches.tgz) in the ${BUILDROOT}
# directory, defined below, and run this script.
#
BUILDROOT=/tmp/arm-tools # edit according to your needs.

cd ${BUILDROOT}
mkdir -p ${BUILDROOT}/src

# unpack the Samsung zip file

unzip 32B650.zip

# remove unnecessary stuff and move the kernel and toolchain code

rm -f libgphoto2-2.3.1.tar.zip
rm -f libusb-0.1.12.tar.gz
rm -f SDL-1.2.11.zip
mv linux.chelsea.tgz ${BUILDROOT}/src

# unpack the toolchain and remove unnecessary stuff

tar -zxvf SELP.3.2.x-Chelsea.src.tgz
rm -f SELP.3.2.x-Chelsea.src.tgz

mv ./SELP.3.2.x-Chelsea.src/Toolchain/gcc-4.2.0-4.0.9.tgz ${BUILDROOT}/src
mv ./SELP.3.2.x-Chelsea.src/Toolchain/binutils-2.17.50.tgz ${BUILDROOT}/src
mv ./SELP.3.2.x-Chelsea.src/Toolchain/glibc-2.5.90-9.0.9.tgz ${BUILDROOT}/src

rm -rf ./SELP.3.2.x-Chelsea.src

# unpack the patches and move them

tar -zxvf SamyGO-toolchain_fc11_patches.tgz
mv *.patch ${BUILDROOT}/src
====Kernel headers installation====
Install the kernel header files. You will need these when you want to build your own kernel modules for your TV. For that, the kernel source code's version has to match your TV's kernel version _exactly_. The installation is done with the install_kernel_src.sh script: again, edit to meet your needs.

#! /bin/sh

# how to install kernel headers using this script:
#
# Create the ${BUILDROOT} directory, put this script (install_kernel_src.sh)
# in it.
# In ${BUILDROOT}, create a directory ./src and put the linux tarball in it.

# go up one directory and run this script.

TARGET=arm-SamyGO-linux-gnueabi
BUILDROOT=/tmp/arm-tools
PREFIX=/usr/local # change to your needs
SYSROOT=${BUILDROOT}/sysroot

export ARCH=arm
export CROSS_COMPILE=${TARGET}-
export PATH=$PATH:${PREFIX}/bin

cd ${BUILDROOT}/src

# remove previous installation if it is there:
rm -rf linux
rm -rf linux-r011
rm -rf RFS
rm -rf ssdtv_platform

# unpack, move up one dir and link:

tar -zxvf linux.chelsea.tgz # from 32B650.zip
mv ./linux/* .
rm -rf linux/

ln -s ./linux-r011 linux

cd linux

# copy header files to sysroot:
mkdir -p ${SYSROOT}/usr/include
cp -a ${BUILDROOT}/src/linux/include/linux ${SYSROOT}/usr/include/linux
cp -a ${BUILDROOT}/src/linux/include/asm-arm ${SYSROOT}/usr/include/asm
cp -a ${BUILDROOT}/src/linux/include/asm-generic ${SYSROOT}/usr/include/asm-generic

# remove stale link to ssdtv headers:
rm -rf ${SYSROOT}/usr/include/asm/arch-ssdtv

# ... and copy these as well:
cp -a ${BUILDROOT}/src/ssdtv_platform/include/asm-arm/arch-ssdtv ${SYSROOT}/usr/include/asm

Everything is now installed (but not yet unpacked). The remainder of the installation consists of the actual building of the tools: First the binutils are built: as, ld and a bunch of others. For cross-compilation, these tools do not need any resources for the target platform (ARM, in this case).
====Building of binutils====
Apart from a small bug in one of the source files and a configuration change to be made to part of the code (patches are included) the build is straightforward, done with mkbinutils.sh:
#! /bin/sh

# how to build binutils using this script:
#
# Create the ${BUILDROOT} directory, put this script (mkbinutils.sh) in it.
# In ${BUILDROOT}, create a directory ./src and put the binutils tarball and
# the patch in it.

# go up one directory and run this script.

TARGET=arm-SamyGO-linux-gnueabi
BUILDROOT=/tmp/arm-tools # change to your needs
PREFIX=/usr/local # change to your liking
SYSROOT=${BUILDROOT}/sysroot
UTILS=binutils-2.17.50

export ARCH=arm
export CROSS_COMPILE=${TARGET}-
export PATH=$PATH:${PREFIX}/bin

cd ${BUILDROOT}/src

tar -zxvf binutils-2.17.50.tgz # from 32B650.zip
patch -p0 < ./binutils-2.17.50_fc11.patch

mkdir -p BUILD/${UTILS}
cd BUILD/${UTILS}

../../${UTILS}/configure --prefix=${PREFIX} --target=${TARGET} \
--with-sysroot=${SYSROOT}
make

make install

mkdir -p $PREFIX/$TARGET/include
cp ${BUILDROOT}/src/${UTILS}/include/libiberty.h $PREFIX/$TARGET/include

When all goes well, you will now have the following executables in /usr/local/bin:

arm-SamyGO-linux-gnueabi-addr2line
arm-SamyGO-linux-gnueabi-ar
arm-SamyGO-linux-gnueabi-as
arm-SamyGO-linux-gnueabi-c++filt
arm-SamyGO-linux-gnueabi-gprof
arm-SamyGO-linux-gnueabi-ld
arm-SamyGO-linux-gnueabi-nm
arm-SamyGO-linux-gnueabi-objcopy
arm-SamyGO-linux-gnueabi-objdump
arm-SamyGO-linux-gnueabi-ranlib
arm-SamyGO-linux-gnueabi-readelf
arm-SamyGO-linux-gnueabi-size
arm-SamyGO-linux-gnueabi-strings
arm-SamyGO-linux-gnueabi-strip

====GCC installation, stage 1====
The C-compiler (gcc) has to be built in two stages: First, it is built and linked against the existing C-library (glibc). This version of the compiler is used to build glibc for the target platform, and then gcc is built again, now with the just compiled C-library.

The stage 1 build of gcc renders a barebones gcc, just useful for compiling glibc, as described in the next step: Edit install_gcc_stage1.sh according to your needs and execute. The source code will be patched to prevent building of two runtime objects that cannot be linked yet (because we don't have a working C-library for ARM, yet)
#! /bin/sh

# how to install gcc stage 1 using this script:
#
# Create the ${BUILDROOT} directory, put this script (install_gcc_stage1.sh)
# in it.
# In ${BUILDROOT}, create a directory ./src and put the gcc tarball in it.

# go up one directory and run this script.

TARGET=arm-SamyGO-linux-gnueabi
BUILDROOT=/tmp/arm-tools
PREFIX=/usr/local # change to your liking
SYSROOT=${BUILDROOT}/sysroot
GCC=gcc-4.2.0-4.0.9

export ARCH=arm
export CROSS_COMPILE=${TARGET}-
export PATH=$PATH:${PREFIX}/bin

cd ${BUILDROOT}/src

# unpack

tar -zxvf ${GCC}.tgz # from 32B650.zip

patch -p0 < ./gcc-4.2.0-4.0.9_t-linux-eabi.patch

mkdir -p BUILD/${GCC}-stage1

cd BUILD/${GCC}-stage1
../../${GCC}/configure --prefix=${PREFIX} --target=${TARGET} \
--enable-languages=c --disable-shared --disable-threads \
--disable-libmudflap --disable-libssp --disable-nls \
--disable-libgomp --with-cpu=arm1136jf-s --with-fpu=vfp

make all-gcc
make install-gcc
====Glibc installation====
Build glibc for ARM: Edit the paths in mkglibc.sh (if needed) and execute:

#! /bin/sh

# how to install glibc using this script:
#
# Create the ${BUILDROOT} directory, put this script (mkglibc.sh)
# in it.
# In ${BUILDROOT}, create a directory ./src and put the glibc tarball in it.

# go up one directory and run this script.

TARGET=arm-SamyGO-linux-gnueabi
BUILDROOT=/tmp/arm-tools # change to meet your needs
PREFIX=/usr/local # change to your liking
SYSROOT=${BUILDROOT}/sysroot
GLIBC_VER=glibc-2.5.90-9.0.9

export ARCH=arm
export CROSS_COMPILE=${TARGET}-
export PATH=$PATH:${PREFIX}/bin

cd ${BUILDROOT}/src

# unpack

tar -zxvf ${GLIBC_VER}.tgz # from 32B650.zip

patch -p0 < ./${GLIBC_VER}_fc11.patch

rm -rf ${BUILDROOT}/src/glibc-build-localedef
mv ${BUILDROOT}/src/${GLIBC_VER}/glibc-build-localedef ./

mkdir -p ${BUILDROOT}/src/BUILD/${GLIBC_VER}
cd BUILD/${GLIBC_VER}

# create some cached defaults:
echo "libc_cv_forced_unwind=yes" > config.cache
echo "libc_cv_c_cleanup=yes" >> config.cache

export GCC_PATH=${PREFIX}/bin

BUILD_CC=gcc CC=${GCC_PATH}/${CROSS_COMPILE}gcc ../../${GLIBC_VER}/configure \
--target=${TARGET} --host=${TARGET} --prefix=${PREFIX}/${TARGET} \
--with-__thread \
--cache-file=config.cache --with-headers=${SYSROOT}/usr/include \
--with-glibc=${BUILDROOT}/src/${GLIBC_VER} \
--disable-profile --enable-add-ons
make
make install
====GCC installation, stage 2====
Finally, gcc needs to be rebuilt and linked against the just built glibc for ARM. Now C++-support will be included as well.

Edit install_gcc_stage2.sh and execute. In this script, links to the kernel header files are created in the include/ directory of the toolchain. That's not very elegant. Normally, the C-compiler should try and find the kernel headers in e.g., /usr/src/linux/include, but that's where the native kernel sources for your build platform reside. Your build platform is not necessarily the same as your target platform (most likely not). The method presented here works, but needs some editing in the future.
#! /bin/sh

# how to install gcc stage 2 using this script:
#
# Create the ${BUILDROOT} directory, put this script (install_gcc_stage2.sh)
# in it.
# In ${BUILDROOT}, create a directory ./src and put the gcc tarball in it.

# go up one directory and run this script.

TARGET=arm-SamyGO-linux-gnueabi
BUILDROOT=/tmp/arm-tools
PREFIX=/usr/local # change to your liking
SYSROOT=${BUILDROOT}/sysroot
GCC=gcc-4.2.0-4.0.9

export ARCH=arm
export CROSS_COMPILE=${TARGET}-
export PATH=$PATH:${PREFIX}/bin

cd ${BUILDROOT}/src

# remove links to kernel headers if they exist:
rm -f ${PREFIX}/${TARGET}/include/linux
rm -f ${PREFIX}/${TARGET}/include/asm
rm -f ${PREFIX}/${TARGET}/include/asm-generic

# create symlinks to kernel headers:

ln -s ${SYSROOT}/usr/include/linux ${PREFIX}/${TARGET}/include/linux
ln -s ${SYSROOT}/usr/include/asm ${PREFIX}/${TARGET}/include/asm
ln -s ${SYSROOT}/usr/include/asm-generic ${PREFIX}/${TARGET}/include/asm-generic

# make builddir:

mkdir -p BUILD/${GCC}-stage2

cd BUILD/${GCC}-stage2

CC=gcc ../../${GCC}/configure --target=${TARGET} --prefix=${PREFIX} \
--enable-languages=c,c++ --enable-threads --enable-shared \
--disable-nls --enable- __cxa_atexit --enable-long-long \
--enable-c99 --with-cpu=arm1136jf-s --with-fpu=vfp

make
make install

When you look in /usr/local/bin now, you should see the cross-compilers for C and C++ for arm-SamyGO-linux-gnueabi.

===Building the toolchain on Windows (Cygwin)===
The toolchain build on Windows/Cygwin proceeds in the same way as the build on Linux. If you have the choice between Windows and Linux, go for Linux. Shell script execution is orders of magnitude faster on Linux, and the installation procedure is carried out through _many_ shell scripts. Don't say that you haven't been warned. To be able to build the toolchain you need to have Cygwin installed, see the Cygwin website [http://www.cygwin.com] for details on installation. At the time of writing, the Cygwin stable release version was 1.5.25-15, and that is the version used for the build here, on Windows XP Home Edition. Cygwin creates a Unix-style environment on the Windows platform, and comes with pretty much the same development environment as GNU/Linux. You will need this GNU/Linux-style environment to be able to build your toolchain. The native Windows environment (visual studio and the likes) will NOT work.
====Cygwin installation notes====
When installing Cygwin, select "Unix-style linefeeds" (the default) when prompted. Otherwise you will find yourself editing ALL installation scripts, not just the handful presented here.
Apart from the default (minimal) installation, which you shouldn't touch, you should have at least the following packages installed:

(Untick the "Hide obsolete packages" box in the "Select Packages" installer window to view everything, the packages in the following list may have been selected already for default installation)

*autoconf
*automake
*bash
*binutils
*bison
*byacc
*bzip2
*diffutils
*flex
*gawk
*gcc
*gcc-core
*gcc-g++
*gcc4
*gcc4-core
*gcc4-g++
*gettext
*gzip
*libgcc1
*libiconv
*m4
*make
*patch
*patchutils
*texinfo
*unzip
*zip
It is not clear whether you actually need all of these, but most packages take little disk space and little time to install. Running into errors because of lacking packages will take more time.

With Cygwin properly installed, the same 6 steps as described in the Linux installation section need to be taken.
Download the SamyGO patches and scripts [http://forum.samygo.tv/download/file.php?id=14] and edit these.
====Editing of installation scripts====
In the following, only differences with respect to the Linux installation will be described. Start Cygwin by double-clicking on its Desktop icon.
You will get a window in which the standard Cygwin shell runs (ash, if I'm not mistaken).
At the prompt, type the following command to make the BUILDROOT directory (take your pick with respect to the name, this is what I've been using):
mkdir -p ./tmp/arm-tools
Copy the Samsung sources (32B650.zip) and the SamyGO patches and scripts to this directory. Windows explorer will do. Unpack the patches:
cd ./tmp/arm-tools
tar -zxvf SamyGO-toolchain-install_fc11.tgz
Edit the environment variable BUILDROOT in the installation scripts (all just installed files that end with .sh).
By default, Cygwin is installed in C:/cygwin. All paths used in Cygwin are relative to this installation path, but for some reason the BUILDROOT environment variable needs to point to the full path. Edit the line BUILDROOT in all installation scripts to make it point to the full path of your build (be sure to use the forward slashes!!):
...
BUILDROOT=c:/cygwin/home/username/tmp/arm-tools # edit according to your needs.
...
When using notepad.exe or another DOS-style editor, revert the scripts, after saving, to unix-style linefeeds with the command:
dos2unix ./install_sources.sh
Do this for all scripts you edit, BEFORE execution. Failing to do so may render errors like:
$'\r': command not found
This error type occurs when shell scripts with DOS rather than Unix-style linefeeds are being processed.
====Installation of the sources and kernel headers====
Execute ./install_sources.sh and ./install_kernel_src.sh after one another by typing their names with a leading ./ and their extension .sh. Unlike Windows, Unix does not guess filename extensions. They are considered to be part of the filename, nothing else. This step installs the sources and kernel headers in the right place.
====Building of binutils and gcc, stage 1====
Edit ./mkbinutils.sh and ./install_gcc_stage1.sh. In both scripts, add a line to make the environment variable CC point to gcc-4:
...
export ARCH=arm
export CROSS_COMPILE=${TARGET}-
export PATH=$PATH:${PREFIX}/bin
export CC=/usr/bin/gcc-4
...

and build the binutils with ./mkbinutils.sh.
After successful completion, build gcc stage 1 with ./install_gcc_stage1.sh.

To be continued soon ...