Re. Building a totally new smart phone

Michael Spacefalcon msokolov at ivan.Harhan.ORG
Sat Aug 24 05:48:30 CEST 2013

Adam Bogacki <adam.bogacki at> wrote:

> Now that I have dir 'freecalypso-sw-SE52Fru5' I am not quite sure what
> to do.
> Is there some documentation available, or a man page ?

No documentation has been written yet, because there is nothing to
document yet: all that's there is a FreeNucleus RTOS skeleton and some
host tools for pushing code images to the Calypso.  See my earlier
posts in this thread for my planned roadmap of adding "meat" to this

The FreeCalypso project is still in a very early stage - most projects
aren't even announced at all when they are this early in the development
process.  The only reason why I'm releasing this code at all is to
satisfy the moral requirement: on my planet it is a crime to have some
ware and not share it, no matter what the ware is.

If you want to play with the current code just for fun (there isn't
anything more that you would be able to do with it), you should be able
to at least compile it, and if you have one of the two supported phone
models (DP-L10 or GTA02), even run it and see the serial output from
the FreeNucleus demo app.  The steps are:

1. Build and install the arm-elf cross-compile toolchain.  Look in the
   toolchain directory and it should be obvious.

2. Using that toolchain, compile the target-utils part.  (Just run make
   in the target-utils subdir with the toolchain in your PATH.)
   You'll get the loadagent.srec image.

3. Compile loadtools - again, just run make in the corresponding
   directory.  These are host tools, so they need to run on whatever
   Unix/Linux machine you'll be using to push code to the Calypso.  If
   you are doing this with a Pirelli phone, FreeCalypso loadtools need
   to run on your PC/desktop/laptop.  If you are playing with a GTA02
   instead, you will need to either make a special cable to get to the
   Calypso via the headphone jack, or build loadtools to run on the
   GTA02 AP.

4. Once you've got loadtools, loadagent.srec and a compatible Calypso
   phone, you can actually try running this stuff.  If you have
   successfully passed steps 1 through 3, but are having difficulties
   with this step, ask and I'll help you.  If you are still struggling
   with one of the previous steps, work on that first.

A command like this (from a laptop with a Pirelli DP-L10 phone
connected and showing up as /dev/ttyUSB0):

fc-loadtool -h pirelli /dev/ttyUSB0

or like this (from the GTA02 AP, talking to the Calypso part of the
same phone):

fc-loadtool -h gta02 /dev/ttySAC0

should produce output that looks like this:

Sending beacons to /dev/ttyUSB0
Got beacon response, attempting download
<p command successful, switching to 115200 baud
Sending image payload
[a long line of dots]Sending checksum
<c command successful, sending <b
<b command successful: downloaded image should now be running!

FreeCalypso loadagent running
Loaded via UART 1 (IrDA) at baud rate #0
TCXO clock input autodetected to be 26 MHz

Executing init script pirelli.init
Script command: w16 fffffb00 00A4
Script command: w16 fffffb02 00A4
Script command: w16 fffffb06 00A4
Script command: w16 fffef006 0008

The 3 lines beginning with "FreeCalypso loadagent running" will be
printed by code running on the Calypso chip itself, which you would
have built in step 2.  Once you are at the loadtool prompt, you are
interacting with the host utility you would have built in step 3,
which is in turn communicating over a serial channel with loadagent.srec
running on the Calypso.  Loadtool has commands for things like peeking
and poking registers, dumping and programming flash, etc.  But right
now the only documentation is the source code.  Type exit, quit or ^D
when you are done - it'll reboot the Pirelli phone or power off the
GTA02 GSM modem.

5. The Nucleus-based skeleton for what is meant to become the main GSM
   firmware lives in the nuc-fw directory.  You can build it as soon as
   you've got the arm-elf toolchain from step 1.  Unlike loadagent,
   which is meant to remain "universal" for all Calypso phones (just
   like TI's FLUID), the main firmware obviously has to be configured
   for a specific target.  The snapshot you are looking at has the
   beginnings of the configuration mechanism, but the latter doesn't
   do anything yet.  For now all that's there is the Nucleus demo, and
   it happens to be the same for all phones, so just type make in the
   nuc-fw directory with the toolchain from step 1 in your PATH.
   You'll get ramImage.srec, which you can run on your Calypso phone
   with the fc-xram utility:

fc-xram -h pirelli /dev/ttyUSB0 ramImage.srec

If you are doing this with a Pirelli DP-L10, you should see the output
from the demo app pouring on your terminal when you run the above
command.  Type ^\ to kill the fc-xram process on your host, but to stop
the demo app running on the phone and make the phone usable again,
you'll have to pull the battery and put it back in.  (And then reset
the clock, as this phone doesn't have a separate RTC backup battery.)

If you are playing with a GTA02 instead, you can run the same
ramImage.srec image, and you can push it with the same fc-xram command
either from inside the phone (from the AP) or from an external host
via that special headphone jack cable, but the demo app's output will
always go to the IrDA UART (unless you change the code in demo.c), so
you won't see anything unless you have that special serial cable.

That's all that one can do with freecalypso-sw for now.  My planned
next step is to attempt porting TI's Calypso BSP code from the MV100
find.  And before someone says that OsmocomBB already does so much
more - I don't really care.  To me this isn't a race, it's about
building something that I will actually be able to use as my everyday
phone.  Because I won't use OsmocomBB for moral reasons, my only
remaining option is to lead my own semi-competing project instead -
which is what I'm doing.  OsmocomBB got a head start on FreeCalypso by
a few years, so it isn't surprising at all that they are ahead
currently.  But it doesn't really matter.  Given how little interest
the OsmocomBB gang is showing in working toward an actual usable
phone, rather than a GSM hacking or security research instrument, I
venture a guess that despite being disadvantaged in every way,
FreeCalypso will quite likely still produce a usable phone fw before
OsmocomBB does.  But if I'm wrong and the OsmocomBB folks do produce a
usable phone fw before I do, great, more power to them.


More information about the community mailing list