local: Read from CAL also overwritten hw revision

Format of arguments for adding piece to fiasco image is now:
$ 0xFFFF -p [[[[dev:hw:]ver:]type:]file[%%layout]

0xFFFF.desktop

@@ -0,0 +1,9 @@
+[Desktop Entry]
+Encoding=UTF-8
+Name=0xFFFF
+Comment=Free flasher for the Nokia internet tablets
+Exec=gnome-terminal -e goxf
+Icon=gnome-terminal.png
+Terminal=false
+Type=Application
+Categories=GTK;Application;Utility;

Makefile

@@ -1,11 +1,17 @@
+include config.mk
 PREFIX?=/usr/local
+DESTDIR?=
 
-all: logot
+all: logot frontend
 	cd src && ${MAKE} all
 
+frontend:
+	-cd src/gui && ${MAKE} all
+
 static: logot
 	cd libusb && ${MAKE} all
 	cd src && ${MAKE} static
+	cd logotool && ${MAKE} static
 
 allusb: logot
 	cd libusb && ${MAKE} all
@@ -16,12 +22,21 @@ logot:
 
 clean:
 	cd src && ${MAKE} clean
+	cd libusb && ${MAKE} clean
 	cd logotool && ${MAKE} clean
 
 install:
-	cp src/0xFFFF ${PREFIX}/bin
-	cp logotool/logotool ${PREFIX}/bin
+	mkdir -p ${DESTDIR}${PREFIX}/bin
+	mkdir -p ${DESTDIR}${PREFIX}/share/applications/
+	cp src/0xFFFF ${DESTDIR}${PREFIX}/bin
+	-cp src/gui/goxf ${DESTDIR}${PREFIX}/bin
+	cp logotool/logotool ${DESTDIR}${PREFIX}/bin
+	cp 0xFFFF.desktop ${DESTDIR}${PREFIX}/share/applications/
+	mkdir -p ${DESTDIR}${PREFIX}/share/man/man1
+	cp man/*.1 ${DESTDIR}${PREFIX}/share/man/man1
 
 deinstall:
-	rm -f ${PREFIX}/bin/0xFFFF
-	rm -f ${PREFIX}/bin/logotool
+	rm -f ${DESTDIR}${PREFIX}/bin/0xFFFF
+	rm -f ${DESTDIR}${PREFIX}/bin/logotool
+	rm -f ${DESTDIR}${PREFIX}/bin/goxf
+	rm ${DESTDIR}${PREFIX}/share/applications/0xFFFF.desktop

README

@@ -27,8 +27,15 @@ Feel free to join to the mailing list and visit the homepage for more info:
   0xffff@lists.nopcode.org
   http://www.nopcode.org/0xFFFF
 
+-----------8<---------------------------------------------------------------
+
+Build:
+ $ make
+
+To install: (by default is /usr/local)
+ $ make install PREFIX=/usr DESTDIR=/
+
+
 
 Have phun!
-
-
                                                          --pancake

config.mk

@@ -0,0 +1,6 @@
+VERSION = 0.6
+PREFIX = /usr/local
+
+# NetBSD stuff
+#CFLAGS += -I/usr/pkg/include -g -O2
+#LDFLAGS += -L/usr/pkg/lib -Wl,-R/usr/pkg/lib

doc/bug-report

@@ -40,14 +40,14 @@ and sometimes (in the early days often) replacing proprietary software.
 
 The non-free bits in the core infrastructure of the IT OS 2007 are a road block
 for efforts to create free operating systems/distributions besides IT OS on the
-N770/N800.
+770/N800.
 
 The reason for why it is helpful to have other operating system/distribution on
 the N800 is simple: There are hundreds of GNU/Linux distributions out there.
 Each one exists because there is a userbase that exactly likes their flavor of
 GNU/Linux.
 
-For the N770/N800 Internet Tablets there exists only one such distribution: The
+For the 770/N800 Internet Tablets there exists only one such distribution: The
 Internet Tablet OS. With the sheer amount of GNU/Linux distributions for
 desktops/workstations/servers/routers/PDAs on the one hand and the single OS
 solution for the Internet Tablets on the other I doubt that it can handle all

doc/faq

@@ -1,79 +1,49 @@
-<b>FAQ</b>
+<h2>FAQ</h2>
 
-This file tries to collect a bunch of common questions/answers about flashing
+<b>*) How can I set my Internet Tablet into RD mode with 0xFFFF?</b>
 
-<b>*) Why implement a free software flasher?</b>
-
-  The Nokia Internet Tablets are based on Free Software (software libre), but
-  not everything included *is* free software, for instance, the firmware flasher
-  tool.
-
-  The 0xFFFF project aims to feed the minds of those who really want to
-  understand how these gadgets work internally, free the knowledge to
-  avoid the restrictions and fill the lack of information on the most
-  important part of the system.
-
-  That's it, now you can build and run this flasher on *BSD, w32, MacOSX on ARM,
-  powerpc, x86, mips, etc...
+  Just type '0xFFFF -r 1' as root
 
 
-<b>*) Can I brick my device?</b>
+<b>*) How can I unpack a FIASCO firmware?
 
-  Of course! You're free to do what you want with your device :)
-
-  Seriously. Flashing a device is not a safe thing, so I give no warranty
-  of what will happen to your device when using this tool.
-
-  BTW, after a huge number of tests I can say that these devices are hard
-  to brick, but if you are scared about bricking your device you should
-  use the flasher provided by Nokia, it's better for your heart's health.
+  Just type '0xFFFF -r 1' as root
 
 
-<b>*) What can I do with 0xFFFF?</b>
+<b>*) How can I unpack a FIASCO firmware?</b>
 
-  Actually 0xFFFF allows you to:
-  
-  - flash separated pieces of the firmware.
-  - retrieve information about the device
-  - reboot de mother board
-  - extract the current firmware pieces from the device (reverse flash)
-  - set the USB host/slave mode
-  - set the R&R mode
-  - identify firmware pieces
+  Just type '0xFFFF -u FiascoFirmware.bin -e /tmp' as root
 
 
-<b>*) What is NOLO?</b>
+<b>*) How can I flash a new rootfs?
 
-  NOLO is the 'server-side' part of the flasher from Nokia. NOLO means
-  NOkia LOader and it's composed by two pieces of the firmware that are
-  flashed together.
+  Unpack the pieces from the fiasco firmware (the one distributed by Nokia for example) and then type:
 
-  On the n800 firmwares, these two pieces are distributed in a single
-  file, but when flashing a n770, NOLO requires to provide the xloader
-  (without commiting) and then the secondary piece.
-
-  This piece of software is closed source and is the responsable of
-  handling the requests from the client-side flasher. It provides a
-  query-like interface via usb control messages for doing different
-  actions on the device.
+  # 0xFFFF -R -p rootfs.jffs 
 
 
-<b>*) How can I identify my device?</b>
+<b>*) How can I flash a full FIASCO image?</b>
 
-  Theorically n770 and n800 have different USB device ID, but this is not
-  true at all. The first series of the n800 comes with the same usb-id 
-  than n770. That's weird!
+  It is not recommended to use, it needs more testing, and is more secure to unpack them first manually
+  and flash the pieces manually with multiple '-p' flags. If you are brave try:
 
-  So, the only way to identify the device is by asking nolo for the version
-  information of different pieces of the firmware. This can be faked, because
-  you can flash n770 stuff on n800 and viceversa, but it's not recommended
-  because it wouldn't work :)
+  # 0xFFFF -F FiascoFirmware.fiasco
 
 
-<b>*) Can I unpack fiasco blobs?</b>
+<h2>Advanced commands</h2>
 
-  Actually the fiasco format is not yet supported and not planned in
-  short term. There is no real need for supporting a proprietary
-  format image containing a proprietary system.
+<b>*) How to extract the firmware pieces from a running device?</b>
 
-  We can just use tarballs containing the desired pieces.
+  It is possible to dump the firmware pieces from the internal MTD to reconstruct a FIASCO image.
+  To do this recompile the flasher for ARM and run this command in the device:
+
+  # mkdir /media/mmc1/backup
+  # 0xFFFF -e /media/mmc1/backup
+
+
+<b>*) Dumping configuration region</b>
+
+  There's a hidden mtd partition containing undocumented configuration information. This one can be
+  dumped from the device using the following command:
+
+  # 0xFFFF -x

doc/faq2

@@ -0,0 +1,80 @@
+<b>FAQ</b>
+
+This file tries to collect a bunch of common questions/answers about flashing
+
+
+<b>*) Why implement a free software flasher?</b>
+
+  The Nokia Internet Tablets are based on Free Software (software libre), but
+  not everything included *is* free software, for instance, the firmware flasher
+  tool.
+
+  The 0xFFFF project aims to feed the minds of those who really want to
+  understand how these gadgets work internally, free the knowledge to
+  avoid the restrictions and fill the lack of information on the most
+  important part of the system.
+
+  That's it, now you can build and run this flasher on *BSD, w32, MacOSX on ARM,
+  powerpc, x86, mips, etc...
+
+
+<b>*) Can I brick my device?</b>
+
+  Of course! You're free to do what you want with your device :)
+
+  Seriously. Flashing a device is not a safe thing, so I give no warranty
+  of what will happen to your device when using this tool.
+
+  BTW, after a huge number of tests I can say that these devices are hard
+  to brick, but if you are scared about bricking your device you should
+  use the flasher provided by Nokia, it's better for your heart's health.
+
+
+<b>*) What can I do with 0xFFFF?</b>
+
+  Actually 0xFFFF allows you to:
+  
+  - flash separated pieces of the firmware.
+  - retrieve information about the device
+  - reboot de mother board
+  - extract the current firmware pieces from the device (reverse flash)
+  - set the USB host/slave mode
+  - set the R&R mode
+  - identify firmware pieces
+
+
+<b>*) What is NOLO?</b>
+
+  NOLO is the 'server-side' part of the flasher from Nokia. NOLO means
+  NOkia LOader and it's composed by two pieces of the firmware that are
+  flashed together.
+
+  On the n800 firmwares, these two pieces are distributed in a single
+  file, but when flashing a 770, NOLO requires to provide the xloader
+  (without commiting) and then the secondary piece.
+
+  This piece of software is closed source and is the responsable of
+  handling the requests from the client-side flasher. It provides a
+  query-like interface via usb control messages for doing different
+  actions on the device.
+
+
+<b>*) How can I identify my device?</b>
+
+  Theorically 770 and n800 have different USB device ID, but this is not
+  true at all. The first series of the n800 comes with the same usb-id 
+  than 770. That's weird!
+
+  So, the only way to identify the device is by asking nolo for the version
+  information of different pieces of the firmware. This can be faked, because
+  you can flash 770 stuff on n800 and viceversa, but it's not recommended
+  because it wouldn't work :)
+
+
+<b>*) Can I unpack fiasco blobs?</b>
+
+  Actually the fiasco format is not yet supported and not planned in
+  short term. There is no real need for supporting a proprietary
+  format image containing a proprietary system.
+
+  We can just use tarballs containing the desired pieces.

doc/fiasco

@@ -1,30 +1,57 @@
-SPECS FOR TEH FIASCO FIRMWARE FILE FORMAT ffff!
+ Copyright (C) 2007-2011  pancake <pancake@youterm.com>
+ Copyright (C) 2011-2012  Pali Rohár <pali.rohar@gmail.com>
+
+SPECS FOR THE FIASCO FIRMWARE FILE FORMAT ffff!
 -----------------------------------------------
 
-  These notes has not been taken properly and may be wrong. It must
-  be revised to fit the reality. But this is mostly a general idea:
+  This is final working version of FIASCO format. FIASCO image which
+  is generated by this spec is acceptable by Nokia flasher-3.5 and
+  unpack data same as FIASO image generated by Nokia fiasco-gen. This
+  format is implemented in 0xFFFF and every image which I tested
+  (generated by 0xFFFF and fiasco-gen) was properly unpacked under
+  0xFFFF and flasher-3.5 with same result. Small difference is that
+  fiasco-gen add some unknown subsection block to image header
+  (type '4' or '/') which contains some messy characters... But if
+  these sections missing, flasher-3.5 working fine too. And old FIASCO
+  images (for N8x0) does not have these subsectin...
 
 
 FILE HEADER
 
    1 byte = 0xb4    --  signature
-   4 bytes          --  firmware name length (big endian)
-   6 bytes          --  versioning info ( byte 4 is format version )
-   N-6 bytes        --  firmware name (zero fill)
+   4 bytes          --  FW header length (big endian)
 
 
-PIECE HEADER
+FW HEADER
 
-   1 byte = 0x54    --  piece signature
-   6 bytes          --  unknown
-   2 bytes          --  checksum for the piece contents (xorpair)
-  12 bytes          --  piece name (first byte is FF if is the last)
-   4 bytes          --  piece size (big endian)
-   4 bytes          --  unknown
+   4 bytes          --  number of FW header blocks (big endian)
              block {
-   1 byte           --  if (value '1'-'9') { ..there's a comment.. }
-   1 byte           --  length of comment
-   N bytes          --  comment
+   1 byte           --  type of block
+                          0xE8 - Fiasco name
+                          0x31 - FW name
+   1 byte           --  length of block data
+   N bytes          --  block data
              }
-   N bytes          -- piece data
 
+
+IMAGE
+
+   1 byte = 0x54    --  signature
+   1 byte           --  number of subsection blocks + 1
+   5 bytes          --  unknown (always 0x2e 0x19 0x01 0x01 0x00)
+   2 bytes          --  checksum for the image contents (xorpair) (big endian)
+  12 bytes          --  image name type (first byte is FF if is the last image)
+   4 bytes          --  length of image data (big endian)
+   4 bytes          --  unknown (always 0x00 0x00 0x00 0x00)
+             block {
+   1 byte           --  type of subsection block
+                          '1' - version
+                          '2' - device & hw revisions (size of device is 16, hw revision 8)
+                          '3' - layout
+                          '4' - unknown
+                          '/' - unknown
+   1 byte           --  length of subsection block
+   N bytes          --  subsection block data
+             }
+   1 byte           --  unknown (0x00 is accepted, maybe end of subsections?)
+   N bytes          --  image data

doc/local-flash

@@ -21,4 +21,4 @@ have flashed properly every piece inside the device, but keep in mind
 that it is dangerous and you can brick your device.
 
 But feel free to send feedback to provide a full support for local
-flashing on n770 and n800.
+flashing on 770 and n800.

doc/mkii

@@ -0,0 +1,90 @@
+ Copyright (C) 2012  Pali Rohár <pali.rohar@gmail.com>
+
+Mk II protocol is the only protocol which can be used to flash eMMC images.
+NOLO does not support eMMC, so flashing eMMC is done in Maemo system. NOLO
+will boot device into "update" mode and Maemo will start only softupd daemon
+(which is responsible for flashing from Maemo system) and load kernel driver
+g_softupd which handle USB communication to user space daemon. When device
+is in PC Suite mode Maemo system start softupd daemon and load kernel driver
+g_nokia which can also handle communication via Mk II protocol.
+
+Default Maemo flasher (v2.5.2 (Oct 21 2009)) support only some basic functions
+via Mk II protocol - it can send eMMC image to softupd server which flash it.
+But there is unofficial Maemo flasher (flasher v2.8.2 (Jan  8 2010)) distributed
+with omap aes kernel driver for Nokia RX-51 under name "flasher.rover" which
+support more functions. So "flasher.rover" is better for RE this protocol.
+
+Via Mk II protocol over usb with softupd daemon in device it is possible to
+flash any type of image except rootfs (xloader, secondary, kernel, mmc,
+cmt-2nd, cmt-algo, cmt-mcusw). Maemo system using same Mk II protocol over
+local TCP socket (server also provided by softupd) to update/flash system.
+
+Over usb are used only these functions for communication:
+
+ usb_claim_interface (interface=1)
+ usb_set_altinterface (alternate=1)
+
+ usb_bulk_write (ep=1, timeout=5000)
+ usb_bulk_read (ep=129, timeout=5000)
+
+For every (request) message which is send by host, server send back responce.
+Format of message every message is same. It has 6 bytes header and (at least)
+4 bytes body.
+
+HEADER
+
+   4 bytes          --  type of header
+                          0x8810001B - out (sent by host: usb_bulk_write)
+                          0x8800101B - in (received by host: usb_bulk_read)
+   2 bytes          --  size of body (big endian)
+
+BODY
+
+   4 bytes          --  type of message
+   N bytes          --  data
+
+Reply message data always starts with char 0x00 (except pong responce).
+
+Here are some sniffed messages from Nokia RX-51. First two messages seems to
+must be always protocol version exchange (first host ask for protocol version of
+server and then host send its protocol version). On RX-51 is used version "2".
+
+ Ping:
+   req_type = 0x00000000
+   res_type = 0x20000000
+
+ Get protocol version:
+   req_type = 0x01010000
+   req_data = "/update/protocol_version"
+   res_type = 0x21010000
+   res_data = 0x00 "2"
+
+ Tell our protocol version:
+   req_type = 0x02020000
+   req_data = "/update/host_protocol_version" 0x00 "2"
+   res_type = 0x22020000
+   res_data = 0x00
+
+ Get device:
+   req_type = 0x01030000
+   req_data = "/device/product_code"
+   res_type = 0x21030000
+   res_data = 0x00 "RX-51"
+
+ Get hwrev:
+   req_type = 0x01040000
+   req_data = "/device/hw_build"
+   res_type = 0x21040000
+   res_data = 0x00 "2101"
+
+ Get image types:
+   req_type = 0x01050000
+   req_data = "/update/supported_images"
+   res_type = 0x21050000
+   res_data = 0x00 "xloader,secondary,kernel,mmc,cmt-2nd,cmt-algo,cmt-mcusw"
+
+ Reboot device:
+   req_type = 0x0C060000
+   req_data = "reboot"
+   res_type = 0x2C060000
+   res_data = 0x00

doc/pieces

@@ -37,7 +37,7 @@ Pieces can be automatically identified by using the '-I' flag:
 You can dump these pieces from the internal memory of the internet
 tablet by using the mtd-utils over /dev/mtd* or just running:
 
-  n770$ 0xFFFF -e /media/mmc1
+  770$ 0xFFFF -e /media/mmc1
 
 There is another way for dumping pieces with extra parameters and options,
 read doc/dumping for more information.

doc/usage

@@ -1,7 +1,7 @@
 <b>Usage guide</b>
 
 0xFFFF is a free software implementation of the flasher for the Nokia Internet
-Tablets (n770 and n800).
+Tablets (770 and n800).
  <pre>
   - flash separated pieces of the firmware.
   - retrieve information about the device

gui/DESCR

@@ -1,53 +0,0 @@
-- preferences
-
- * choose flasher type.
-
-    by default 0xFFFF is used
-
- *
-
-piece [file]
- |
- +-- radio
- |
- +-- nbh
-
-info
- |
- +-- -i
-
-reboot
- |
- +-- ???
-
-----------
-
-piece [file]
- |
- +-- xloader
- |
- +-- secondary
- |
- +-- kernel
- |
- +-- initfs
- |
- +-- rootfs
- |
- +-- autodetected
-
-info
- |
- +-- -i
-
-usb-host-mode
- |
- +-- -U [0|1]
-
-rd-mode
- |
- +-- -r 0|1
-
-reboot
- |
- +-- -R

gui/Makefile

@@ -1,8 +0,0 @@
-OBJ=main.o
-BIN=goxf
-
-CFLAGS=`pkg-config libgladeui-1.0 libglade-2.0 --cflags`
-LDFLAGS=`pkg-config libgladeui-1.0 libglade-2.0 --libs`
-
-all: ${OBJ}
-	${CC} ${LDFLAGS} ${OBJ} -o ${BIN}

gui/g0xFFFF.glade

@@ -1,223 +0,0 @@
-<?xml version="1.0" encoding="UTF-8" standalone="no"?>
-<!DOCTYPE glade-interface SYSTEM "glade-2.0.dtd">
-<!--*- mode: xml -*-->
-<glade-interface>
-  <widget class="GtkWindow" id="main_window">
-    <property name="border_width">5</property>
-    <property name="title" translatable="yes" context="yes">g0xFFFF</property>
-    <property name="default_width">501</property>
-    <property name="default_height">329</property>
-    <property name="icon_name">gtk-connect</property>
-    <signal name="destroy_event" handler="gtk_main_quit" object="0"/>
-    <child>
-      <widget class="GtkVBox" id="vbox1">
-        <property name="visible">True</property>
-        <property name="spacing">3</property>
-        <child>
-          <widget class="GtkHButtonBox" id="hbuttonbox2">
-            <property name="visible">True</property>
-            <property name="layout_style">GTK_BUTTONBOX_START</property>
-            <child>
-              <widget class="GtkComboBox" id="combobox2">
-                <property name="visible">True</property>
-                <property name="active">0</property>
-                <property name="items" translatable="yes" context="yes">n770/n800
-HERMflasher</property>
-              </widget>
-              <packing>
-                <property name="expand">False</property>
-                <property name="fill">False</property>
-              </packing>
-            </child>
-            <child>
-              <widget class="GtkButton" id="gochange">
-                <property name="width_request">32</property>
-                <property name="visible">True</property>
-                <property name="has_default">True</property>
-                <property name="label" translatable="yes" context="yes">&gt;</property>
-              </widget>
-              <packing>
-                <property name="expand">False</property>
-                <property name="fill">False</property>
-                <property name="position">1</property>
-              </packing>
-            </child>
-          </widget>
-          <packing>
-            <property name="expand">False</property>
-            <property name="fill">False</property>
-          </packing>
-        </child>
-        <child>
-          <widget class="GtkHBox" id="hbox1">
-            <property name="visible">True</property>
-            <property name="spacing">6</property>
-            <child>
-              <widget class="GtkScrolledWindow" id="scrolledwindow1">
-                <property name="visible">True</property>
-                <property name="hscrollbar_policy">GTK_POLICY_AUTOMATIC</property>
-                <property name="vscrollbar_policy">GTK_POLICY_AUTOMATIC</property>
-                <child>
-                  <widget class="GtkTreeView" id="treeview1">
-                    <property name="visible">True</property>
-                  </widget>
-                </child>
-              </widget>
-            </child>
-            <child>
-              <widget class="GtkVBox" id="vbox2">
-                <property name="visible">True</property>
-                <property name="border_width">3</property>
-                <property name="spacing">2</property>
-                <child>
-                  <widget class="GtkFileChooserButton" id="filechooserbutton2">
-                  </widget>
-                  <packing>
-                    <property name="expand">False</property>
-                  </packing>
-                </child>
-                <child>
-                  <widget class="GtkComboBox" id="combo1">
-                    <property name="row_span_column">0</property>
-                    <property name="column_span_column">0</property>
-                    <property name="active">0</property>
-                    <property name="tearoff_title">patata</property>
-                    <property name="items" translatable="yes" context="yes">rootfs
-initfs
-kernel
-secondary
-xloader</property>
-                  </widget>
-                  <packing>
-                    <property name="expand">False</property>
-                    <property name="position">1</property>
-                  </packing>
-                </child>
-                <child>
-                  <widget class="GtkHBox" id="hbox4">
-                    <property name="visible">True</property>
-                    <child>
-                      <widget class="GtkButton" id="button2">
-                        <property name="visible">True</property>
-                        <property name="label" context="yes">Remove</property>
-                      </widget>
-                    </child>
-                    <child>
-                      <widget class="GtkButton" id="add">
-                        <property name="visible">True</property>
-                        <property name="label" context="yes">Add</property>
-                      </widget>
-                      <packing>
-                        <property name="position">1</property>
-                      </packing>
-                    </child>
-                  </widget>
-                  <packing>
-                    <property name="expand">False</property>
-                    <property name="position">2</property>
-                  </packing>
-                </child>
-                <child>
-                  <widget class="GtkCheckButton" id="checkbutton2">
-                    <property name="visible">True</property>
-                    <property name="label" translatable="yes" context="yes">USB host mode</property>
-                    <property name="draw_indicator">True</property>
-                  </widget>
-                  <packing>
-                    <property name="expand">False</property>
-                    <property name="fill">False</property>
-                    <property name="position">3</property>
-                  </packing>
-                </child>
-                <child>
-                  <widget class="GtkCheckButton" id="checkbutton3">
-                    <property name="visible">True</property>
-                    <property name="label" translatable="yes" context="yes">R&amp;D mode</property>
-                    <property name="draw_indicator">True</property>
-                  </widget>
-                  <packing>
-                    <property name="expand">False</property>
-                    <property name="fill">False</property>
-                    <property name="position">4</property>
-                  </packing>
-                </child>
-                <child>
-                  <widget class="GtkCheckButton" id="reboot">
-                    <property name="visible">True</property>
-                    <property name="label" translatable="yes" context="yes">Reboot</property>
-                    <property name="draw_indicator">True</property>
-                  </widget>
-                  <packing>
-                    <property name="expand">False</property>
-                    <property name="fill">False</property>
-                    <property name="position">5</property>
-                  </packing>
-                </child>
-              </widget>
-              <packing>
-                <property name="expand">False</property>
-                <property name="pack_type">GTK_PACK_END</property>
-                <property name="position">1</property>
-              </packing>
-            </child>
-          </widget>
-          <packing>
-            <property name="padding">3</property>
-            <property name="position">1</property>
-          </packing>
-        </child>
-        <child>
-          <widget class="GtkHBox" id="hbox3">
-            <property name="visible">True</property>
-            <property name="spacing">6</property>
-            <child>
-              <widget class="GtkProgressBar" id="progressbar1">
-                <property name="visible">True</property>
-                <property name="show_text">True</property>
-              </widget>
-            </child>
-            <child>
-              <widget class="GtkHBox" id="hbox5">
-                <property name="visible">True</property>
-                <child>
-                  <widget class="GtkButton" id="info">
-                    <property name="visible">True</property>
-                    <property name="label" translatable="yes" context="yes">gtk-dialog-info</property>
-                    <property name="use_stock">True</property>
-                  </widget>
-                  <packing>
-                    <property name="expand">False</property>
-                    <property name="fill">False</property>
-                  </packing>
-                </child>
-                <child>
-                  <widget class="GtkButton" id="but_commit">
-                    <property name="visible">True</property>
-                    <property name="label" translatable="yes" context="yes">gtk-execute</property>
-                    <property name="use_stock">True</property>
-                  </widget>
-                  <packing>
-                    <property name="expand">False</property>
-                    <property name="fill">False</property>
-                    <property name="position">1</property>
-                  </packing>
-                </child>
-              </widget>
-              <packing>
-                <property name="expand">False</property>
-                <property name="fill">False</property>
-                <property name="pack_type">GTK_PACK_END</property>
-                <property name="position">1</property>
-              </packing>
-            </child>
-          </widget>
-          <packing>
-            <property name="expand">False</property>
-            <property name="fill">False</property>
-            <property name="position">2</property>
-          </packing>
-        </child>
-      </widget>
-    </child>
-  </widget>
-</glade-interface>

logotool/Makefile

@@ -1,8 +1,14 @@
 OBJ=logotool.o compress.o uncompress.o rgb2yuv.o
-CFLAGS=-Wall -g
+#CFLAGS=-Wall -g
+BIN=logotool
 
-all: ${OBJ}
+all: ${BIN}
+
+${BIN}: ${OBJ}
 	${CC} ${OBJ} -o logotool
 
+static: ${BIN}
+	${CC} -static ${OBJ} -o logotool
+
 clean:
 	rm -f ${OBJ} logotool

logotool/uncompress.c

@@ -71,7 +71,7 @@ int uncompress_image(char *srcf, char *dstf)
 	src = malloc ( fsize );
 	dst = malloc ( width*height*2 );
 	deof = dst+width*height*2;
-	if ((int)src == -1 || (int)dst == -1 ) {
+	if (src == (void *)-1 || dst == (void *)-1 ) {
 		printf("Cannot malloc\n");
 		return 1;
 	}
@@ -105,7 +105,7 @@ int uncompress_image(char *srcf, char *dstf)
 			}
 		}
 	}
-	fprintf(stderr, "Output Size: %d\n",dst2-dst);
+	fprintf(stderr, "Output Size: %lld\n",(long long int)(dst2-dst));
 
 	if ((dst2-dst)!=(width*height*2))
 		fprintf(stderr, "failed?\n");

man/0xFFFF.1

@@ -0,0 +1,99 @@
+.TH 0xFFFF 1 "November 18, 2010"
+.\" Please adjust this date whenever revising the manpage.
+.SH NAME
+0xFFFF \- Open Free Fiasco Firmware Flasher
+
+.SH SYNOPSIS
+.B 0xFFFF
+.RB [OPTION]...
+.SH DESCRIPTION
+The 'Open Free Fiasco Firmware Flasher' aka 0xFFFF utility implements
+a free (GPL3) userspace handler for the NOLO bootloader and related
+utilities for the Nokia Internet Tablets like flashing, setting device
+options, packing/unpacking FIASCO firmware format and more.
+
+.SH OPTIONS
+.TP
+.BI -b	[args]
+boots the kernel with arguments
+.TP
+.BI -c
+console prompt mode
+.TP
+.BI -d	[vid:pid]
+injects a usb device into the supported list
+.TP
+.BI -D	[0|1|2]
+sets the root device to flash (0), mmc (1) or usb (2)
+.TP
+.BI -f	<flags>
+set the given RD flags (see '-f help')
+.TP
+.BI -i
+show device information (let standby mode)
+.TP
+.BI -l
+list supported usb device ids
+.TP
+.BI -p	[[p%]file]
+piece-of-firmware % file-where-this-piece-is
+.TP
+.BI -r	[0|1]
+disable/enable R&D mode
+.TP
+.BI -R
+reboot the omap board
+.TP
+.BI -U	[0|1]
+disable/enable the usb host mode
+.TP
+.BI -Q
+enter shared queues server mode (for gui or remote)
+.TP
+.BI -s	[serial]
+serial port console (minicom like terminal)
+.TP
+.BI -h
+show help message
+.TP
+.BI -S	[subversion]
+unpacks/flash pieces matching this sub-version information
+.TP
+.BI -n
+do not flash or write to disk (simulation)
+.TP
+.BI -C	[/dev/mtd]
+check bad blocks on mtd
+.TP
+.BI -e	[path]
+dump/extract pieces to path
+.TP
+.BI -F	[fiasco]
+flash a fiasco firmware image
+.TP
+.BI -H	[file]
+calculate hash for file
+.TP
+.BI -I	[piece]
+identify a firmware piece
+.TP
+.BI -P	[new-fiasco]
+creates a new fiasco package, pieces as arguments
+.TP
+.BI -u	[fiasco]
+unpack target fiasco image
+.TP
+.BI -v
+be verbose and noisy
+.TP
+.BI -V
+show version information and exit.
+.TP
+.BI -x
+extract configuration entries from /dev/mtd1
+
+.SH AUTHOR
+0xFFFF was written by pancake.
+.PP
+This manual page was written by Sebastian Reichel <elektranox@gmail.com>,
+for the Debian project (but may be used by others).

man/goxf.1

@@ -0,0 +1,20 @@
+.TH GOXF 1 "November 18, 2010"
+.\" Please adjust this date whenever revising the manpage.
+.SH NAME
+goxf \- 0xFFFF GUI
+.SH SYNOPSIS
+.B goxf
+.RB [FILE]
+.SH DESCRIPTION
+This utility is a graphical interface to 0xFFFF. It is used to
+communicate with the NOLO bootloader of Nokia's internet tablets
+(770, N800, N810, N900).
+.SH OPTIONS
+goxf takes no options.
+.SH SEE ALSO
+.B 0xFFFF(1)
+.SH AUTHOR
+goxf was written by pancake.
+.PP
+This manual page was written by Sebastian Reichel <elektranox@gmail.com>,
+for the Debian project (but may be used by others).

man/logotool.1

@@ -0,0 +1,41 @@
+.TH LOGOTOOL 1 "November 18, 2010"
+.\" Please adjust this date whenever revising the manpage.
+.SH NAME
+logotool \- FIASCO logo file tool
+.SH SYNOPSIS
+.B logotool
+.RB [OPTION]...
+.SH DESCRIPTION
+Tool to compress, uncompress or watch FIASCO logo files.
+.SH OPTIONS
+.TP
+.BI -u	img
+uncompress image to img.rgb
+.TP
+.BI -c	img
+compres a 24 bit rgb raw image to a 16(565) one
+.TP
+.BI -m	img
+show image using mplayer (dumps to <img>.yuv)
+.TP
+.BI -v	img
+view uncompressed image using the 'display' command from ImageMagick (in monochrome)
+.TP
+.BI -w
+specify width (required for -v and -c)
+.TP
+.BI -a
+force RGBA instead of RGB when compressing (use with -c)
+.TP
+.BI -h
+specify height (required for -v and -c)
+.TP
+.BI -V
+show version information and exit.
+.SH SEE ALSO
+.B 0xFFFF(1)
+.SH AUTHOR
+logotool was written by pancake and esteve.
+.PP
+This manual page was written by Sebastian Reichel <elektranox@gmail.com>,
+for the Debian project (but may be used by others).

src/Makefile

@@ -1,19 +1,19 @@
-VERSION=0.3
-OBJ=main.o fiasco.o hexdump.o dump.o flash.o serial.o
-OBJ+=hash.o fpid.o query.o pieces.o utils.o devices.o console.o
-BIN=0xFFFF
-CFLAGS+=-DVERSION=\"${VERSION}\" -Wall -g -I .
-USBOBJ=../libusb/error.o ../libusb/usb.o ../libusb/descriptors.o
-USBOBJ+=../libusb/linux.o ## XXX not portable
+include ../config.mk
 
-all: ${OBJ}
-	${CC} ${LDFLAGS} -o ${BIN} ${OBJ} -lusb
+CPPFLAGS += -DVERSION=\"$(VERSION)\" -D_GNU_SOURCE -I.
+CFLAGS += -W -Wall -O2 -pedantic -std=c99
+LIBS += -lm -lusb
 
-allusb: ${OBJ}
-	${CC} ${LDFLAGS} -o ${BIN} ${OBJ} ${USBOBJ}
+OBJS = main.o nolo.o printf-utils.o image.o fiasco.o device.o usb-device.o cold-flash.o qmode.o console.o squeue/squeue.o operations.o local.o mkii.o disk.o cal.o
+BIN = 0xFFFF
 
-static: ${OBJ}
-	${CC} ${LDFLAGS} -o ${BIN} -static ${OBJ} ${USBOBJ}
+all: $(BIN)
+
+$(BIN): $(OBJS) Makefile ../config.mk
+	$(CC) $(CFLAGS) $(LDFLAGS) -o $(BIN) $(OBJS) $(LIBS)
+
+%.o: %.c Makefile ../config.mk
+	$(CC) $(CFLAGS) $(CPPFLAGS) -c -o $@ $<
 
 clean:
-	-rm -f ${OBJ} ${BIN}
+	-rm -f $(OBJS) $(BIN)

src/cal.c

@@ -0,0 +1,263 @@
+/*
+    0xFFFF - Open Free Fiasco Firmware Flasher
+    Copyright (c) 2011  Michael Buesch <mb@bu3sch.de>
+    Copyright (C) 2012  Pali Rohár <pali.rohar@gmail.com>
+
+    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 3 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, see <http://www.gnu.org/licenses/>.
+
+*/
+
+/* This is simple CAL parser form Calvaria */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdint.h>
+#include <limits.h>
+#include <errno.h>
+#include <string.h>
+
+#include <sys/ioctl.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <unistd.h>
+#include <fcntl.h>
+
+#include <linux/fs.h>
+#include <mtd/mtd-user.h>
+
+#include "cal.h"
+
+#define MAX_SIZE	393216
+#define INDEX_LAST	(0xFF + 1)
+#define HDR_MAGIC	"ConF"
+
+struct cal {
+	int fd;
+	ssize_t size;
+	void * mem;
+};
+
+struct header {
+	char magic[4];		/* Magic sequence */
+	uint8_t type;		/* Type number */
+	uint8_t index;		/* Index number */
+	uint16_t flags;		/* Flags */
+	char name[16];		/* Human readable section name */
+	uint32_t length;	/* Payload length */
+	uint32_t datasum;	/* Data CRC32 checksum */
+	uint32_t hdrsum;	/* Header CRC32 checksum */
+} __attribute__((__packed__));
+
+
+int cal_init_file(const char * file, struct cal ** cal_out) {
+
+	int fd = -1;
+	uint64_t blksize = 0;
+	ssize_t size = 0;
+	void * mem = NULL;
+	struct cal * cal = NULL;
+	struct stat st;
+	mtd_info_t mtd_info;
+
+	if ( stat(file, &st) != 0 )
+		return -1;
+
+	fd = open(file, O_RDONLY);
+
+	if ( fd < 0 )
+		return -1;
+
+	if ( S_ISREG(st.st_mode) )
+		size = st.st_size;
+	else if ( S_ISBLK(st.st_mode) ) {
+		if ( ioctl(fd, BLKGETSIZE64, &blksize) != 0 )
+			goto err;
+		if ( blksize > SSIZE_MAX )
+			goto err;
+		size = blksize;
+	} else if ( S_ISCHR(st.st_mode) && major(st.st_rdev) == 90 ) {
+		if ( ioctl(fd, MEMGETINFO, &mtd_info) != 0 )
+			goto err;
+		size = mtd_info.size;
+	} else {
+		goto err;
+	}
+
+	if ( size == 0 || size > MAX_SIZE )
+		goto err;
+
+	mem = malloc(size);
+
+	if ( ! mem )
+		goto err;
+
+	if ( read(fd, mem, size) != size )
+		goto err;
+
+	cal = malloc(sizeof(struct cal));
+
+	if ( ! cal )
+		goto err;
+
+	cal->fd = fd;
+	cal->mem = mem;
+	cal->size = size;
+
+	*cal_out = cal;
+	return 0;
+
+err:
+	close(fd);
+	free(mem);
+	return -1;
+
+}
+
+int cal_init(struct cal ** cal_out) {
+
+	return cal_init_file("/dev/mtd1ro", cal_out);
+
+}
+
+void cal_finish(struct cal * cal) {
+
+	if ( cal ) {
+		free(cal->mem);
+		free(cal);
+	}
+
+}
+
+static uint32_t crc32(uint32_t crc, const void * _data, size_t size) {
+
+	const uint8_t * data = _data;
+	uint8_t value;
+	unsigned int bit;
+	size_t i;
+	const uint32_t poly = 0xEDB88320;
+
+	for ( i = 0; i < size; i++ ) {
+		value = data[i];
+		for ( bit = 8; bit; bit-- ) {
+			if ( (crc & 1) != (value & 1) )
+				crc = (crc >> 1) ^ poly;
+			else
+				crc >>= 1;
+			value >>= 1;
+		}
+	}
+
+	return crc;
+
+}
+
+static int is_header(void *data, size_t size) {
+
+	struct header * hdr = data;
+
+	if ( size < sizeof(struct header) )
+		return 0;
+
+	if ( memcmp(hdr->magic, HDR_MAGIC, sizeof(hdr->magic)) != 0 )
+
+		return 0;
+	return 1;
+
+}
+
+static int64_t find_section(void *start, uint64_t count, int want_index, const char *want_name) {
+
+	int64_t offset = 0, found_offset = -1;
+	uint8_t * data = start;
+	struct header *hdr;
+	char sectname[sizeof(hdr->name) + 1] = { 0, };
+	uint32_t payload_len;
+	int previous_index = -1;
+
+	while ( 1 ) {
+
+		/* Find header start */
+		if ( count < sizeof(struct header) )
+			break;
+
+		if ( ! is_header(data + offset, count) ) {
+			count--;
+			offset++;
+			continue;
+		}
+
+		hdr = (struct header *)(data + offset);
+		payload_len = hdr->length;
+
+		if ( count - sizeof(struct header) < payload_len )
+			return -1;
+
+		memcpy(sectname, hdr->name, sizeof(hdr->name));
+
+		if ( want_index == INDEX_LAST ) {
+			if ((int)hdr->index <= previous_index)
+				goto next;
+		} else {
+			if (want_index >= 0 && want_index != hdr->index)
+				goto next;
+		}
+
+		if ( want_name && strcmp(sectname, want_name) != 0 )
+			goto next;
+
+		/* Found it */
+		found_offset = offset;
+		if ( want_index == INDEX_LAST )
+			previous_index = hdr->index;
+		else
+			break;
+
+next:
+		count -= sizeof(struct header) + payload_len;
+		offset += sizeof(struct header) + payload_len;
+
+	}
+
+	return found_offset;
+
+}
+
+int cal_read_block(struct cal * cal, const char * name, void ** ptr, unsigned long * len, unsigned long flags) {
+
+	int64_t find_offset;
+	uint64_t filelen = cal->size;
+	uint8_t * data = cal->mem;
+	struct header * hdr;
+
+	find_offset = find_section(data, filelen, INDEX_LAST, name);
+	if ( find_offset < 0 )
+		return -1;
+
+	hdr = (struct header *)(data + find_offset);
+
+	if ( flags && hdr->flags != flags )
+		return -1;
+
+	if ( crc32(0, hdr, sizeof(*hdr) - 4) != hdr->hdrsum )
+		return -1;
+
+	*ptr = data + find_offset + sizeof(struct header);
+	*len = hdr->length;
+
+	if ( crc32(0, *ptr, *len) != hdr->datasum )
+		return -1;
+
+	return 0;
+
+}

src/cal.h

@@ -0,0 +1,35 @@
+/*
+    0xFFFF - Open Free Fiasco Firmware Flasher
+    Copyright (c) 2011  Michael Buesch <mb@bu3sch.de>
+    Copyright (C) 2012  Pali Rohár <pali.rohar@gmail.com>
+
+    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 3 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, see <http://www.gnu.org/licenses/>.
+
+*/
+
+#ifndef CAL_H
+#define CAL_H
+
+#define CAL_MAX_NAME_LEN	16
+#define CAL_FLAG_USER		0x0001
+#define CAL_FLAG_WRITE_ONCE	0x0002
+
+struct cal;
+
+int cal_init(struct cal ** cal_out);
+int cal_init_file(const char * file, struct cal ** cal_out);
+void cal_finish(struct cal * cal);
+int cal_read_block(struct cal * cal, const char * name, void ** ptr, unsigned long * len, unsigned long flags);
+
+#endif

src/cold-flash.c

@@ -0,0 +1,410 @@
+/*
+    cold-flash.c - Cold flashing
+    Copyright (C) 2011-2012  Pali Rohár <pali.rohar@gmail.com>
+
+    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 3 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, see <http://www.gnu.org/licenses/>.
+
+*/
+
+#include <stdio.h>
+#include <stdint.h>
+#include <string.h>
+#include <errno.h>
+#include <usb.h>
+
+#include "global.h"
+
+#include "cold-flash.h"
+#include "image.h"
+#include "usb-device.h"
+#include "printf-utils.h"
+
+#define READ_DEV		0x81
+#define WRITE_DEV		0x01
+#define READ_TIMEOUT		500
+#define WRITE_TIMEOUT		3000
+
+static uint32_t tab[256];
+
+static void crc32_gentab(void) {
+
+	int i, j;
+	uint32_t crc;
+	uint32_t poly = 0xEDB88320L;
+
+	for ( i = 0; i < 256; i++) {
+
+		crc = i;
+
+		for ( j = 8; j > 0; j-- ) {
+
+			if (crc & 1)
+				crc = (crc >> 1) ^ poly;
+			else
+				crc >>= 1;
+
+		}
+
+		tab[i] = crc;
+
+	}
+
+}
+
+static uint32_t crc32(unsigned char * bytes, size_t size, uint32_t crc) {
+
+	static int gen = 0;
+	uint32_t i;
+
+	if ( ! gen ) {
+		crc32_gentab();
+		gen = 1;
+	}
+
+	for ( i = 0; i < size; ++i )
+		crc = (crc >> 8) ^ tab[(crc ^ bytes[i]) & 0xff];
+
+	return crc;
+
+}
+
+/* Omap Boot Messages */
+/* See spruf98v.pdf (page 3444): OMAP35x Technical Reference Manual - 25.4.5 Periheral Booting */
+
+/* Omap Peripheral boot message */
+static const uint32_t omap_peripheral_msg = 0xF0030002;
+
+/* Omap Void (no device) boot message */
+static const uint32_t omap_void_msg = 0xF0030006;
+
+/* Omap XIP memory boot message */
+static const uint32_t omap_xip_msg = 0xF0030106;
+
+/* Omap Nand boot message */
+static const uint32_t omap_nand_msg = 0xF0030206;
+
+/* Omap OneNAND boot message */
+static const uint32_t omap_onenand_msg = 0xF0030306;
+
+/* Omap DOC boot message */
+static const uint32_t omap_doc_msg = 0xF0030406;
+
+/* Omap MMC/SD2 boot message */
+static const uint32_t omap_mmc2_msg = 0xF0030506;
+
+/* Omap MMC/SD1 boot message */
+static const uint32_t omap_mmc1_msg = 0xF0030606;
+
+/* Omap XIP memory with wait monitoring boot message */
+static const uint32_t omap_xipwait_msg = 0xF0030706;
+
+/* Omap UART boot message */
+static const uint32_t omap_uart_msg = 0xF0031006;
+
+/* Omap HS USB boot message */
+static const uint32_t omap_hsusb_msg = 0xF0031106;
+
+/* Omap next device boot message */
+static const uint32_t omap_next_msg = 0xFFFFFFFF;
+
+/* Omap memory boot message */
+static const uint32_t omap_memory_msg = 0;
+
+
+/* Nokia X-Loader messages */
+
+/* Structure of X-Loader message */
+struct xloader_msg {
+	uint32_t type; /* 4 bytes - type of message */
+	uint32_t size; /* 4 bytes - size of file */
+	uint32_t crc1; /* 4 bytes - crc32 of file */
+	uint32_t crc2; /* 4 bytes - crc32 of first 12 bytes of message */
+};
+
+#define XLOADER_MSG_TYPE_PING	0x6301326E
+#define XLOADER_MSG_TYPE_SEND	0x6302326E
+
+struct xloader_msg xloader_msg_create(uint32_t type, struct image * image) {
+
+	struct xloader_msg msg;
+	uint32_t need, readed;
+	int ret;
+	uint8_t buffer[1024];
+
+	msg.type = type;
+	msg.size = 0;
+	msg.crc1 = 0;
+
+	if ( image ) {
+		msg.size = image->size;
+		image_seek(image, 0);
+		readed = 0;
+		while ( readed < image->size ) {
+			need = image->size - readed;
+			if ( need > sizeof(buffer) )
+				need = sizeof(buffer);
+			ret = image_read(image, buffer, need);
+			if ( ret == 0 )
+				break;
+			msg.crc1 = crc32(buffer, ret, msg.crc1);
+			readed += ret;
+		}
+	}
+
+	msg.crc2 = crc32((unsigned char *)&msg, 12, 0);
+
+	return msg;
+
+}
+
+static int read_asic(usb_dev_handle * udev, uint8_t * asic_buffer, int size, int asic_size) {
+
+	int ret;
+
+	printf("Waiting for ASIC ID...\n");
+	ret = usb_bulk_read(udev, READ_DEV, (char *)asic_buffer, size, READ_TIMEOUT);
+	if ( ret != asic_size )
+		ERROR_RETURN("Invalid size of ASIC ID", -1);
+
+	return 0;
+
+}
+
+static int send_2nd(usb_dev_handle * udev, struct image * image) {
+
+	uint8_t buffer[1024];
+	uint32_t need, readed;
+	int ret;
+
+	printf("Sending OMAP peripheral boot message...\n");
+	ret = usb_bulk_write(udev, WRITE_DEV, (char *)&omap_peripheral_msg, sizeof(omap_peripheral_msg), WRITE_TIMEOUT);
+	usleep(5000);
+	if ( ret != sizeof(omap_peripheral_msg) )
+		ERROR_RETURN("Sending OMAP peripheral boot message failed", -1);
+
+	printf("Sending 2nd X-Loader image size...\n");
+	ret = usb_bulk_write(udev, WRITE_DEV, (char *)&image->size, 4, WRITE_TIMEOUT);
+	usleep(5000);
+	if ( ret != 4 )
+		ERROR_RETURN("Sending 2nd X-Loader image size failed", -1);
+
+	printf("Sending 2nd X-Loader image...\n");
+	printf_progressbar(0, image->size);
+	image_seek(image, 0);
+	readed = 0;
+	while ( readed < image->size ) {
+		need = image->size - readed;
+		if ( need > sizeof(buffer) )
+			need = sizeof(buffer);
+		ret = image_read(image, buffer, need);
+		if ( ret == 0 )
+			break;
+		if ( usb_bulk_write(udev, WRITE_DEV, (char *)buffer, ret, WRITE_TIMEOUT) != ret )
+			PRINTF_ERROR_RETURN("Sending 2nd X-Loader image failed", -1);
+		readed += ret;
+		printf_progressbar(readed, image->size);
+	}
+	usleep(50000);
+
+	return 0;
+
+}
+
+static int send_secondary(usb_dev_handle * udev, struct image * image) {
+
+	struct xloader_msg init_msg;
+	uint8_t buffer[1024];
+	uint32_t need, readed;
+	int ret;
+
+	init_msg = xloader_msg_create(XLOADER_MSG_TYPE_SEND, image);
+
+	printf("Sending X-Loader init message...\n");
+	ret = usb_bulk_write(udev, WRITE_DEV, (char *)&init_msg, sizeof(init_msg), WRITE_TIMEOUT);
+	usleep(5000);
+	if ( ret != sizeof(init_msg) )
+		ERROR_RETURN("Sending X-Loader init message failed", -1);
+
+	printf("Waiting for X-Loader response...\n");
+	ret = usb_bulk_read(udev, READ_DEV, (char *)&buffer, 4, READ_TIMEOUT); /* 4 bytes - dummy value */
+	if ( ret != 4 )
+		ERROR_RETURN("No response", -1);
+
+	printf("Sending Secondary image...\n");
+	printf_progressbar(0, image->size);
+	image_seek(image, 0);
+	readed = 0;
+	while ( readed < image->size ) {
+		need = image->size - readed;
+		if ( need > sizeof(buffer) )
+			need = sizeof(buffer);
+		ret = image_read(image, buffer, need);
+		if ( ret == 0 )
+			break;
+		if ( usb_bulk_write(udev, WRITE_DEV, (char *)buffer, ret, WRITE_TIMEOUT) != ret )
+			PRINTF_ERROR_RETURN("Sending Secondary image failed", -1);
+		readed += ret;
+		printf_progressbar(readed, image->size);
+	}
+	usleep(5000);
+
+	printf("Waiting for X-Loader response...\n");
+	ret = usb_bulk_read(udev, READ_DEV, (char *)&buffer, 4, READ_TIMEOUT); /* 4 bytes - dummy value */
+	if ( ret != 4 )
+		ERROR_RETURN("No response", -1);
+
+	return 0;
+
+}
+
+static int ping_timeout(usb_dev_handle * udev) {
+
+	int ret;
+	int pong = 0;
+	int try_ping = 10;
+
+	while ( try_ping > 0 ) {
+
+		struct xloader_msg ping_msg = xloader_msg_create(XLOADER_MSG_TYPE_PING, NULL);
+		int try_read = 4;
+
+		printf("Sending X-Loader ping message\n");
+		ret = usb_bulk_write(udev, WRITE_DEV, (char *)&ping_msg, sizeof(ping_msg), WRITE_TIMEOUT);
+		if ( ret != sizeof(ping_msg) )
+			ERROR_RETURN("Sending X-Loader ping message faild", -1);
+
+		printf("Waiting for X-Loader pong response...\n");
+		while ( try_read > 0 ) {
+
+			uint32_t ping_read;
+			ret = usb_bulk_read(udev, READ_DEV, (char *)&ping_read, sizeof(ping_read), READ_TIMEOUT);
+			if ( ret == sizeof(ping_read) ) {
+				printf("Got it\n");
+				pong = 1;
+				break;
+			}
+
+			usleep(5000);
+			--try_read;
+
+		}
+
+		if ( pong )
+			break;
+
+		printf("Responce timeout\n");
+		--try_ping;
+
+	}
+
+	if (pong)
+		return 0;
+	else
+		return -1;
+
+}
+
+int init_cold_flash(struct usb_device_info * dev) {
+
+	uint8_t asic_buffer[127];
+	int asic_size = 69;
+	int i;
+
+	if ( dev->flash_device->protocol != FLASH_COLD )
+		ERROR_RETURN("Device is not in Cold Flash mode", -1);
+
+	if ( read_asic(dev->udev, asic_buffer, sizeof(asic_buffer), asic_size) != 0 )
+		ERROR_RETURN("Reading ASIC ID failed", -1);
+
+	if ( verbose ) {
+		printf("Got ASIC ID:");
+		for ( i = 0; i < asic_size; ++i )
+			printf(" 0x%.2X", (unsigned int)asic_buffer[i]);
+		printf("\n");
+	}
+
+	/* TODO: Detect device from asic id */
+
+	/* ASIC ID specification: http://processors.wiki.ti.com/index.php/OMAP35x_and_AM/DM37x_Initialization#UART.2FUSB_Booting */
+
+	/* Number of subblocks */
+	if ( asic_buffer[0] != 0x05 )
+		ERROR_RETURN("Invalid ASIC ID", -1);
+
+	/* ID Subblock - header */
+	if ( memcmp(asic_buffer+1, "\x01\x05\x01", 3) != 0 )
+		ERROR_RETURN("Invalid ASIC ID", -1);
+
+	/* ID Subblock - OMAP chip version (check for OMAP35x) */
+	if ( memcmp(asic_buffer+4, "\x34\x30\x07", 3) != 0 )
+		ERROR_RETURN("Invalid ASIC ID", -1);
+
+	/* Reserved1 - header */
+	if ( memcmp(asic_buffer+8, "\x13\x02\x01", 3) != 0 )
+		ERROR_RETURN("Invalid ASIC ID", -1);
+
+	/* 2nd ID Subblock - header */
+	if ( memcmp(asic_buffer+12, "\x12\x15\x01", 3) != 0 )
+		ERROR_RETURN("Invalid ASIC ID", -1);
+
+	/* Reserved2 - header */
+	if ( memcmp(asic_buffer+35, "\x14\x15\x01", 3) != 0 )
+		ERROR_RETURN("Invalid ASIC ID", -1);
+
+	/* Checksum subblock - header */
+	if ( memcmp(asic_buffer+58, "\x15\x09\x01", 3) != 0 )
+		ERROR_RETURN("Invalid ASIC ID", -1);
+
+	printf("Detected OMAP35x chip\n");
+
+	return 0;
+
+}
+
+int cold_flash(struct usb_device_info * dev, struct image * x2nd, struct image * secondary) {
+
+	if ( x2nd->type != IMAGE_2ND )
+		ERROR_RETURN("Image type is not 2nd X-Loader", -1);
+
+	if ( secondary->type != IMAGE_SECONDARY )
+		ERROR_RETURN("Image type is not Secondary", -1);
+
+	if ( send_2nd(dev->udev, x2nd) != 0 )
+		ERROR_RETURN("Sending 2nd X-Loader image failed", -1);
+
+	if ( ping_timeout(dev->udev) != 0 )
+		ERROR_RETURN("Sending X-Loader ping message failed", -1);
+
+	if ( send_secondary(dev->udev, secondary) != 0 )
+		ERROR_RETURN("Sending Secondary image failed", -1);
+
+	printf("Done\n");
+	return 0;
+
+}
+
+int leave_cold_flash(struct usb_device_info * dev) {
+
+	int ret;
+
+	printf("Sending OMAP memory boot message...\n");
+	ret = usb_bulk_write(dev->udev, WRITE_DEV, (char *)&omap_memory_msg, sizeof(omap_memory_msg), WRITE_TIMEOUT);
+	usleep(5000);
+	if ( ret != sizeof(omap_memory_msg) )
+		ERROR_RETURN("Sending OMAP memory boot message failed", -1);
+
+	usleep(250000);
+	return 0;
+
+}

src/cold-flash.h

@@ -0,0 +1,35 @@
+/*
+    cold-flash.h - Cold flashing
+    Copyright (C) 2011-2012  Pali Rohár <pali.rohar@gmail.com>
+
+    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 3 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, see <http://www.gnu.org/licenses/>.
+
+*/
+
+#ifndef COLD_FLASH_H
+#define COLD_FLASH_H
+
+#include "image.h"
+#include "usb-device.h"
+
+/* Initialize Cold Flash mde */
+int init_cold_flash(struct usb_device_info * dev);
+
+/* Flash 2nd and secondary image in Cold Flash mode. After flashing device will boot secondary image */
+int cold_flash(struct usb_device_info * dev, struct image * x2nd, struct image * secondary);
+
+/* Leave Cold Flashing mode and continue booting */
+int leave_cold_flash(struct usb_device_info * dev);
+
+#endif

src/console.c

@@ -1,6 +1,7 @@
 /*
  *  0xFFFF - Open Free Fiasco Firmware Flasher
- *  Copyright (C) 2007  pancake <pancake@youterm.com>
+ *  Copyright (C) 2007, 2008  pancake <pancake@youterm.com>
+ *  Copyright (C) 2012        Pali Rohár <pali.rohar@gmail.com>
  *
  *  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
@@ -16,20 +17,21 @@
  *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
-#include "main.h"
-#include "query.h"
 #include <stdio.h>
 #include <string.h>
 #include <stdlib.h>
 #include <getopt.h>
+#include <unistd.h>
 
-void cmd_exit(char *line)
-{
+#include "global.h"
+#include "console.h"
+
+static void cmd_exit(char *line) {
 	exit(0);
+	(void)line;
 }
 
-void cmd_help(char *line)
-{
+static void cmd_help(char *line) {
 	printf("connect           connects via usb to nolo\n");
 	printf("reboot            reboots remote host\n");
 	printf("info              shows info of the remote system\n");
@@ -41,79 +43,75 @@ void cmd_help(char *line)
 	printf("                  f.ex: nanddump /dev/mtd0 0x0 0x4000 xloader.bin 1 1\n");
 	printf("exit              exits the shell\n");
 	fflush(stdout);
+	(void)line;
 }
 
-void cmd_info(char *line)
-{
-	get_hw_revision(); // get hardware revision:
-	get_root_device(); // only for flashing
-	get_usb_mode();
-	get_rd_mode();
-	get_rd_flags();
+static void cmd_info(char *line) {
+	/* TODO */
+	(void)line;
 }
 
-void cmd_nanddump(char *line)
-{
+static void cmd_nanddump(char *line) {
+
 	char dev[128];
 	int from;
 	int length;
 	char out[128];
 	int ignbb;
 	int ignoob = -1;
-	sscanf(line, "%127s 0x%x 0x%x %127s %d %d", &dev, &from, &length, &out, &ignbb, &ignoob);
-	if (ignoob == -1) {
-		printf("Invalid arguments.\n");
-		printf("nanddump [dev] [start] [len] [out] [ignore-badblocks] [ignore-oob]\n");
-		printf("                  f.ex: nanddump /dev/mtd0 0x0 0x4000 xloader.bin 1 1\n");
-	} else {
-		nanddump(dev, from, length, out, ignbb, ignoob);
-	}
+
+	sscanf(line, "%127s 0x%x 0x%x %127s %d %d",
+		(char *)&dev, (unsigned int*)&from, (unsigned int *)&length,
+		(char *)&out, (int*)&ignbb, (int *)&ignoob);
+
+	/* TODO */
 }
 
-void cmd_dump(char *line)
-{
-	if (!line[0]) {
+static void cmd_dump(char *line) {
+
+	if ( ! line[0] ) {
 		printf("Usage: dump [path]\n");
 		return;
 	}
-	while(line[0]==' ') line = line +1;
-	reverse_extract_pieces(line);
+
+	while ( line[0] == ' ' )
+		++line;
+
+	/* TODO */
 }
 
-void cmd_badblocks(char *line)
-{
-	if (!line[0]) {
-		printf("Usage: dump [path]\n");
+static void cmd_badblocks(char *line) {
+
+	if ( ! line[0] ) {
+		printf("Usage: badblocks [path]\n");
 		return;
 	}
-	while(line[0]==' ') line = line +1;
-	check_badblocks(line);
+
+	while ( line[0] == ' ' )
+		++line;
+
+	/* TODO */
 }
 
-void cmd_connect(char *line)
-{
-	connect_via_usb();
+static void cmd_connect(char *line) {
+	/* TODO */
+	(void)line;
 }
 
-void cmd_reboot(char *line)
-{
-	reboot_board();
+static void cmd_reboot(char *line) {
+	/* TODO */
+	(void)line;
 }
 
-void cmd_shell(char *line)
-{
+static void cmd_shell(char *line) {
 	system("/bin/sh");
+	(void)line;
 }
 
-#define CMDS 11
-#define IS_CMD(x) !strcmp(console_commands[i].name, x)
-#define CALL_CMD(x) console_commands[x].callback((char *)line)
-#define FOREACH_CMD(x) for(x=0;x<CMDS;x++)
-
-struct cmd_t {
+static struct cmd_t {
 	char *name;
 	void (*callback)(char *);
-} console_commands[CMDS] = {
+} console_commands[] = {
 	{ .name = "exit",      .callback = &cmd_exit },
 	{ .name = "q",         .callback = &cmd_exit },
 	{ .name = "connect",   .callback = &cmd_connect },
@@ -127,37 +125,42 @@ struct cmd_t {
 	{ .name = "shell",     .callback = &cmd_shell }
 };
 
-static int console_command(const char *line)
-{
-	int i;
+static int console_command(char *line) {
+
+	size_t i;
 	char command[11];
 
 	command[0] = '\0';
 	sscanf(line, "%10s", command);
 	line = line + strlen(command);
 
-	FOREACH_CMD(i)
-		if (IS_CMD(command))
-			CALL_CMD(i);
-	//
+	for ( i = 0; i < (sizeof(console_commands)/sizeof(console_commands[0])); ++i )
+		if ( strcmp(console_commands[i].name, command) == 0 )
+			console_commands[i].callback(line);
+
 	return 1;
+
 }
 
-int console_prompt()
-{
+int console_prompt(void) {
+
 	char line[1024];
 
 	do {
 		write(1, "0xFFFF> ", 8);
 		line[0] = '\0';
 		fgets(line, 1024, stdin);
-		if (feof(stdin)) {
+
+		if ( feof(stdin) ) {
 			write(1, "\n", 1);
 			break;
 		}
-		if (line[0]) line[strlen(line)-1] = '\0';
+
+		if ( line[0] )
+			line[strlen(line)-1] = '\0';
 		line[1023] = '\0';
-	} while(console_command(line));
+	} while ( console_command(line) );
 
 	return 0;
+
 }

src/console.h

@@ -1,6 +1,7 @@
 /*
  *  0xFFFF - Open Free Fiasco Firmware Flasher
- *  Copyright (C) 2007  pancake <pancake@youterm.com>
+ *  Copyright (C) 2007, 2008  pancake <pancake@youterm.com>
+ *  Copyright (C) 2012        Pali Rohár <pali.rohar@gmail.com>
  *
  *  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
@@ -16,34 +17,9 @@
  *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
-#include <glade/glade.h>
-#include <gtk/gtk.h>
+#ifndef CONSOLE_H
+#define CONSOLE_H
 
-#define U(x) printf("%d\n",x); fflush(stdout);
+int console_prompt(void);
 
-int main(int argc, char **argv)
-{
-	GtkWidget *w;
-	GladeXML *xml;
-
-	gtk_init(&argc, &argv);
-
-	xml = glade_xml_new("g0xFFFF.glade", "main_window", "");
-	//xml = glade_xml_new("test.glade", "window1", NULL);
-	if(!xml) {
-		g_warning("We could not load the interface!");
-		return 1;
-	}
-
-	glade_xml_signal_autoconnect(xml);
-
-	w = glade_xml_get_widget(xml, "main_window");
-	gtk_signal_connect(GTK_OBJECT(w), "destroy",
-		GTK_SIGNAL_FUNC(gtk_main_quit),NULL);
-	gtk_widget_show_all(w);
-
-	gtk_object_unref(GTK_OBJECT(xml));
-
-	gtk_main();
-	return 0;	
-}
+#endif

src/device.c

@@ -0,0 +1,329 @@
+/*
+    0xFFFF - Open Free Fiasco Firmware Flasher
+    Copyright (C) 2012  Pali Rohár <pali.rohar@gmail.com>
+
+    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 3 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, see <http://www.gnu.org/licenses/>.
+
+*/
+
+#include <stdlib.h>
+#include <stdint.h>
+#include <string.h>
+#include <math.h>
+
+#include "global.h"
+
+#include "device.h"
+
+static const char * devices[] = {
+	[DEVICE_SU_18] = "SU-18",
+	[DEVICE_RX_34] = "RX-34",
+	[DEVICE_RX_44] = "RX-44",
+	[DEVICE_RX_48] = "RX-48",
+	[DEVICE_RX_51] = "RX-51",
+};
+
+enum device device_from_string(const char * device) {
+
+	size_t i;
+
+	if ( ! device || ! device[0] )
+		return DEVICE_ANY;
+
+	for ( i = 0; i < sizeof(devices)/sizeof(devices[0]); ++i )
+		if ( devices[i] && strcmp(devices[i], device) == 0 )
+			return i;
+
+	return DEVICE_UNKNOWN;
+
+}
+
+const char * device_to_string(enum device device) {
+
+	if ( device > sizeof(devices)/sizeof(devices[0]) )
+		return NULL;
+
+	return devices[device];
+
+}
+
+static const char * long_devices[] = {
+	[DEVICE_SU_18] = "Nokia 770",
+	[DEVICE_RX_34] = "Nokia N800",
+	[DEVICE_RX_44] = "Nokia N810",
+	[DEVICE_RX_48] = "Nokia N810 Wimax",
+	[DEVICE_RX_51] = "Nokia N900",
+};
+
+const char * device_to_long_string(enum device device) {
+
+	if ( device > sizeof(long_devices)/sizeof(long_devices[0]) )
+		return NULL;
+
+	return long_devices[device];
+
+}
+
+int hwrev_is_valid(const int16_t * hwrevs, int16_t hwrev) {
+
+	int i;
+
+	/* hwrevs not specified, valid for any hwrev */
+	if ( ! hwrevs )
+		return 1;
+
+	for ( i = 0; hwrevs[i] != -1; ++i )
+		if ( hwrev == hwrevs[i] )
+			return 1;
+
+	return 0;
+
+}
+
+int16_t * hwrevs_alloc_from_string(const char * str) {
+
+	const char * ptr = str;
+	const char * oldptr = ptr;
+	int count = 2;
+	int16_t * ret;
+	int16_t tmp;
+	int i;
+	char buf[5];
+
+	if ( ! str )
+		return NULL;
+
+	while ( (ptr = strchr(ptr, ',')) ) {
+		++count;
+		++ptr;
+	}
+
+	ret = calloc(count, sizeof(int16_t));
+	if ( ! ret )
+		return NULL;
+
+	i = 0;
+
+	ptr = str;
+	while ( (ptr = strchr(ptr, ',')) ) {
+		strncpy(buf, oldptr, ptr-oldptr);
+		buf[4] = 0;
+		tmp = atoi(buf);
+		if ( tmp >= 0 )
+			ret[i++] = tmp;
+		++ptr;
+		oldptr = ptr;
+	}
+
+	tmp = atoi(oldptr);
+	if ( tmp >= 0 )
+		ret[i++] = tmp;
+
+	ret[i++] = -1;
+	return ret;
+
+}
+
+char * hwrevs_alloc_to_string(const int16_t * hwrevs) {
+
+	char * ret;
+	char * ptr;
+	int i;
+	int len = 0;
+
+	for ( i = 0; hwrevs[i] != -1; ++i )
+		len += log10(hwrevs[i]+1)+2;
+
+	ret = calloc(1, len+1);
+	if ( ! ret )
+		return NULL;
+
+	ptr = ret;
+	for ( i = 0; hwrevs[i] != -1; ++i )
+		ptr += sprintf(ptr, "%d,", hwrevs[i]);
+
+	*(ptr-1) = 0;
+	return ret;
+
+}
+
+#define MAX_HWREVS 29
+
+char ** device_list_alloc_to_bufs(const struct device_list * device_list) {
+
+	int count = 0;
+	int size = 0;
+	const char * device;
+	const struct device_list * device_first;
+	char ** ret;
+	char * last_ptr;
+	int i, j, k;
+
+	device_first = device_list;
+
+	while ( device_first ) {
+
+		int local = 0;
+
+		if ( ! device_to_string(device_first->device) ) {
+			device_first = device_first->next;
+			continue;
+		}
+
+		for ( i = 0; device_first->hwrevs[i] != -1; ++i )
+			if ( device_first->hwrevs[i] >= 0 && device_first->hwrevs[i] <= 9999 )
+				++local;
+
+		size += (1+16+(MAX_HWREVS+1)*8)*(local/MAX_HWREVS+1);
+		count += local/MAX_HWREVS;
+		if ( local%MAX_HWREVS != 0 || local == 0 )
+			++count;
+
+		device_first = device_first->next;
+
+	}
+
+	ret = calloc(1, (count+1)*sizeof(char *) + size);
+	if ( ! ret )
+		return NULL;
+
+	j = 0;
+	last_ptr = (char *)ret + (count+1)*sizeof(char *);
+	device_first = device_list;
+
+	while ( device_first ) {
+
+		i = -1;
+
+		device = device_to_string(device_first->device);
+		if ( ! device ) {
+			device_first = device_first->next;
+			continue;
+		}
+
+		while ( device_first->hwrevs[i+1] != -1 ) {
+
+			uint8_t len = 0;
+			ret[j] = ++last_ptr;
+
+			strncpy(ret[j]+1, device, 16);
+			last_ptr += 16;
+			len += 16;
+
+			k = 0;
+
+			for ( k = 0; k < MAX_HWREVS; ++k ) {
+
+				if ( device_first->hwrevs[i+1] == -1 )
+					break;
+
+				++i;
+
+				if ( device_first->hwrevs[i] < 0 || device_first->hwrevs[i] > 9999 )
+					continue;
+
+				snprintf(ret[j]+1+16+k*8, 8, "%d", device_first->hwrevs[i]);
+				last_ptr += 8;
+				len += 8;
+
+			}
+
+			((uint8_t*)ret[j])[0] = len;
+
+			++j;
+
+		}
+
+		device_first = device_first->next;
+
+	}
+
+	ret[j] = NULL;
+
+	return ret;
+
+}
+
+struct device_list * device_list_alloc_from_buf(const char * buf, size_t size) {
+
+	int i;
+	int len;
+	int count;
+	char str[17];
+	const char * ptr1;
+	const char * ptr;
+	struct device_list * ret;
+
+	ret = calloc(1, sizeof(struct device_list));
+	if ( ! ret )
+		return NULL;
+
+	len = strnlen(buf, size);
+	if ( len > 16 )
+		len = 16;
+
+	memset(str, 0, sizeof(str));
+	memcpy(str, buf, len);
+	ptr1 = buf + len;
+
+	ret->device = device_from_string(str);
+
+	ptr = ptr1;
+	count = 1;
+	while ( ptr < buf + size ) {
+
+		while ( ptr < buf + size && *ptr < 32 )
+			++ptr;
+
+		if ( ptr >= buf + size )
+			break;
+
+		len = strnlen(ptr, buf + size - ptr);
+		if ( len > 8 )
+			len = 8;
+
+		ptr += len + 1;
+		++count;
+
+	}
+
+	ret->hwrevs = calloc(count, sizeof(int16_t));
+	if ( ! ret->hwrevs )
+		return ret;
+
+	ptr = ptr1;
+	i = 0;
+	while ( ptr < buf + size ) {
+
+		while ( ptr < buf + size && *ptr < 32 )
+			++ptr;
+
+		if ( ptr >= buf + size )
+			break;
+
+		len = strnlen(ptr, buf + size - ptr);
+		if ( len > 8 )
+			len = 8;
+
+		memset(str, 0, sizeof(str));
+		memcpy(str, ptr, len);
+		ptr += len + 1;
+		ret->hwrevs[i++] = atoi(str);
+
+	}
+
+	ret->hwrevs[i] = -1;
+	return ret;
+
+}

src/device.h

@@ -0,0 +1,59 @@
+/*
+    0xFFFF - Open Free Fiasco Firmware Flasher
+    Copyright (C) 2012  Pali Rohár <pali.rohar@gmail.com>
+
+    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 3 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, see <http://www.gnu.org/licenses/>.
+
+*/
+
+#ifndef DEVICE_H
+#define DEVICE_H
+
+#include <stdint.h>
+
+enum device {
+	DEVICE_UNKNOWN = 0,
+	DEVICE_ANY,   /* Unspecified / Any device */
+	DEVICE_SU_18, /* Nokia 770 */
+	DEVICE_RX_34, /* Nokia N800 */
+	DEVICE_RX_44, /* Nokia N810 */
+	DEVICE_RX_48, /* Nokia N810 WiMax */
+	DEVICE_RX_51, /* Nokia N900 */
+	DEVICE_COUNT,
+};
+
+/*
+  hwrevs - array of int16_t
+         - terminated by -1
+         - valid numbers: 0-9999
+*/
+struct device_list {
+	enum device device;
+	int16_t * hwrevs;
+	struct device_list * next;
+};
+
+enum device device_from_string(const char * device);
+const char * device_to_string(enum device device);
+const char * device_to_long_string(enum device device);
+
+int hwrev_is_valid(const int16_t * hwrevs, int16_t hwrev);
+
+int16_t * hwrevs_alloc_from_string(const char * str);
+char * hwrevs_alloc_to_string(const int16_t * hwrevs);
+
+char ** device_list_alloc_to_bufs(const struct device_list * device_list);
+struct device_list * device_list_alloc_from_buf(const char * buf, size_t size);
+
+#endif

src/devices.c

@@ -1,118 +0,0 @@
-/*
- *  0xFFFF - Open Free Fiasco Firmware Flasher
- *  Copyright (C) 2007  pancake <pancake@youterm.com>
- *
- *  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 3 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, see <http://www.gnu.org/licenses/>.
- */
-
-#include "main.h"
-#include <stdio.h>
-#include <string.h>
-#include <stdlib.h>
-
-/*
- * The internet tablet PC (and probably most of
- * Nokia devices have different USB-IDs depending
- * on the boot state.
- *
- * The following table shows this info:
- *
- *           boot       os
- * n770   0421:0105  0421:0431
- * n800              0421:0431
- *
- */
-struct devices supported_devices[SUPPORTED_DEVICES] = {
-  { "FFFF", 0x000, 0x0000, 0x0000 },  // dummy
-  { "unkn", 0x421, 0x3f00, 0x0000 },  // probably a development board
-  { "n770", 0x421, 0x0105, 0x0001 },  // my n770 
-  { "n800", 0x421, 0x04c3, 0x0001 },  // a n800 
-  { 0 },
-  { 0 }
-};
-
-/** Returns 0 when no device was found and a positive
-  * non-zero value when one was found.
-  *
-  * The return value is the index into the supported_devices
-  * array which denotes the device which was found.
-  */
-int is_valid_device(struct usb_device_descriptor *udd)
-{
-	int i;
-	struct devices ptr = supported_devices[1];
-
-	for(i=1 ; ptr.vendor_id; ptr = supported_devices[++i])
-		if ((udd->idVendor  == ptr.vendor_id)
-		&&  (udd->idProduct == ptr.product_id)) {
-                        D printf("found %s\n", supported_devices[i]);
-			return i;
-		}
-
-	return 0;
-}
-
-/*
- * List all supported device-ids and it's names
- *
- */
-void list_valid_devices()
-{
-	int i;
-	struct devices ptr = supported_devices[1];
-
-	for(i=1; ptr.vendor_id; ptr = supported_devices[++i])
-		printf("%04x:%04x  %s\n", ptr.vendor_id, ptr.product_id, ptr.name);
-}
-
-/*
- * Returns true (1) when a valid usb device is found and stores the udd and devices
- *   structures for the specified device.
- * Otherwise returns false (0)
- */
-
-int usb_device_found(struct usb_device_descriptor *udd, struct devices *it_device)
-{
-	struct usb_bus *bus;
-        int dev_index = 0;
-
-	if (usb_find_busses() < 0) {
-		fprintf(stderr, "\nerror: no usb busses found.\n");
-		exit(1);
-	} else {
-		switch(usb_find_devices()) {
-		case -1:
-			fprintf(stderr, "\nerror: no devices found.\n");
-			exit(1);
-		default:
-			for (bus = usb_busses; bus; bus = bus->next) {
-				struct usb_device *dev = bus->devices;
-				D printf("bus: \n");
-				for (; dev; dev = dev->next) { 
-					*udd = dev->descriptor;
-					D printf(" dev (%s) - ", dev->filename);
-					D printf("vendor: %04x product: %04x\n", udd->idVendor, udd->idProduct);
-
-					if ((dev_index = is_valid_device(udd))) {
-						device = dev;
-                                                *it_device = supported_devices[dev_index];
-						return 1;
-					}
-				}
-			}
-		}
-	}
-
-	return 0;
-}

src/disk.c

@@ -0,0 +1,188 @@
+/*
+    0xFFFF - Open Free Fiasco Firmware Flasher
+    Copyright (C) 2012  Pali Rohár <pali.rohar@gmail.com>
+
+    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 3 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, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <fcntl.h>
+#include <libgen.h>
+
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <sys/ioctl.h>
+#include <sys/statvfs.h>
+
+#include <linux/fs.h>
+
+#include "disk.h"
+#include "global.h"
+#include "image.h"
+#include "device.h"
+#include "usb-device.h"
+#include "printf-utils.h"
+
+static char global_buf[1 << 22]; /* 4MB */
+
+int disk_init(struct usb_device_info * dev) {
+
+	ERROR("RAW mode is not implemented yet");
+	(void)dev;
+	return -1;
+
+}
+
+enum device disk_get_device(struct usb_device_info * dev) {
+
+	ERROR("Not implemented yet");
+	(void)dev;
+	return DEVICE_UNKNOWN;
+
+}
+
+int disk_flash_raw(const char * blkdev, const char * file) {
+
+	ERROR("Not implemented yet");
+	(void)blkdev;
+	(void)file;
+	return -1;
+
+}
+
+int disk_flash_image(struct usb_device_info * dev, struct image * image) {
+
+	ERROR("Not implemented yet");
+	(void)dev;
+	(void)image;
+	return -1;
+
+}
+
+int disk_dump_raw(const char * blkdev, const char * file) {
+
+	int fd1, fd2;
+	int ret;
+	char * path;
+	uint64_t blksize;
+	size_t need, readed;
+	ssize_t size;
+	struct stat st;
+	struct statvfs buf;
+
+	printf("Dump block device %s to file %s...\n", blkdev, file);
+
+	if ( stat(blkdev, &st) != 0 ) {
+		ERROR_INFO("Cannot stat block device %s", blkdev);
+		return -1;
+	}
+
+	if ( ! S_ISBLK(st.st_mode) ) {
+		ERROR("Invalid block device %s", blkdev);
+		return -1;
+	}
+
+	fd1 = open(blkdev, O_RDONLY);
+
+	if ( fd1 < 0 ) {
+		ERROR_INFO("Cannot open block device %s", blkdev);
+		return -1;
+	}
+
+	if ( ioctl(fd1, BLKGETSIZE64, &blksize) != 0 ) {
+		ERROR_INFO("Cannot get size of block device %s", blkdev);
+		close(fd1);
+		return -1;
+	}
+
+	if ( blksize > ULLONG_MAX ) {
+		ERROR("Block device %s is too big", blkdev);
+		close(fd1);
+		return -1;
+	}
+
+	if ( blksize == 0 ) {
+		ERROR("Block device %s has zero size", blkdev);
+		close(fd1);
+		return -1;
+	}
+
+	path = strdup(file);
+	if ( ! path ) {
+		ALLOC_ERROR();
+		close(fd1);
+		return -1;
+	}
+
+	ret = statvfs(dirname(path), &buf);
+
+	free(path);
+
+	if ( ret == 0 && buf.f_bsize * buf.f_bfree < blksize ) {
+		ERROR("Not enought free space (have: %llu, need: %llu)", (unsigned long long int)(buf.f_bsize) * buf.f_bfree, (unsigned long long int)blksize);
+		close(fd1);
+		return -1;
+	}
+
+	fd2 = creat(file, S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH);
+
+	if ( fd2 < 0 ) {
+		ERROR_INFO("Cannot create file %s", file);
+		close(fd1);
+		return -1;
+	}
+
+	readed = 0;
+	printf_progressbar(0, blksize);
+
+	while ( readed < blksize ) {
+		need = blksize - readed;
+		if ( need > sizeof(global_buf) )
+			need = sizeof(global_buf);
+		size = read(fd1, global_buf, need);
+		if ( size == 0 )
+			break;
+		if ( write(fd2, global_buf, size) != size ) {
+			PRINTF_ERROR("Dumping image failed");
+			close(fd1);
+			close(fd2);
+			return -1;
+		}
+		readed += size;
+		printf_progressbar(readed, blksize);
+	}
+
+	close(fd1);
+	close(fd2);
+	return 0;
+
+}
+
+int disk_dump_image(struct usb_device_info * dev, enum image_type image, const char * file) {
+
+	ERROR("Not implemented yet");
+	(void)dev;
+	(void)image;
+	(void)file;
+	return -1;
+
+}
+
+int disk_check_badblocks(struct usb_device_info * dev, const char * device) {
+
+	ERROR("Not implemented yet");
+	(void)dev;
+	(void)device;
+	return -1;
+
+}

src/disk.h

@@ -0,0 +1,37 @@
+/*
+    0xFFFF - Open Free Fiasco Firmware Flasher
+    Copyright (C) 2012  Pali Rohár <pali.rohar@gmail.com>
+
+    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 3 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, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef DISK_H
+#define DISK_H
+
+#include "image.h"
+#include "device.h"
+#include "usb-device.h"
+
+int disk_init(struct usb_device_info * dev);
+
+enum device disk_get_device(struct usb_device_info * dev);
+
+int disk_flash_raw(const char * blkdev, const char * file);
+int disk_dump_raw(const char * blkdev, const char * file);
+
+int disk_flash_image(struct usb_device_info * dev, struct image * image);
+int disk_dump_image(struct usb_device_info * dev, enum image_type image, const char * file);
+int disk_check_badblocks(struct usb_device_info * dev, const char * device);
+
+#endif

src/dump.c

@@ -1,580 +0,0 @@
-/*
- *  0xFFFF - Open Free Fiasco Firmware Flasher
- *  Copyright (C) 2007  pancake <pancake@youterm.com>
- *
- *  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 3 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, see <http://www.gnu.org/licenses/>.
- */
-
-#include "main.h"
-#include "hexdump.h"
-#include <usb.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-
-/*
- * Extracts a piece from an mtd device
- * -----------------------------------
- * This function is known to be buggy, It does not takes care about
- * badblocks and oob data. It is replaced by nanddump(), but will
- * probably be fixed in the future or it will die.
- */
-int rf_extract(char *dev, off_t from, off_t to, char *file)
-{
-	off_t i, blk = 0xfffff;
-	char buf[0xfffff];
-	FILE *fs = fopen(dev, "rb");
-	FILE *fd = fopen(file, "wb+");
-
-	if (from>to) {
-		printf("Bad range %lld - %lld for %s\n", from, to, file);
-		goto __rf_extract_exit;
-	}
-	if (fs == NULL) { perror(dev);  goto __rf_extract_exit; }
-	if (fd == NULL) { perror(file); goto __rf_extract_exit; }
-
-	printf("Extracting %s...\n", file);
-	fseek(fs, from, SEEK_SET);
-
-	for(i=from;i<to;i+=blk) {
-		int ret;
-		if (i+blk>to) blk = to-i;
-		ret = fread(buf, blk, 1, fs);
-		progressbar(i, to);
-		if (!ret || feof(fs)) break;
-		fwrite(buf, blk, 1, fd);
-	}
-
-	printf("\r%s: %lld bytes dumped from %s\n",
-		file, to-from, dev);
-
-__rf_extract_exit:
-	if (fs) fclose(fs);
-	if (fd) fclose(fd);
-
-	return 1;
-}
-
-/*
- * This function was covardly copied from nanddump.c @ mtd-utils-20060907
- */
-#define _GNU_SOURCE
-#include <ctype.h>
-#include <errno.h>
-#include <fcntl.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include <unistd.h>
-#include <getopt.h>
-#include <sys/ioctl.h>
-#include <sys/types.h>
-#include <sys/stat.h>
-#include <asm/types.h>
-#include <mtd/mtd-user.h>
-
-#define M_RDONLY   0x00000001
-#define M_RDRW     0x00000002
-#define M_OMITOOB  0x00000010
-#define M_OMITBAD  0x00000011
-#define M_OMITECC  0x00000012
-
-int mtd_open(char *file, mtd_info_t *meminfo, int *oobinfochanged, 
-	struct nand_oobinfo *old_oobinfo, int *eccstats, int flags)
-{
-	int fd;
-	*oobinfochanged = 0 ;
-	
-	fd = open(file, (flags&M_RDONLY)?O_RDONLY:O_RDWR);
-	if (fd == -1) {
-		perror("mtd_open");
-		return -1;
-	}
-	/* Fill in MTD device capability structure */
-	if (ioctl(fd, MEMGETINFO, meminfo) != 0) {
-		perror("MEMGETINFO");
-		close(fd);
-		return 1;
-	}
-
-	/* Make sure device page sizes are valid */
-	if (!(meminfo->oobsize == 64 && meminfo->writesize == 2048) &&
-	    !(meminfo->oobsize == 16 && meminfo->writesize == 512) &&
-	    !(meminfo->oobsize == 8  && meminfo->writesize == 256)) {
-		fprintf(stderr, "Unknown flash (not normal NAND)\n");
-		close(fd);
-		return -1;
-	}
-
-	return fd;
-}
-
-int mtd_close(int fd, struct nand_oobinfo *old_oobinfo, int oobinfochanged)
-{
-	if (fd == -1)
-		return 1;
-
-	/* reset oobinfo */
-	if (oobinfochanged == 1) {
-		if (ioctl (fd, MEMSETOOBSEL, &old_oobinfo) != 0) {
-			perror ("MEMSETOOBSEL");
-			close(fd);
-			return 1;
-		}
-	}
-	/* Close the output file and MTD device */
-	return close(fd);
-}
-
-// configuration for nanddump //
-//int	noecc = 0;		// don't error correct
-int	omitoob = 1;		// omit oob data
-int	omitbad = 1;
-// configuration for nanddump //
-
-#define CONFIGURE_FLAGS(x) \
-omitoob = x & M_OMITOOB; \
-omitbad = x & M_OMITBAD;
-
-int check_badblocks(char *mtddev)
-{
-	int fd;
-	int oobinfochanged = 0 ;
-	int badblock = 0;
-	int badblocks = 1;
-	int eccstats = 0;
-	unsigned long int i;
-	unsigned long long blockstart = 1;
-	unsigned char oobbuf[64];
-	struct nand_oobinfo old_oobinfo;
-	struct mtd_oob_buf oob = {0, 16, oobbuf};
-	struct mtd_ecc_stats stat1, stat2;
-	mtd_info_t meminfo;
-
-	fd = mtd_open(mtddev, &meminfo, &oobinfochanged, &old_oobinfo, &eccstats, M_RDONLY);
-
-	if (fd == -1) {
-		printf("cannot open mtd\n");
-		return 1;
-	}
-
-        fprintf(stderr, "Block size %u, page size %u, OOB size %u\n",
-                meminfo.erasesize, meminfo.writesize, meminfo.oobsize);
-        fprintf(stderr, "Size %u, flags %u, type 0x%x\n",
-                meminfo.size, meminfo.flags, (int)meminfo.type);
-
-
-	oob.length = meminfo.oobsize;
-	for(i = 0; i < meminfo.size; i+= meminfo.writesize) {
-
-		// new eraseblock , check for bad block
-		if (blockstart != (i & (~meminfo.erasesize + 1))) {
-			blockstart = i & (~meminfo.erasesize + 1);
-			if ((badblock = ioctl(fd, MEMGETBADBLOCK, &blockstart)) < 0) {
-				perror("ioctl(MEMGETBADBLOCK)");
-				goto closeall;
-			}
-		}
-
-		if (badblock) {
-			if (omitbad) {
-				printf("Bad block found at 0x%lx\n", i);
-				continue;
-			}
-		} else {
-			char readbuf[2048]; // XXX hardcoded like mtd-utils?? ugly!
-			// dummy -- should be removed
-			if (pread(fd, readbuf, meminfo.writesize, i) != meminfo.writesize) {
-				perror("pread");
-				goto closeall;
-			}
-		}
-
-		/* ECC stats available ? */
-		if (eccstats) {
-			if (ioctl(fd, ECCGETSTATS, &stat2)) {
-				perror("ioctl(ECCGETSTATS)");
-				goto closeall;
-			}
-			if (stat1.failed != stat2.failed)
-				fprintf(stderr, "ECC: %d uncorrectable bitflip(s)"
-					" at offset 0x%08lx\n",
-					stat2.failed - stat1.failed, i);
-			if (stat1.corrected != stat2.corrected)
-				fprintf(stderr, "ECC: %d corrected bitflip(s) at"
-					" offset 0x%08lx\n",
-					stat2.corrected - stat1.corrected, i);
-			stat1 = stat2;
-		}
-
-		if (badblock) {
-			printf("Oops badblock %d at 0x%lx !\n", badblocks++, i);
-		} else {
-			/* Read OOB data and exit on failure */
-			oob.start = i;
-			if (ioctl(fd, MEMREADOOB, &oob) != 0) {
-				perror("ioctl(MEMREADOOB)");
-				goto closeall;
-			}
-		}
-
-		/* Write out OOB data */
-		if (badblock)
-		D dump_bytes(oobbuf, meminfo.oobsize);
-	}
-
-	mtd_close(fd, &old_oobinfo, oobinfochanged);
-	return 0;
-
-closeall:
-	mtd_close(fd, &old_oobinfo, oobinfochanged);
-	return 1;
-}
-
-int nanddump(char *mtddev, unsigned long start_addr, unsigned long length, char *dumpfile, int isbl)
-{
-	unsigned char readbuf[2048];
-	int oobinfochanged = 0 ;
-	unsigned char oobbuf[64];
-	unsigned long ofs, end_addr = 0;
-	unsigned long long blockstart = 1;
-	struct nand_oobinfo none_oobinfo = {
-		.useecc = MTD_NANDECC_OFF,
-	};
-	int fd, ofd, bs, badblock = 0;
-	struct mtd_oob_buf oob = {0, 16, oobbuf};
-	mtd_info_t meminfo;
-	int badblocks = 1;
-	struct nand_oobinfo old_oobinfo;
-	int eccstats = 0;
-	struct mtd_ecc_stats stat1, stat2;
-	int flags = M_RDONLY;
-
-	printf("\nExtracting %s from %s...\n", dumpfile, mtddev);
-
-	fd = mtd_open(mtddev, &meminfo, &oobinfochanged, &old_oobinfo, &eccstats, flags);
-
-	if (meminfo.writesize == 0) {
-		printf("What the fuck.. this is not an MTD device!\n");
-		close(fd);
-		return 1;
-	}
-
-	/* Read the real oob length */
-	oob.length = meminfo.oobsize;
-        fprintf(stderr, "Block size %u, page size %u, OOB size %u\n",
-                meminfo.erasesize, meminfo.writesize, meminfo.oobsize);
-        fprintf(stderr, "Size %u, flags %u, type 0x%x\n",
-                meminfo.size, meminfo.flags, (int)meminfo.type);
-
-	if (flags & M_OMITECC)  { // (noecc)
-		switch (ioctl(fd, MTDFILEMODE, (void *) MTD_MODE_RAW)) {
-		case -ENOTTY:
-			if (ioctl (fd, MEMGETOOBSEL, old_oobinfo) != 0) {
-				perror ("MEMGETOOBSEL");
-				close (fd);
-				exit (1);
-			}
-			if (ioctl (fd, MEMSETOOBSEL, none_oobinfo) != 0) {
-				perror ("MEMSETOOBSEL");
-				close (fd);
-				exit (1);
-			}
-			oobinfochanged = 1;
-			break;
-
-		case 0:
-			oobinfochanged = 2;
-			break;
-		default:
-			perror ("MTDFILEMODE");
-			close (fd);
-			return 1;
-		}
-	} else {
-		/* check if we can read ecc stats */
-		if (!ioctl(fd, ECCGETSTATS, &stat1)) {
-			eccstats = 1;
-			fprintf(stderr, "ECC failed: %d\n", stat1.failed);
-			fprintf(stderr, "ECC corrected: %d\n", stat1.corrected);    
-			fprintf(stderr, "Number of bad blocks: %d\n", stat1.badblocks);    
-			fprintf(stderr, "Number of bbt blocks: %d\n", stat1.bbtblocks);    
-		} else
-			perror("No ECC status information available");
-	}
-
-	/* Open output file for writing. If file name is "-", write to standard
-	 * output. */
-	if (!dumpfile) {
-		ofd = STDOUT_FILENO;
-	} else if ((ofd = open(dumpfile, O_WRONLY | O_TRUNC | O_CREAT, 0644))== -1) {
-		perror ("open outfile");
-		close(fd);
-		return 1;
-	}
-
-	/* Initialize start/end addresses and block size */
-	if (length)
-		end_addr = start_addr + length;
-	if (!length || end_addr > meminfo.size)
-		end_addr = meminfo.size;
-
-	bs = meminfo.writesize;
-
-	fprintf(stderr,
-		"Dumping data starting at 0x%08x and ending at 0x%08x...\n",
-		(unsigned int) start_addr, (unsigned int) end_addr);
-
-	/* Dump the flash contents */
-	for (ofs = start_addr; ofs < end_addr ; ofs+=bs) {
-		// new eraseblock , check for bad block
-		if (blockstart != (ofs & (~meminfo.erasesize + 1))) {
-			blockstart = ofs & (~meminfo.erasesize + 1);
-			if ((badblock = ioctl(fd, MEMGETBADBLOCK, &blockstart)) < 0) {
-				perror("ioctl(MEMGETBADBLOCK)");
-				goto closeall;
-			}
-		}
-
-		if (!isbl && badblock) {
-			if (omitbad)
-				continue;
-			memset (readbuf, 0xff, bs);
-		} else {
-			/* Read page data and exit on failure */
-			if (pread(fd, readbuf, bs, ofs) != bs) {
-				perror("pread");
-				goto closeall;
-			}
-		}
-
-		// TODO exist on n800??? // remove code?
-		/* ECC stats available ? */
-		if (eccstats) {
-			if (ioctl(fd, ECCGETSTATS, &stat2)) {
-				perror("ioctl(ECCGETSTATS)");
-				goto closeall;
-			}
-			if (stat1.failed != stat2.failed)
-				fprintf(stderr, "ECC: %d uncorrectable bitflip(s)"
-					" at offset 0x%08lx\n",
-					stat2.failed - stat1.failed, ofs);
-			if (stat1.corrected != stat2.corrected)
-				fprintf(stderr, "ECC: %d corrected bitflip(s) at"
-					" offset 0x%08lx\n",
-					stat2.corrected - stat1.corrected, ofs);
-			stat1 = stat2;
-		}
-
-		/* Write out page data */
-		//if (pretty_print) dump_bytes(readbuf, bs);
-		progressbar(ofs, end_addr);
-
-		// OOB STUFF //
-		if (omitoob)
-			continue;
-
-		if (!isbl&&badblock) {
-			printf("Oops badblock %d *ignored* at 0x%lx !\n", badblocks++, ofs);
-			memset (readbuf, 0xff, meminfo.oobsize);
-		} else {
-			/* Read OOB data and exit on failure */
-			oob.start = ofs;
-			if (ioctl(fd, MEMREADOOB, &oob) != 0) {
-				perror("ioctl(MEMREADOOB)");
-				goto closeall;
-			}
-		}
-
-		/* Write out OOB data */
-		D dump_bytes(oobbuf, meminfo.oobsize);
-		write(ofd, oobbuf, meminfo.oobsize);
-	}
-
-	mtd_close(fd, &old_oobinfo, oobinfochanged);
-	close(ofd);
-
-	return 0;
-
- closeall:
-	mtd_close(fd, &old_oobinfo, oobinfochanged);
-	close(ofd);
-	return 1;
-}
-
-int rf_strip(char *file)
-{
-	FILE *fd = fopen(file, "rw");
-	unsigned char buf[4096];
-	int ret;
-	off_t eof = 0;
-
-	if (!fd) {
-		fprintf(stderr, "Weird! can't open %s???\n", file);
-		exit(0);
-	}
-	printf("Stripping padding from %s... ", file);
-	fflush(stdout);
-	fseek(fd, 0, SEEK_END);
-	if (ftell(fd)>4096) {
-		do {
-			fseek(fd, -4096, SEEK_CUR);
-			ret = fread(buf, 1, 4096, fd);
-			fseek(fd, -4096, SEEK_CUR);
-			for(ret--;ret>0;ret--)
-				if (buf[ret]!=0xff) {
-					fseek(fd, ret+1, SEEK_CUR);
-					eof = ftell(fd);
-					goto __done;
-				}
-		} while(1);
-	}
-
-__done:
-	fclose(fd);
-	if (eof) truncate(file, eof);
-	printf("done at %d\n", (int)eof);
-
-	return 1;
-}
-
-int is_n800()
-{
-	int n800 = 0;
-	unsigned char buf[4];
-	FILE *fd = fopen("/dev/mtd0", "rb");
-
-	if (!fd) {
-		fprintf(stderr, "Cannot open /dev/mtd0.\n");
-		exit(1);
-	}
-	fread(buf, 4, 1,fd);
-	if (!memcmp("\xff\xff\xff\xff", buf, 4))
-		n800 = 1;
-	
-	fclose(fd);
-
-	return n800;
-}
-
-int dump_config()
-{
-	mtd_info_t meminfo;
-	int fd = open("/dev/mtd1", O_RDONLY);
-	char buf[1024];
-	int i=0,j;
-	int ret;
-
-
-	if (fd == -1) {
-		perror("open /dev/mtd1");
-		return 1;
-	}
-	if (ioctl(fd, MEMGETINFO, &meminfo) != 0) {
-		perror("MEMGETINFO");
-		close(fd);
-		return 1;
-	}
-
-	while(i<0x60000) {
-	iniloop:
-		ret = read(fd, buf, 4);
-		if (ret == -1)
-			break;
-		if (!memcmp(buf,"ConF", 4)) {
-		loop:
-			read(fd, buf, 4);
-			if (ret == -1) break;
-			printf("\n0x%08x : ConF %02x %02x %02x %02x : ", i,
-				buf[0], buf[1], buf[2], buf[3]);
-			fflush(stdout);
-			while(1) {
-				ret = read(fd, buf, 4);
-				if (ret <1) {
-					printf("Unexpected eof\n");
-					break;
-				}
-				if (buf[0]=='\0'||buf[1]=='\0'||buf[2]=='\0'||buf[3]=='\0') {
-					printf("%s  \t  ", buf);
-					fflush(stdout);
-					while(1) {
-						ret = read(fd, buf, 4);
-						if (ret <1) {
-							printf("Unexpected eof\n");
-							break;
-						}
-						if (!memcmp(buf,"\xff\xff\xff\xff", 4))
-							goto iniloop;
-						if (!memcmp(buf,"ConF", 4))
-							goto loop;
-						printf ("%02x %02x %02x %02x ",
-							buf[0], buf[1], buf[2], buf[3]);
-					}
-					break;
-				} else {
-					write(1, buf,4);
-				}
-			}
-		}
-		j = lseek(fd, 0, SEEK_CUR);
-		if (j==i) break; i = j;
-	}
-	close(fd);
-	printf("\n");
-	return 0;
-}
-
-int reverse_extract_pieces(char *dir)
-{
-	char reply;
-	chdir(dir);
-
-	// TODO: get values from /proc/mtd ???
-
-	//rf_extract("/dev/mtd0", is_n800()?0x200:0, 0x003600, "xloader.bin");
-	nanddump("/dev/mtd0", is_n800()?0x200:0, 0x4000, "xloader.bin", 1); // 0x3600 size?
-	//rf_extract("/dev/mtd0", 0x004000, 0x01ffff,  "secondary.bin");
-	nanddump("/dev/mtd0", 0x004000, 0,  "secondary.bin", 1);
-	nanddump("/dev/mtd1", 0, 0,  "config.bin", 0);
-	//rf_extract("/dev/mtd2", 0x000800, 0x200000,  "zImage");
-	nanddump("/dev/mtd2", 0x000800, 0,  "zImage", 0);
-	//rf_extract("/dev/mtd3", 0x000000, 0x1D00000, "initfs.jffs2");
-	nanddump("/dev/mtd3", 0x000000, 0, "initfs.jffs2", 0);
-
-	printf("\n\nExtract rootfs? (y/N): "); fflush(stdout);
-	read(0, &reply, 1);
-	if (reply=='y'||reply=='Y') {
-		//rf_extract("/dev/mtd4", 0x000000, 0x6000000, "rootfs.jffs2");
-		nanddump("/dev/mtd4", 0x000000, 0, "rootfs.jffs2", 0);
-	} else	printf("*** Ignoring rootfs\n");
-
-	printf("\n\nStrip dumped files? (y/N): "); fflush(stdout);
-	read(0, &reply, 1);
-	if (reply=='y'||reply=='Y') {
-		rf_strip("xloader.bin");
-		rf_strip("secondary.bin");
-		rf_strip("zImage");
-		rf_strip("initfs.jffs2");
-	} else  printf("*** Ignoring strip\n");
-
-	printf("\nIdentifying extracted files...\n");
-	printf("%s: xloader\n", fpid_file("xloader.bin"));
-	printf("%s: secondary.bin\n", fpid_file("secondary.bin"));
-	printf("%s: config.bin\n", fpid_file("config.bin"));
-	printf("%s: zImage\n", fpid_file("zImage"));
-	printf("%s: initfs.jffs2\n", fpid_file("initfs.jffs2"));
-	printf("%s: rootfs.jffs2\n", fpid_file("rootfs.jffs2"));
-
-	return 1;
-}

src/fiasco.c

@@ -1,293 +1,572 @@
 /*
- *  0xFFFF - Open Free Fiasco Firmware Flasher
- *  Copyright (C) 2007  pancake <pancake@youterm.com>
- *
- *  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 3 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, see <http://www.gnu.org/licenses/>.
- */
+    0xFFFF - Open Free Fiasco Firmware Flasher
+    Copyright (C) 2007-2011  pancake <pancake@youterm.com>
+    Copyright (C) 2011-2012  Pali Rohár <pali.rohar@gmail.com>
+
+    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 3 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, see <http://www.gnu.org/licenses/>.
+
+*/
 
 #include <stdio.h>
-#include <string.h>
 #include <stdlib.h>
-#include <fcntl.h>
-#include <unistd.h>
+#include <string.h>
+
 #include <sys/types.h>
 #include <sys/stat.h>
 #include <arpa/inet.h>
-#include "main.h"
-#include "hash.h"
+#include <fcntl.h>
+#include <unistd.h>
 
-void (*fiasco_callback)(struct header_t *header) = NULL;
+#include "global.h"
 
-int openfiasco(char *name)
-{
-	struct header_t header;
-	unsigned char buf[128];
-	unsigned char data[128];
-	unsigned int namelen;
-	off_t off;
-	int i;
-	header.fd = open(name, O_RDONLY);
+#include "device.h"
+#include "image.h"
+#include "fiasco.h"
 
-	if (header.fd == -1) {
-		fprintf(stderr, "Cannot open %s\n", name);
-		return 1;
+#define FIASCO_READ_ERROR(fiasco, ...) do { ERROR_INFO(__VA_ARGS__); fiasco_free(fiasco); return NULL; } while (0)
+#define FIASCO_WRITE_ERROR(file, fd, ...) do { ERROR_INFO_STR(file, __VA_ARGS__); if ( fd >= 0 ) close(fd); return -1; } while (0)
+#define READ_OR_FAIL(fiasco, buf, size) do { if ( read(fiasco->fd, buf, size) != size ) { FIASCO_READ_ERROR(fiasco, "Cannot read %d bytes", size); } } while (0)
+#define READ_OR_RETURN(fiasco, buf, size) do { if ( read(fiasco->fd, buf, size) != size ) return fiasco; } while (0)
+#define WRITE_OR_FAIL(file, fd, buf, size) do { if ( ! simulate ) { if ( write(fd, buf, size) != (ssize_t)size ) { FIASCO_WRITE_ERROR(file, fd, "Cannot write %d bytes", size); } } } while (0)
+
+struct fiasco * fiasco_alloc_empty(void) {
+
+	struct fiasco * fiasco = calloc(1, sizeof(struct fiasco));
+	if ( ! fiasco )
+		ALLOC_ERROR_RETURN(NULL);
+
+	fiasco->fd = -1;
+	return fiasco;
+
+}
+
+struct fiasco * fiasco_alloc_from_file(const char * file) {
+
+	uint8_t byte;
+	uint32_t length;
+	uint32_t count;
+	uint8_t length8;
+	uint8_t count8;
+
+	char type[13];
+	char device[17];
+	char hwrevs[1024];
+	char version[257];
+	char layout[257];
+	uint16_t hash;
+	off_t offset;
+	struct image * image;
+
+	char hwrev[9];
+	unsigned char buf[512];
+	unsigned char *pbuf;
+
+	struct fiasco * fiasco = fiasco_alloc_empty();
+	if ( ! fiasco )
+		return NULL;
+
+	fiasco->fd = open(file, O_RDONLY);
+	if ( fiasco->fd < 0 ) {
+		ERROR_INFO("Cannot open file");
+		fiasco_free(fiasco);
+		return NULL;
 	}
 
-	/* read header */
-	read(header.fd, buf, 5);
-	if (buf[0] != 0xb4) {
-		printf("Invalid header\n");
-		return close(header.fd);
-	}
-	memcpy(&namelen,buf+1,4);
-	namelen = ntohl(namelen);
-	if (namelen>128) {
-		printf("Stupid length at header. Is this a joke?\n");
-		return close(header.fd);
-	}
-	memset(buf,'\0', 128);
-	read(header.fd, buf, namelen);
+	fiasco->orig_filename = strdup(file);
 
-	printf("Fiasco version: %2d\n", buf[3]);
-	strcpy(header.fwname, buf+6);
-	for(i=6;i<namelen;i+=strlen(buf+i)+1)
-		printf("Name: %s\n", buf+i);
+	READ_OR_FAIL(fiasco, &byte, 1);
+	if ( byte != 0xb4 )
+		FIASCO_READ_ERROR(fiasco, "Invalid fiasco signature");
+
+	READ_OR_FAIL(fiasco, &length, 4);
+	length = ntohl(length);
+
+	READ_OR_FAIL(fiasco, &count, 4);
+	count = ntohl(count);
+
+	VERBOSE("Number of header blocks: %d\n", count);
+
+	while ( count > 0 ) {
+		READ_OR_FAIL(fiasco, &byte, 1);
+		READ_OR_FAIL(fiasco, &length8, 1);
+		READ_OR_FAIL(fiasco, buf, length8);
+		if ( byte == 0xe8 ) {
+			memset(fiasco->name, 0, sizeof(fiasco->name));
+			strncpy(fiasco->name, (char *)buf, length8);
+			VERBOSE("Fiasco name: %s\n", fiasco->name);
+		} else if ( byte == 0x31 ) {
+			memset(fiasco->swver, 0, sizeof(fiasco->swver));
+			strncpy(fiasco->swver, (char *)buf, length8);
+			VERBOSE("SW version: %s\n", fiasco->swver);
+		} else {
+			VERBOSE("Unknown header %#x\n", byte);
+		}
+		--count;
+	}
 
 	/* walk the tree */
-	while(1) {
-		if (read(header.fd, buf, 9)<9)
-			break;
+	while ( 1 ) {
 
-		if (buf[0] != 0x54) { // 'T'
-			printf("unexpected header at 0x%x, found %02x %02x %02x\n", 
-				((int)lseek(header.fd, 0, SEEK_CUR))-9,
-				buf[0], buf[1], buf[2]);
-			break;
+		/* If end of file, return fiasco image */
+		READ_OR_RETURN(fiasco, buf, 7);
+
+		/* Header of next image */
+		if ( ! buf[0] == 0x54 && buf[2] == 0x2E && buf[3] == 0x19 && buf[4] == 0x01 && buf[5] == 0x01 && buf[6] == 0x00 ) {
+			ERROR("Invalid next image header");
+			return fiasco;
 		}
-		header.hash = buf[7]<<8|buf[8];
 
-		/* piece name */
-		memset(data, '\0', 13);
-		if (read(header.fd, data, 12)<12)
-			break;
+		count8 = buf[1];
+		if ( count8 > 0 )
+			--count8;
 
-		if (data[0] == 0xff) {
-			printf(" [eof]\n");
-			break;
-		} else printf(" %s\n", data);
-		strcpy(header.name, data);
+		READ_OR_RETURN(fiasco, &hash, 2);
+		hash = ntohs(hash);
 
-		if (read(header.fd, buf, 9)<9)
-			break;
-		memcpy(&header.size, buf,4);
-		header.size = ntohl(header.size);
-		printf("   size:    %d bytes\n", header.size);
-		printf("   hash:    %04x\n", header.hash);
-		//printf("BYTE: %02x %02x %02x %02x %02x\n", 
-		//	buf[4], buf[5], buf[6], buf[7], buf[8]);
-		/* XXX this is not ok */
-		//printf("BUF8: %02x\n", buf[8]);
-		while (buf[8] && buf[8]>'0' && buf[8] < '9') {
-			if (read(header.fd, data, 1)<1)
-				break;
-			i = data[0];
-			if (read(header.fd, data, i)<i)
-				break;
-			if (data[0])
-			printf("   version: %s\n", data);
-			strcpy(header.version, data);
-			if (read(header.fd, buf+8, 1)<1)
-				break;
+		memset(type, 0, sizeof(type));
+		READ_OR_RETURN(fiasco, type, 12);
+
+		byte = type[0];
+		if ( byte == 0xFF )
+			return fiasco;
+
+		VERBOSE(" %s\n", type);
+
+		READ_OR_RETURN(fiasco, &length, 4);
+		length = ntohl(length);
+
+		/* unknown */
+		READ_OR_RETURN(fiasco, buf, 4);
+
+		VERBOSE("   size:    %d bytes\n", length);
+		VERBOSE("   hash:    %#04x\n", hash);
+		VERBOSE("   subsections: %d\n", count8);
+
+		memset(device, 0, sizeof(device));
+		memset(hwrevs, 0, sizeof(hwrevs));
+		memset(version, 0, sizeof(version));
+		memset(layout, 0, sizeof(layout));
+
+		while ( count8 > 0 ) {
+
+			READ_OR_RETURN(fiasco, &byte, 1);
+			READ_OR_RETURN(fiasco, &length8, 1);
+			READ_OR_RETURN(fiasco, buf, length8);
+
+			VERBOSE("   subinfo\n");
+			VERBOSE("     length: %d\n", length8);
+			VERBOSE("     type: ");
+
+			if ( byte == '1' ) {
+				memset(version, 0, sizeof(version));
+				strncpy(version, (char *)buf, length8);
+				VERBOSE("version string\n");
+				VERBOSE("       version: %s\n", version);
+			} else if ( byte == '2' ) {
+				int tmp = length8;
+				if ( tmp > 16 ) tmp = 16;
+				memset(device, 0, sizeof(device));
+				strncpy(device, (char *)buf, tmp);
+				VERBOSE("hw revision\n");
+				VERBOSE("       device: %s\n", device);
+				pbuf = buf + strlen(device) + 1;
+				while ( pbuf < buf + length8 ) {
+					while ( pbuf < buf + length8 && *pbuf < 32 )
+						++pbuf;
+					if ( pbuf >= buf + length8 ) break;
+					tmp = buf + length8 - pbuf;
+					if ( tmp > 8 ) tmp = 8;
+					memset(hwrev, 0, sizeof(hwrev));
+					strncpy(hwrev, (char *)pbuf, tmp);
+					if ( ! hwrevs[0] )
+						strcpy(hwrevs, hwrev);
+					else {
+						/* TODO: check if hwrevs has enought size */
+						strcat(hwrevs, ",");
+						strcat(hwrevs, hwrev);
+					}
+					VERBOSE("       hw revision: %s\n", hwrev);
+					pbuf += strlen(hwrev) + 1;
+				}
+			} else if ( byte == '3' ) {
+				memset(layout, 0, sizeof(layout));
+				strncpy(layout, (char *)buf, length8);
+				VERBOSE("layout\n");
+			} else {
+				VERBOSE("unknown ('%c':%#x)\n", byte, byte);
+			}
+
+			--count8;
 		}
-		/* callback */
-		off = lseek(header.fd, 0, SEEK_CUR);
-		if (fiasco_callback != NULL) {
-			fiasco_callback(&header);
-			free(header.data);
-			continue;
+
+		/* unknown */
+		READ_OR_RETURN(fiasco, buf, 1);
+
+		offset = lseek(fiasco->fd, 0, SEEK_CUR);
+
+		VERBOSE("   version: %s\n", version);
+		VERBOSE("   device: %s\n", device);
+		VERBOSE("   hwrevs: %s\n", hwrevs);
+		VERBOSE("   data at: %#08x\n", (unsigned int)offset);
+
+		image = image_alloc_from_shared_fd(fiasco->fd, length, offset, hash, type, device, hwrevs, version, layout);
+
+		if ( ! image )
+			FIASCO_READ_ERROR(fiasco, "Cannot allocate image");
+
+		fiasco_add_image(fiasco, image);
+
+		lseek(fiasco->fd, offset+length, SEEK_SET);
+
+	}
+
+	return fiasco;
+
+}
+
+void fiasco_free(struct fiasco * fiasco) {
+
+	struct image_list * list = fiasco->first;
+
+	while ( list ) {
+		struct image_list * next = list->next;
+		image_list_del(list);
+		list = next;
+	}
+
+	if ( fiasco->fd >= 0 )
+		close(fiasco->fd);
+
+	free(fiasco->orig_filename);
+
+	free(fiasco);
+
+}
+
+void fiasco_add_image(struct fiasco * fiasco, struct image * image) {
+
+	image_list_add(&fiasco->first, image);
+
+}
+
+int fiasco_write_to_file(struct fiasco * fiasco, const char * file) {
+
+	int fd = -1;
+	int i;
+	int device_count;
+	uint32_t size;
+	uint32_t length;
+	uint16_t hash;
+	uint8_t length8;
+	char ** device_hwrevs_bufs;
+	const char * str;
+	const char * type;
+	struct image_list * image_list;
+	struct image * image;
+	unsigned char buf[4096];
+
+	if ( ! fiasco )
+		return -1;
+
+	printf("Generating Fiasco image %s...\n", file);
+
+	if ( ! fiasco->first )
+		FIASCO_WRITE_ERROR(file, fd, "Nothing to write");
+
+	if ( fiasco->name && strlen(fiasco->name)+1 > UINT8_MAX )
+		FIASCO_WRITE_ERROR(file, fd, "Fiasco name string is too long");
+
+	if ( fiasco->swver && strlen(fiasco->swver)+1 > UINT8_MAX )
+		FIASCO_WRITE_ERROR(file, fd, "SW version string is too long");
+
+	if ( ! simulate ) {
+		fd = open(file, O_RDWR|O_CREAT|O_TRUNC, 0644);
+		if ( fd < 0 ) {
+			ERROR_INFO("Cannot create file");
+			return -1;
 		}
-		// XXX dup
-		lseek(header.fd, off, SEEK_SET);
-		lseek(header.fd, header.size, SEEK_CUR);
 	}
+
+	printf("Writing Fiasco header...\n");
+
+	WRITE_OR_FAIL(file, fd, "\xb4", 1); /* signature */
+
+	if ( fiasco->name[0] )
+		str = fiasco->name;
+	else
+		str = "OSSO UART+USB";
+
+	length = 4 + strlen(str) + 3;
+	if ( fiasco->swver[0] )
+		length += strlen(fiasco->swver) + 3;
+	length = htonl(length);
+	WRITE_OR_FAIL(file, fd, &length, 4); /* FW header length */
+
+	if ( fiasco->swver[0] )
+		length = htonl(2);
+	else
+		length = htonl(1);
+	WRITE_OR_FAIL(file, fd, &length, 4); /* FW header blocks count */
+
+	/* Fiasco name */
+	length8 = strlen(str)+1;
+	WRITE_OR_FAIL(file, fd, "\xe8", 1);
+	WRITE_OR_FAIL(file, fd, &length8, 1);
+	WRITE_OR_FAIL(file, fd, str, length8);
+
+	/* SW version */
+	if ( fiasco->swver[0] ) {
+		printf("Writing SW version: %s\n", fiasco->swver);
+		length8 = strlen(fiasco->swver)+1;
+		WRITE_OR_FAIL(file, fd, "\x31", 1);
+		WRITE_OR_FAIL(file, fd, &length8, 1);
+		WRITE_OR_FAIL(file, fd, fiasco->swver, length8);
+	};
+
+	printf("\n");
+
+	image_list = fiasco->first;
+
+	while ( image_list ) {
+
+		image = image_list->image;
+
+		if ( ! image )
+			FIASCO_WRITE_ERROR(file, fd, "Empty image");
+
+		printf("Writing image...\n");
+		image_print_info(image);
+
+		type = image_type_to_string(image->type);
+
+		device_hwrevs_bufs = device_list_alloc_to_bufs(image->devices);
+
+		device_count = 0;
+		if ( device_hwrevs_bufs && device_hwrevs_bufs[0] )
+			for ( ; device_hwrevs_bufs[device_count]; ++device_count );
+
+		if ( ! type )
+			FIASCO_WRITE_ERROR(file, fd, "Unknown image type");
+
+		if ( image->version && strlen(image->version) > UINT8_MAX )
+			FIASCO_WRITE_ERROR(file, fd, "Image version string is too long");
+
+		if ( image->layout && strlen(image->layout) > UINT8_MAX )
+			FIASCO_WRITE_ERROR(file, fd, "Image layout is too long");
+
+		printf("Writing image header...\n");
+
+		/* signature */
+		WRITE_OR_FAIL(file, fd, "T", 1);
+
+		/* number of subsections */
+		length8 = device_count+1;
+		if ( image->version )
+			++length8;
+		if ( image->layout )
+			++length8;
+		WRITE_OR_FAIL(file, fd, &length8, 1);
+
+		/* unknown */
+		WRITE_OR_FAIL(file, fd, "\x2e\x19\x01\x01\x00", 5);
+
+		/* checksum */
+		hash = htons(image->hash);
+		WRITE_OR_FAIL(file, fd, &hash, 2);
+
+		/* image type name */
+		memset(buf, 0, 12);
+		strncpy((char *)buf, type, 12);
+		WRITE_OR_FAIL(file, fd, buf, 12);
+
+		/* image size */
+		size = htonl(image->size);
+		WRITE_OR_FAIL(file, fd, &size, 4);
+
+		/* unknown */
+		WRITE_OR_FAIL(file, fd, "\x00\x00\x00\x00", 4);
+
+		/* append version subsection */
+		if ( image->version ) {
+			WRITE_OR_FAIL(file, fd, "1", 1); /* 1 - version */
+			length8 = strlen(image->version)+1;
+			WRITE_OR_FAIL(file, fd, &length8, 1);
+			WRITE_OR_FAIL(file, fd, image->version, length8);
+		}
+
+		/* append device & hwrevs subsection */
+		for ( i = 0; i < device_count; ++i ) {
+			WRITE_OR_FAIL(file, fd, "2", 1); /* 2 - device & hwrevs */
+			WRITE_OR_FAIL(file, fd, &device_hwrevs_bufs[i][0], 1);
+			WRITE_OR_FAIL(file, fd, device_hwrevs_bufs[i]+1, ((uint8_t *)(device_hwrevs_bufs[i]))[0]);
+		}
+		free(device_hwrevs_bufs);
+
+		/* append layout subsection */
+		if ( image->layout ) {
+			length8 = strlen(image->layout);
+			WRITE_OR_FAIL(file, fd, "3", 1); /* 3 - layout */
+			WRITE_OR_FAIL(file, fd, &length8, 1);
+			WRITE_OR_FAIL(file, fd, image->layout, length8);
+		}
+
+		/* dummy byte - end of all subsections */
+		WRITE_OR_FAIL(file, fd, "\x00", 1);
+
+		printf("Writing image data...\n");
+
+		image_seek(image, 0);
+		while ( 1 ) {
+			size = image_read(image, buf, sizeof(buf));
+			if ( size == 0 )
+				break;
+			WRITE_OR_FAIL(file, fd, buf, size);
+		}
+
+		image_list = image_list->next;
+
+		if ( image_list )
+			printf("\n");
+
+	}
+
+	close(fd);
+	printf("\nDone\n\n");
 	return 0;
+
 }
 
-void fiasco_data_read(struct header_t *header)
-{
-	header->data = (char *)malloc(header->size);
-	if (header->data == NULL) {
-		printf("Cannot alloc %d bytes\n", header->size);
-		return;
-	}
-	read(header->fd, header->data, header->size);
-}
+int fiasco_unpack(struct fiasco * fiasco, const char * dir) {
 
-/* fiasco writer */
-int fiasco_new(const char *filename, const char *name)
-{
-	int fd;
-	//int len = htonl(strlen(name)+1+6+14);
+	int fd = -1;
+	char * name = NULL;
+	char * layout_name = NULL;
+	struct image * image;
+	struct image_list * image_list;
+	uint32_t size;
+	char cwd[256];
+	unsigned char buf[4096];
 
-	fd = open(filename, O_RDWR|O_CREAT, 0644);
-	if (fd == -1)
-		return -1;
-#if 1
-	write(fd, "\xb4\x00\x00\x00\x14\x00\x00\x00\x01\xe8\x0e", 11);
-	write(fd, "OSSO UART+USB", 14);
-#else
-	/* 2nd format doesnt works. atm stay with old one */
-	write(fd, "\xb4", 1);
-	write(fd, &len, 4);
-	/* version header */
-	write(fd, "\x00\x00\x00\x02\xe8\x0e", 6);
-	/* firmware type */
-	write(fd, "OSSO UART+USB", 14);
-	/* firmware name */
-	write(fd, name, strlen(name));
-	write(fd, "", 1);
-#endif
-	return fd;
-}
+	if ( dir ) {
 
-int fiasco_add_eof(int fd)
-{
-#if 0
-	unsigned char buf[120];
-	if (fd == -1)
-		return -1;
-	memset(buf,'\xff', 120);
-	write(fd, buf, 120);
-#endif
-	return 0;
-}
+		memset(cwd, 0, sizeof(cwd));
 
+		if ( ! getcwd(cwd, sizeof(cwd)) ) {
+			ERROR_INFO("Cannot store current directory");
+			return -1;
+		}
 
-int fiasco_add(int fd, const char *name, const char *file, const char *version)
-{
-	int gd,ret;
-	unsigned int sz;
-	unsigned char len;
-	unsigned short hash;
-	unsigned char *ptr = (unsigned char *)&hash;
-	char buf[4096];
-	char bname[32];
+		if ( chdir(dir) < 0 ) {
+			ERROR_INFO("Cannot change current directory to %s", dir);
+			return -1;
+		}
 
-	if (fd == -1)
-		return -1;
-	if (file == NULL)
-		return -1;
-	gd = open(file, O_RDONLY);
-	if (gd == -1)
-		return -1;
-
-	sz = htonl((unsigned int) lseek(gd, 0, SEEK_END));
-	lseek(gd, 0, SEEK_SET);
-	// 4 bytes big endian
-	//write(fd, "T\x02\x2e\x19\x01\x01\x00", 7); // header?
-	write(fd, "T\x01\x2e\x19\x01\x01\x00", 7); // header (old piece format)
-	/* checksum */
-	hash = do_hash_file(file);
-	ptr[0]^=ptr[1]; ptr[1]=ptr[0]^ptr[1]; ptr[0]^=ptr[1];
-	write(fd, &hash, 2);
-	printf("hash: %04x\n", hash);
-
-	memset(bname, '\0', 13);
-	if (name == NULL)
-		name = fpid_file(file);
-	/* failback */
-	if (name == NULL)
-		name = file;
-
-	strncpy(bname, name, 12);
-	write(fd, bname, 12);
-
-	write(fd, &sz, 4);
-	if (version) {
-		/* append metadata */
-		write(fd, "\x00\x00\x00\x00\x31", 5);
-		len = strlen(version);
-		write(fd, &len, 1);
-		write(fd, version, len);
-		write(fd, "\x00\x9b", 2);
-	} else {
-		write(fd, "\x00\x00\x00\x00\x9b", 5);
 	}
 
-	while(1) {
-		ret = read(gd, buf, 4096);
-		if (ret<1)
-			break;
-		write(fd, buf, ret);
-	}
+	fiasco_print_info(fiasco);
 
-	return 0;
-}
+	image_list = fiasco->first;
 
-int fiasco_pack(int optind, char *argv[])
-{
-	const char *file = argv[optind];
-	char *type;
-	int fd, ret;
+	while ( image_list ) {
 
-	fd = fiasco_new(file, file); // TODO use a format here
-	if (fd == -1)
-		return 1;
+		image = image_list->image;
+
+		name = image_name_alloc_from_values(image);
+		if ( ! name )
+			return -1;
+
+		printf("\n");
+		printf("Unpacking image...\n");
+		image_print_info(image);
+
+		if ( image->layout ) {
+
+			layout_name = calloc(1, strlen(name) + strlen(".layout") + 1);
+			if ( ! layout_name )
+				ALLOC_ERROR_RETURN(-1);
+
+			sprintf(layout_name, "%s.layout", name);
+
+			printf("    Layout file: %s\n", layout_name);
+
+		}
+
+		printf("    Output file: %s\n", name);
+
+		if ( ! simulate ) {
+			fd = open(name, O_RDWR|O_CREAT|O_TRUNC, 0644);
+			if ( fd < 0 ) {
+				ERROR_INFO("Cannot create output file %s", name);
+				return -1;
+			}
+		}
+
+		free(name);
+
+		image_seek(image, 0);
+		while ( 1 ) {
+			size = image_read(image, buf, sizeof(buf));
+			if ( size == 0 )
+				break;
+			WRITE_OR_FAIL(name, fd, buf, size);
+		}
+
+		close(fd);
+
+		if ( image->layout ) {
+
+			if ( ! simulate ) {
+				fd = open(layout_name, O_RDWR|O_CREAT|O_TRUNC, 0644);
+				if ( fd < 0 ) {
+					ERROR_INFO("Cannot create layout file %s", layout_name);
+					return -1;
+				}
+			}
+
+			free(layout_name);
+
+			WRITE_OR_FAIL(layout_name, fd, image->layout, (int)strlen(image->layout));
 
-	printf("Package: %s\n", file);
-	while((file=argv[++optind])) {
-		type = (char *)fpid_file(file);
-		printf("Adding %s: %s..\n", type, file);
-		ret = fiasco_add(fd, type, file, NULL);
-		if (ret<0) {
-			printf("Error\n");
 			close(fd);
-			return 1;
+
+		}
+
+		image_list = image_list->next;
+
+	}
+
+	if ( dir ) {
+		if ( chdir(cwd) < 0 ) {
+			ERROR_INFO("Cannot change current directory back to %s", cwd);
+			return -1;
 		}
 	}
-	fiasco_add_eof(fd);
-	printf("Done!\n");
-	close(fd);
+
+	printf("\nDone\n\n");
 	return 0;
+
 }
 
-/* local code */
-#if 0
-void my_callback(int fd, struct header_t *header)
-{
-	fiasco_data_read(header);
-	//read(fd, buf, header->size);
-	printf("Dumping %s\n", header->name);
-	printf("DATA: %02x\n", header->data[0]);
-	fiasco_data_free(header);
+void fiasco_print_info(struct fiasco * fiasco) {
+
+	if ( fiasco->orig_filename )
+		printf("File: %s\n", fiasco->orig_filename);
+
+	if ( fiasco->name[0] )
+		printf("    Fiasco Name: %s\n", fiasco->name);
+
+	if ( fiasco->swver[0] )
+		printf("    Fiasco Software release version: %s\n", fiasco->swver);
+
 }
-
-int main(int argc, char **argv)
-{
-	if (argc!=2) {
-		printf("Usage: unfiasco [file]\n");
-		return 1;
-	}
-
-/*
-	fd = fiasco_new("myfiasco", "pancake-edition");
-	fiasco_add(fd, "kernel", "zImage", "2.6.22");
-	close(fd);
-*/
-
-//	fiasco_callback = &my_callback;
-
-	return openfiasco(argv[1]);
-}
-#endif

src/fiasco.h

@@ -0,0 +1,42 @@
+/*
+    0xFFFF - Open Free Fiasco Firmware Flasher
+    Copyright (C) 2007-2011  pancake <pancake@youterm.com>
+    Copyright (C) 2011-2012  Pali Rohár <pali.rohar@gmail.com>
+
+    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 3 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, see <http://www.gnu.org/licenses/>.
+
+*/
+
+#ifndef FIASCO_H
+#define FIASCO_H
+
+#include "image.h"
+
+struct fiasco {
+	char name[257];
+	char swver[257];
+	int fd;
+	char * orig_filename;
+	struct image_list * first;
+};
+
+struct fiasco * fiasco_alloc_empty(void);
+struct fiasco * fiasco_alloc_from_file(const char * file);
+void fiasco_free(struct fiasco * fiasco);
+void fiasco_add_image(struct fiasco * fiasco, struct image * image);
+int fiasco_write_to_file(struct fiasco * fiasco, const char * file);
+int fiasco_unpack(struct fiasco * fiasco, const char * dir);
+void fiasco_print_info(struct fiasco * fiasco);
+
+#endif

src/flash.c

@@ -1,197 +0,0 @@
-/*
- *  0xFFFF - Open Free Fiasco Firmware Flasher
- *  Copyright (C) 2007  pancake <pancake@youterm.com>
- *
- *  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 3 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, see <http://www.gnu.org/licenses/>.
- */
-
-#include "main.h"
-#include "hash.h"
-#include "hexdump.h"
-#include <usb.h>
-#include <stdio.h>
-#include <string.h>
-#include <stdlib.h>
-
-void check_nolo_order_failed()
-{
-	fprintf(stderr, "\nERROR: Provide xloader before the secondary. NOLO disagrees anything else.\n");
-	fprintf(stderr, "Use: -p xloader.bin -p secondary.bin\n");
-	exit(1);
-}
-
-void query_error_message()
-{
-	/* query error message */
-	int len = 0;
-	char nolomsg[2048];
-	memset(nolomsg, '\0', 2048);
-	usb_control_msg(dev, 192, 5, 0, 0, nolomsg, 2048, 2000);
-	nolomsg[2047] = '\0';
-	printf("\nNOLO says:\n");
-	if (nolomsg[0] == '\0') {
-		printf(" (.. silence ..)\n");
-	} else {
-		dump_bytes((unsigned char *)nolomsg, 128);
-		do {
-			printf(" - %s\n", nolomsg+len);
-			len+=strlen(nolomsg+len)+1;
-		} while(nolomsg[len]!='\0');
-	}
-}
-
-void check_nolo_order()
-{
-	int i, xlo = 0;
-
-	for(i=0;i<pcs_n;i++) {
-		if (!strcmp(pcs[i].type, "xloader")) {
-			if (!xlo && ++i<pcs_n) {
-			printf("CHK%s\n", pcs[i].type);
-				xlo++;
-				if (!strcmp(pcs[i].type, "secondary")) {
-					xlo = 0x11;
-					break;
-				} else check_nolo_order_failed();
-			} check_nolo_order_failed();
-		} else
-		if (!strcmp(pcs[i].type, "secondary"))
-			check_nolo_order_failed();
-	}
-
-	if (xlo && xlo != 0x11)
-		check_nolo_order_failed();
-}
-
-void flash_image(char *filename, char *piece, char *version)
-{
-	FILE *fd;
-	int vlen = 0;
-	int request;
-	/*/ n800 flash queries have a variable size */
-	unsigned char fquery[256]; /* flash query */
-	unsigned long long size, off;
-	unsigned char bsize[4], tmp;
-	unsigned char nolofiller[128];
-	ushort hash = do_hash_file(filename);
-
-	if (version)
-		vlen = strlen(version)+1;
-
-	fd = fopen(filename, "rb");
-	if (fd == NULL) {
-		printf("Cannot open file\n");
-		exit(1);
-	}
-	/* cook flash query */
-	memset(fquery, '\x00', 27);              // reset buffer
-	memcpy(fquery, "\x2e\x19\x01\x01", 4);   // header
-	//memcpy(fquery+5, "\xbf\x6b", 2); // some magic (modified crc16???)
-	memcpy(fquery+5, &hash, 2);
-	tmp = fquery[5]; fquery[5] = fquery[6]; fquery[6] = tmp;
-	memcpy(fquery+7, piece, strlen(piece));  // XXX ??!??
-
-	printf("| hash: 0x%hhx%hhx ", fquery[5], fquery[6]);
-	size = get_file_size(filename);
-	bsize[0] = (size & 0xff000000) >> 24;
-	bsize[1] = (size & 0x00ff0000) >> 16;
-	bsize[2] = (size & 0x0000ff00) >> 8;
-	bsize[3] = (size & 0x000000ff);
-	printf("size: %lld (%02x %02x %02x %02x)\n",
-		size, bsize[0], bsize[1], bsize[2], bsize[3]);
-	memcpy(fquery+0x13, &bsize, 4);
-	if (vlen) memcpy(fquery+27, version, vlen);
-	
-	if (!strcmp(piece, "rootfs"))
-		request = 85;
-	else    request = 68;
-
-	//dump_bytes(fquery, 27+vlen);
-	if (usb_control_msg(dev, CMD_WRITE, request, 0, 0, (char *)fquery, 27+vlen, 2000) <0) {
-		query_error_message();
-		perror("flash_image.header");
-		exit(1);
-	}
-
-	/*/ cook and bulk nollo filler */
-	memset(&nolofiller, '\xff', 128);
-	memcpy(nolofiller+0x00, "NOLO filler", 11);
-	memcpy(nolofiller+0x40, "NOLO filler", 11);
-	usb_bulk_write(dev, 2, (char *)nolofiller, 128, 5000);
-	usb_bulk_write(dev, 2, (char *)nolofiller, 0,   5000);
-
-	/*/ bulk write image here */
-	printf("[=] Bulkwriting the %s piece...\n", piece);
-	fflush(stdout);
-
-	for(off = 0; off<size; off += BSIZE) {
-		char buf[BSIZE];
-		int bread, bsize = size-off;
-		if (bsize>BSIZE) bsize = BSIZE;
-		bread = fread(buf, bsize, 1, fd);
-		if (bread != 1)
-			printf("WARNING: Oops wrong read %d vs %d \n", bread, bsize);
-		bread = usb_bulk_write(dev, 2, buf, bsize, 5000);
-		if (bread == 64) {
-			query_error_message();
-			fclose(fd);
-			return;
-		}
-		progressbar(off, size);
-		if (bread<0) {
-			printf("\n");
-			perror(" -ee- ");
-			fclose(fd);
-			return;
-		}
-		fflush(stdout);
-	}
-	fclose(fd);
-	/*/ EOF */
-	usb_bulk_write(dev, 2, (char *)nolofiller, 0, 1000);
-	progressbar(1, 1);
-	printf("\n");
-
-	// index = 4????
-	if (!strcmp(piece, "rootfs")) {
-		if (usb_control_msg(dev, CMD_WRITE, 82, 0, 0, (char *)fquery, 0, 30000)<0) {
-			fprintf(stderr, "Oops. Invalid checksum?\n");
-			exit(1);
-		}
-	} else {
-		int t = 0;
-		if (!strcmp(piece, "secondary"))
-			t = 1;
-		else
-		if (!strcmp(piece, "kernel"))
-			t = 3;
-		else
-		if (!strcmp(piece, "initfs"))
-			t = 4;
-		if (!strcmp(piece, "xloader"))
-			printf("xloader flashed not commiting until secondary arrives...\n");
-		else
-		if (usb_control_msg(dev, CMD_WRITE, 80, 0, t, (char *)fquery, 0, 10000)<0) {
-			fprintf(stderr, "Oops. Invalid checksum?\n");
-			exit(1);
-		}
-	}
-
-	// unknown query !! :""
-	if (usb_control_msg(dev, CMD_WRITE, 67, 0, 0, (char *)fquery, 0, 2000)<0) {
-		fprintf(stderr, "Oops, the flash was denied or so :/\n");
-		exit(1);
-	}
-	printf("Flash done succesfully.\n");
-}

src/fpid.c

@@ -1,72 +0,0 @@
-/*
- *  0xFFFF - Open Free Fiasco Firmware Flasher
- *  Copyright (C) 2007  pancake <pancake@youterm.com>
- *
- *  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 3 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, see <http://www.gnu.org/licenses/>.
- */
-
-#include "main.h"
-#include <stdio.h>
-#include <string.h>
-
-const char *fpid_file(const char *filename)
-{
-	FILE *fd;
-	char buf[512];
-	unsigned char *b = (unsigned char *)&buf;
-	char *piece = NULL;
-	long size;
-
-	// 2nd      : +0x34 = 2NDAPE
-	// secondary: +0x04 = NOLOScnd
-	// x-loader : +0x14 = X-LOADER
-	// xloader8 : +0x0c = NOLOXldr
-	// kernel   : +0x00 = 0000 a0e1 0000 a0e1
-	// initfs   : <2M...be sure with 3M 0x300000
-
-	fd = fopen(filename, "r");
-	if (fd == NULL) {
-		printf("Cannot open file '%s'\n", filename);
-		return NULL;
-	}
-	fread(buf, 512, 1, fd);
-	fseek(fd, 0, SEEK_END);
-	size = ftell(fd);
-	fclose(fd);
-
-	if (!memcmp(b+0x34, "2NDAPE", 6))
-		return pieces[PIECE_2ND];
-	else
-	if (!memcmp(b+0x04, "NOLOScnd", 8))
-		return pieces[PIECE_SECONDARY];
-	else
-	if (!memcmp(b+0x14, "X-LOADER", 8))
-		return pieces[PIECE_XLOADER];
-	else
-	if (!memcmp(b+0x0c, "NOLOXldr", 8)) // TODO: this is xloader800, not valid on 770?
-		return pieces[PIECE_XLOADER];
-	else
-	if (!memcmp(b+0x00, "\x00\x00\xa0\xe1\x00\x00\xa0\xe1", 8))
-		return pieces[PIECE_KERNEL];
-	else
-	// JFFS2 MAGIC
-	if (!memcmp(b+0x00, "\x85\x19", 2)) { //\x01\xe0", 4)) {
-		/*/ is jffs2 */
-		if (size < 0x300000)
-			return pieces[PIECE_INITFS];
-		return pieces[PIECE_ROOTFS];
-	}
-
-	return piece;
-}

src/global.h

@@ -0,0 +1,24 @@
+
+#ifndef GLOBAL_H
+#define GLOBAL_H
+
+#include <stdio.h>
+#include <string.h>
+#include <errno.h>
+
+extern int simulate;
+extern int noverify;
+extern int verbose;
+
+#define VERBOSE(...) do { if ( verbose ) { fprintf(stderr, __VA_ARGS__); } } while (0)
+#define WARNING(...) do { fprintf(stderr, "Warning: "); fprintf(stderr, __VA_ARGS__); fprintf(stderr, "\n"); } while (0)
+#define ERROR_INFO_STR(str, ...) do { if ( str[0] ) fprintf(stderr, "Error: %s: ", str); else fprintf(stderr, "Error: "); fprintf(stderr, __VA_ARGS__); if ( errno ) fprintf(stderr, ": %s\n", strerror(errno)); else fprintf(stderr, "\n"); } while (0)
+#define ERROR_STR(str, ...) do { errno = 0; ERROR_INFO_STR(str, __VA_ARGS__); } while (0)
+#define ERROR_INFO(...) do { ERROR_INFO_STR("", __VA_ARGS__); } while (0)
+#define ERROR(...) do { ERROR_STR("", __VA_ARGS__); } while (0)
+#define ERROR_RETURN(str, ...) do { ERROR("%s", str); return __VA_ARGS__; } while (0)
+
+#define ALLOC_ERROR() do { ERROR("Cannot allocate memory"); } while (0)
+#define ALLOC_ERROR_RETURN(...) do { ALLOC_ERROR(); return __VA_ARGS__; } while (0)
+
+#endif

src/gui/Makefile

@@ -0,0 +1,21 @@
+include ../../config.mk
+
+ifeq (${HAVE_GUI},1)
+all: goxf
+
+goxf:
+	${CC} -I../squeue ../squeue/squeue.c ../fpid.c gui.c `pkg-config --cflags --libs gtk+-2.0` -o goxf
+
+c:
+	gtkamlc --save-temps --Xcc=-I../squeue ../squeue/squeue.c ../fpid.c ../squeue/squeue.vapi gui.gtkon extras.vapi --pkg gtk+-2.0 -o goxf
+
+test:
+	valac --save-temps --Xcc=-I.. squeue.vapi test.vala ../squeue.c -o v
+	valac --save-temps --Xcc=-I.. squeue.vapi client.vala ../squeue.c -o c
+else
+all:
+	@true
+endif
+
+clean:
+	rm -f goxf *.o *.c

src/gui/extras.vapi

@@ -0,0 +1,10 @@
+namespace Extras {
+	public class External {
+		[CCode (cname = "system")]
+		public static int system(string cmd);
+		[CCode (cname = "fpid_file")]
+		public static string fpid_file(string file);
+		[CCode (cname = "fpid_size")]
+		public static long fpid_size(string file);
+	}
+}

src/gui/gui.gtkaml.orig

@@ -0,0 +1,356 @@
+<!--
+
+ Frontend for the 0xFFFF flasher in gtkaml
+
+ author: pancake <youterm.com>
+
+-->
+
+<Window xmlns="Gtk"
+        xmlns:GLib="GLib"
+        xmlns:Extras="Extras"
+        xmlns:SQueues="SQueues"
+        xmlns:class="http://gtkaml.org/0.2"
+        class:name="MainWindow"
+        title="0xFFFF GUI">
+        <!-- delete-event="{OnWindow1DeleteEvent}" -->
+<VBox>
+  <MenuBar expand="false">
+    <MenuItem label="_File" with-mnemonic="true">
+    <submenu>
+      <Menu>
+      <ImageMenuItem stock-id="gtk-new" activate="{OnFileNewEvent}"/>
+      <ImageMenuItem stock-id="gtk-open" activate="{OnFileOpenEvent}"/>
+      <SeparatorMenuItem />
+      <ImageMenuItem stock-id="gtk-quit" activate="{OnQuitEvent}"/>
+      </Menu>
+    </submenu>
+    </MenuItem>
+
+    <!-- Help menu -->
+    <MenuItem label="_Target" with-mnemonic="true">
+    <submenu>
+      <Menu>
+      <ImageMenuItem stock-id="gtk-connect" activate="{OnConnect}"/>
+      <ImageMenuItem stock-id="gtk-stop" activate="{OnStop}"/>
+      <ImageMenuItem stock-id="gtk-info" activate="{OnGetInformation}"/>
+      <ImageMenuItem label="Reset" activate="{OnReset}"/>
+      </Menu>
+    </submenu>
+    </MenuItem>
+
+    <!-- Help menu -->
+    <MenuItem label="_Help" with-mnemonic="true">
+    <submenu>
+      <Menu>
+	<ImageMenuItem stock-id="gtk-about" activate="{OnMenuHelpAboutActivatedEvent}"/>
+      </Menu>
+    </submenu>
+    </MenuItem>
+  </MenuBar>
+
+  <HBox border-width="5">
+   <VBox border-width="3" spacing="3">
+   <ScrolledWindow can-focus="true" hscrollbar-policy="{PolicyType.AUTOMATIC}" vscrollbar-policy="{PolicyType.AUTOMATIC}">
+    <TreeView class:private="tv">
+    </TreeView>
+   </ScrolledWindow>
+
+   </VBox>
+   <VBox expand="false" border-width="3" spacing="3">
+      <Button label="gtk-connect" use-stock="true" expand="false" clicked="{OnConnect}"/>
+      <Button label="gtk-stop" use-stock="true" expand="false" clicked="{OnStop}"/>
+      <Button label="gtk-info" use-stock="true" expand="false" clicked="{OnGetInformation}"/>
+    <Label label="" />
+<!--      <Button label="Options" use-stock="false" expand="false"/>
+      <Button label="Fiasco!" use-stock="false" expand="false"/>
+      <Button label="Unpack!" use-stock="false" expand="false"/> -->
+      <Button label="gtk-add" use-stock="true" expand="false" clicked="{OnFileOpenEvent}" />
+      <Button label="gtk-remove" use-stock="true" expand="false" clicked="{list_del}"/>
+    <Label label="" />
+      <Button label="gtk-media-record" use-stock="true" expand="false" clicked="{OnFileFlashEvent}"/>
+   </VBox>
+  </HBox>
+  <ProgressBar class:private="pb" expand="false" />
+
+ <!-- <Statusbar expand="false"/> -->
+</VBox>
+	<AboutDialog class:standalone="true" class:private="aboutdialog1" delete-event="{aboutdialog1.hide_on_delete}"
+		border-width="5" title="About 0xFFFF gui" resizable="false" modal="true"
+		window-position="{WindowPosition.CENTER_ON_PARENT}" has-separator="false"
+		program-name="0xFFFF" version="0.5" copyright="Copyright (c) 2007-2009 pancake"
+		comments="The Free Nokia Internet Tablet flasher"
+		website="http://www.nopcode.org/0xFFFF/" 
+		authors='{new string[] {"pancake (pancake@youterm.com)", null}}'>
+	</AboutDialog>			
+
+<![CDATA[
+
+
+private void doCloseApplication ()
+{
+	Gtk.main_quit ();
+}
+
+private void OnReset()
+{
+	q->push("reset:device", 1);
+}
+
+private void OnFileFlashEvent()
+{
+	ListStore ls = (ListStore)tv.get_model();
+	weak string str;
+	TreeIter iter;
+
+	int n = ls.iter_n_children(null);
+	if (n >0) {
+		if (showYesNo("Do you want to flash these files?")) {
+			ls.get_iter_first(out iter);
+			do {
+				ls.get(iter, 2, out str, -1);
+				//stdout.printf("polla:%s\n", str);
+				q->push2("flash", str, 1);
+			} while(ls.iter_next(ref iter));
+		}
+	} else {
+		showMessage("No files selected", MessageType.ERROR);
+	}
+}
+
+private void OnFileOpenEvent ()
+{
+	FileChooserDialog fc = new FileChooserDialog("Select file to open",
+			this, FileChooserAction.OPEN,
+			"gtk-cancel", ResponseType.CANCEL,
+			"gtk-open", ResponseType.ACCEPT);
+	int resp = fc.run ();
+	fc.hide ();
+	if (resp == ResponseType.ACCEPT) {
+		string file = fc.get_filename();
+		string *type = External.fpid_file(file);
+		string size = "%ld".printf(External.fpid_size(file));
+		if (type == null) {
+			showMessage("Invalid file type", MessageType.ERROR);
+		} else {
+			add_file(type, size, file);
+		}
+	}
+	fc.destroy ();
+}
+
+public bool loadFile( string filename )
+{
+	int err = 0;
+	try {
+		string contents; size_t length;
+		FileUtils.get_contents (filename, out contents, out length);
+		//textview1.buffer.set_text (contents, length);
+	} catch(Error e) {
+		showError ("Unexpected error while loading the file, please contact the author with the following information:\n\n" + e.message);
+		err++;
+	}
+	return err == 0;
+}
+
+public bool showYesNo(string s)
+{
+	MessageDialog md = new MessageDialog (this,
+			DialogFlags.DESTROY_WITH_PARENT,
+			MessageType.QUESTION, ButtonsType.YES_NO, s);
+	int ret = md.run ();
+	md.destroy ();
+
+	return ret==ResponseType.YES;
+}
+
+public void showMessage(string s, MessageType mt)
+{
+	MessageDialog md = new MessageDialog (this,
+			DialogFlags.DESTROY_WITH_PARENT,
+			mt, ButtonsType.CLOSE, s);
+	md.run ();
+	md.destroy ();
+}
+
+private void OnMenuHelpAboutActivatedEvent ()
+{
+	aboutdialog1.transient_for = this;
+	aboutdialog1.run ();
+}
+
+public void showError (string s)
+{
+	MessageDialog md = new MessageDialog (this,
+			DialogFlags.DESTROY_WITH_PARENT,
+			MessageType.ERROR,
+			ButtonsType.CLOSE,
+			s);
+	md.run ();
+	md.destroy ();
+}
+
+private void OnFileNewEvent ()
+{
+	list_clear();
+	// TODO: clear file list
+}
+
+private void OnQuitEvent ()
+{
+	doCloseApplication();
+	// TODO: send message to gracefully kill 0xFFFF
+	// TODO: handle ^C when flashing
+}
+
+public void list_clear()
+{
+	((ListStore)tv.model).clear();
+}
+
+public void list_del()
+{
+        TreeIter iter;
+        TreeModel model;
+
+        TreeSelection sel = tv.get_selection();
+
+        if (sel.count_selected_rows() == 1) {
+                sel.get_selected(out model, out iter);
+                ((ListStore)tv.model).remove(iter);
+        }
+}
+
+public void add_file(string type, string size, string file)
+{
+	ListStore listmodel = (ListStore)tv.get_model();
+	Gtk.TreeIter iter;
+	listmodel.append (out iter);
+	listmodel.set (iter, 0, type, 1, size, 2, file, -1);
+}
+
+public static void setup_treeview (Gtk.TreeView view)
+{
+        /* use liststore to hold accountname, accounttype, balance and color attribute */
+        /* for more info how gtkTreeview works take a look in the GTK API */
+
+        var listmodel = new Gtk.ListStore(4, typeof(string), typeof(string), typeof(string), typeof(string));       
+        view.set_model(listmodel);
+
+        view.insert_column_with_attributes (-1, "Type", new Gtk.CellRendererText(), "text", 0, null);
+        view.insert_column_with_attributes (-1, "Size", new Gtk.CellRendererText(), "text", 1, null);
+
+        var cell = new Gtk.CellRendererText (); 
+        cell.set ("foreground_set", true, null);
+        view.insert_column_with_attributes (-1, "Name", cell, "text", 2, "foreground", 3, null);
+
+//        Gtk.TreeIter iter;
+ //       listmodel.append (out iter);
+  //      listmodel.set (iter, 0, "initfs", 1, "3M", 2, "initfs.jffs", -1);
+        //listmodel.set (iter, 0, "initfs", 1, "3M", 2, "initfs.jffs", 3, "green", -1);
+
+   //     listmodel.append (out iter);
+    //    listmodel.set (iter, 0, "rootfs", 1, "52M", 2, "rootfs.jffs", -1);
+}
+
+public static bool readFunc()
+{
+	weak string msg = p->get(0);
+
+	if (msg != null && msg[0]!='\0') {
+		stdout.printf("[<] msg received: %s\n", msg);
+		string[] foo = msg.split(":",2);
+		if (foo[1] != null) {
+			switch(foo[0]) {
+			case "bar":
+				viewer.pb.fraction = foo[1].to_int() / 100;
+				viewer.pb.text = foo[1]+"%";
+				break;
+			case "error":
+				viewer.showMessage(foo[1], MessageType.ERROR);
+				break;
+			case "info":
+				viewer.showMessage(foo[1], MessageType.INFO);
+				break;
+			default:
+				stderr.printf("[E] Unknown message type\n");
+				break;
+			}
+			//viewer.showMessage(msg, MessageType.INFO);
+		}
+		p->pop();
+	}
+	return true;
+}
+
+static SQueue *q = null;
+static SQueue *p = null;
+
+private void OnGetInformation()
+{
+	msg("info:device");
+}
+
+private void OnConnect()
+{
+	//msg("connect:device");
+	OnStop();
+	External.system("sudo 0xFFFF -Q &");
+	p->close();
+	q->close();
+	p = q = null;
+}
+
+private void OnStop()
+{
+	External.system("sudo pkill 0xFFFF");
+}
+
+
+private bool chk_queues()
+{
+	if (p == null)
+		p = SQueue.open("/tmp/0xFFFF.1", SQueueMode.OPEN);
+	if (q == null)
+		q = SQueue.open("/tmp/0xFFFF.2", SQueueMode.OPEN);
+	if (p == null || q == null) {
+		showMessage("Cannot connect to queues", MessageType.ERROR);
+		return false;
+	}
+	return true;
+}
+
+public void msg(string str)
+{
+	if (!chk_queues())
+		return;
+	if (q->push(str, 0)<1) {
+		stderr.printf("Oops on push\n");
+		q->free();
+		q = null;
+		p->free();
+		p = null;
+	}
+}
+
+static MainWindow viewer;
+
+static int main (string[] args)
+{
+	Gtk.init (ref args);
+	viewer = new MainWindow();
+	if (args.length > 1)
+		viewer.loadFile (args[1]);
+	viewer.resize(600,400);
+	viewer.set_position(WindowPosition.CENTER);
+	viewer.delete_event += (x,y) => { Gtk.main_quit(); };
+	setup_treeview(viewer.tv);
+	viewer.show_all ();
+//	viewer.showMessage("This software is beta and does not guaranties correct functionality", MessageType.WARNING);
+	Timeout.add(200, (SourceFunc)(readFunc));
+	Gtk.main ();
+	return 0;
+}
+
+]]>
+</Window>

src/gui/gui.gtkon

@@ -0,0 +1,321 @@
+/*
+ | Frontend for the 0xFFFF flasher in gtkaml
+ | author: pancake <youterm.com>
+ */
+
+Window using="Gtk" gtkon:version=0.4
+	using:Extras="Extras"
+	using:SQueues="SQueues"
+	name="MainWindow"
+	title="0xFFFF GUI"
+{
+	/* delete-event="{OnWindow1DeleteEvent}" */
+	VBox {
+		MenuBar !expand {
+			MenuItem label="_File" with-mnemonic {
+				submenu {
+					Menu {
+						ImageMenuItem stock-id="gtk-new" activate=OnFileNewEvent;
+						ImageMenuItem stock-id="gtk-open" activate=OnFileOpenEvent;
+						SeparatorMenuItem;
+						ImageMenuItem stock-id="gtk-quit" activate=OnQuitEvent;
+					}
+				}
+			}
+			MenuItem label="_Target" with-mnemonic {
+				submenu {
+					Menu {
+						ImageMenuItem stock-id="gtk-connect" activate=OnConnect;
+						ImageMenuItem stock-id="gtk-stop" activate=OnStop;
+						ImageMenuItem stock-id="gtk-info" activate=OnGetInformation;
+						ImageMenuItem label="Reset" activate=OnReset;
+					}
+				}
+			}
+			MenuItem label="_Help" with-mnemonic {
+				submenu {
+					Menu {
+						ImageMenuItem stock-id="gtk-about" activate=OnMenuHelpAboutActivatedEvent;
+					}
+				}
+			}
+		}
+
+		HBox border-width="5" {
+			VBox border-width="3" spacing="3" {
+				ScrolledWindow can-focus="true" hscrollbar-policy="{PolicyType.AUTOMATIC}" vscrollbar-policy="{PolicyType.AUTOMATIC}" {
+					TreeView $.tv;
+				}
+
+			}
+			VBox !expand border-width="3" spacing="3" {
+				Button label="gtk-connect" use-stock !expand clicked=OnConnect;
+				Button label="gtk-stop" use-stock !expand clicked=OnStop;
+				Button label="gtk-info" use-stock !expand clicked=OnGetInformation;
+				Label label="";
+				/*
+				   <!--      <Button label="Options" use-stock="false" expand="false"/>
+				   <Button label="Fiasco!" use-stock="false" expand="false"/>
+				   <Button label="Unpack!" use-stock="false" expand/> -->
+				 */
+				Button label="gtk-add" use-stock="true" !expand clicked=OnFileOpenEvent;
+				Button label="gtk-remove" use-stock="true" expand="false" clicked=list_del;
+				Label label="";
+				Button label="gtk-media-record" use-stock="true" expand="false" clicked=OnFileFlashEvent;
+			}
+		}
+		ProgressBar $.pb !expand;
+
+		//<!-- <Statusbar expand="false"/> -->
+	}
+	AboutDialog gtkaml:standalone $.aboutdialog1 delete-event=aboutdialog1.hide_on_delete
+		border-width="5" title="About 0xFFFF gui" resizable="false" modal="true"
+		window-position="{WindowPosition.CENTER_ON_PARENT}" has-separator="false"
+		program-name="0xFFFF" version="0.5" copyright="Copyright (c) 2007-2009 pancake"
+		comments="The Free Nokia Internet Tablet flasher"
+		website="http://www.nopcode.org/0xFFFF/" 
+		authors='{new string[] {"pancake (pancake@youterm.com)", null}}';
+
+	-{
+
+
+		private void doCloseApplication () {
+			Gtk.main_quit ();
+		}
+
+		private void OnReset() {
+			q->push("reset:device", 1);
+		}
+
+		private void OnFileFlashEvent() {
+			ListStore ls = (ListStore)tv.get_model();
+			weak string str;
+			TreeIter iter;
+
+			int n = ls.iter_n_children(null);
+			if (n >0) {
+				if (showYesNo("Do you want to flash these files?")) {
+					ls.get_iter_first(out iter);
+					do {
+						ls.get(iter, 2, out str, -1);
+						//stdout.printf("polla:%s\n", str);
+						q->push2("flash", str, 1);
+					} while(ls.iter_next(ref iter));
+				}
+			} else showMessage("No files selected", MessageType.ERROR);
+		}
+
+		private void OnFileOpenEvent () {
+			FileChooserDialog fc = new FileChooserDialog("Select file to open",
+					this, FileChooserAction.OPEN,
+					"gtk-cancel", ResponseType.CANCEL,
+					"gtk-open", ResponseType.ACCEPT);
+			int resp = fc.run ();
+			fc.hide ();
+			if (resp == ResponseType.ACCEPT) {
+				string file = fc.get_filename();
+				string *type = External.fpid_file(file);
+				string size = "%ld".printf(External.fpid_size(file));
+				if (type == null)
+					showMessage("Invalid file type", MessageType.ERROR);
+				else add_file(type, size, file);
+			}
+			fc.destroy ();
+		}
+
+		public bool loadFile( string filename ) {
+			int err = 0;
+			try {
+				string contents; size_t length;
+				FileUtils.get_contents (filename, out contents, out length);
+				//textview1.buffer.set_text (contents, length);
+			} catch(Error e) {
+				showError ("Unexpected error while loading the file, please contact the author with the following information:\n\n" + e.message);
+				err++;
+			}
+			return err == 0;
+		}
+
+		public bool showYesNo(string s) {
+			MessageDialog md = new MessageDialog (this,
+					DialogFlags.DESTROY_WITH_PARENT,
+					MessageType.QUESTION, ButtonsType.YES_NO, s);
+			int ret = md.run ();
+			md.destroy ();
+			return ret==ResponseType.YES;
+		}
+
+		public void showMessage(string s, MessageType mt) {
+			MessageDialog md = new MessageDialog (this,
+					DialogFlags.DESTROY_WITH_PARENT,
+					mt, ButtonsType.CLOSE, s);
+			md.run ();
+			md.destroy ();
+		}
+
+		private void OnMenuHelpAboutActivatedEvent () {
+			aboutdialog1.transient_for = this;
+			aboutdialog1.response.connect ((x)=> { aboutdialog1.hide (); });
+			aboutdialog1.run ();
+		}
+
+		public void showError (string s) {
+			MessageDialog md = new MessageDialog (this,
+					DialogFlags.DESTROY_WITH_PARENT,
+					MessageType.ERROR,
+					ButtonsType.CLOSE,
+					s);
+			md.run ();
+			md.destroy ();
+		}
+
+		private void OnFileNewEvent () {
+			list_clear();
+			// TODO: clear file list
+		}
+
+		private void OnQuitEvent () {
+			doCloseApplication();
+			// TODO: send message to gracefully kill 0xFFFF
+			// TODO: handle ^C when flashing
+		}
+
+		public void list_clear() {
+			((ListStore)tv.model).clear();
+		}
+
+		public void list_del() {
+			TreeIter iter;
+			TreeModel model;
+
+			TreeSelection sel = tv.get_selection();
+
+			if (sel.count_selected_rows() == 1) {
+				sel.get_selected(out model, out iter);
+				((ListStore)tv.model).remove(iter);
+			}
+		}
+
+		public void add_file(string type, string size, string file) {
+			ListStore listmodel = (ListStore)tv.get_model();
+			Gtk.TreeIter iter;
+			listmodel.append (out iter);
+			listmodel.set (iter, 0, type, 1, size, 2, file, -1);
+		}
+
+		public static void setup_treeview (Gtk.TreeView view) {
+			/* use liststore to hold accountname, accounttype, balance and color attribute */
+			/* for more info how gtkTreeview works take a look in the GTK API */
+
+			var listmodel = new Gtk.ListStore(4, typeof(string), typeof(string), typeof(string), typeof(string));       
+			view.set_model(listmodel);
+
+			view.insert_column_with_attributes (-1, "Type", new Gtk.CellRendererText(), "text", 0, null);
+			view.insert_column_with_attributes (-1, "Size", new Gtk.CellRendererText(), "text", 1, null);
+
+			var cell = new Gtk.CellRendererText (); 
+			cell.set ("foreground_set", true, null);
+			view.insert_column_with_attributes (-1, "Name", cell, "text", 2, "foreground", 3, null);
+
+			//        Gtk.TreeIter iter;
+			//       listmodel.append (out iter);
+			//      listmodel.set (iter, 0, "initfs", 1, "3M", 2, "initfs.jffs", -1);
+			//listmodel.set (iter, 0, "initfs", 1, "3M", 2, "initfs.jffs", 3, "green", -1);
+
+			//     listmodel.append (out iter);
+			//    listmodel.set (iter, 0, "rootfs", 1, "52M", 2, "rootfs.jffs", -1);
+		}
+
+		public static bool readFunc() {
+			weak string msg = p->get(0);
+
+			if (msg != null && msg[0]!='\0') {
+				stdout.printf("[<] msg received: %s\n", msg);
+				string[] foo = msg.split(":",2);
+				if (foo[1] != null) {
+					switch(foo[0]) {
+						case "bar":
+							viewer.pb.fraction = foo[1].to_int() / 100;
+							viewer.pb.text = foo[1]+"%";
+							break;
+						case "error":
+							viewer.showMessage(foo[1], MessageType.ERROR);
+							break;
+						case "info":
+							viewer.showMessage(foo[1], MessageType.INFO);
+							break;
+						default:
+							stderr.printf("[E] Unknown message type\n");
+							break;
+					}
+					//viewer.showMessage(msg, MessageType.INFO);
+				}
+				p->pop();
+			}
+			return true;
+		}
+
+		static SQueue *q = null;
+		static SQueue *p = null;
+
+		private void OnGetInformation() {
+			msg("info:device");
+		}
+
+		private void OnConnect() {
+			//msg("connect:device");
+			OnStop();
+			External.system("sudo 0xFFFF -Q &");
+			p->close();
+			q->close();
+			p = q = null;
+		}
+
+		private void OnStop() {
+			External.system("sudo pkill 0xFFFF");
+		}
+
+		private bool chk_queues() {
+			if (p == null)
+				p = SQueue.open("/tmp/0xFFFF.1", SQueueMode.OPEN);
+			if (q == null)
+				q = SQueue.open("/tmp/0xFFFF.2", SQueueMode.OPEN);
+			if (p == null || q == null) {
+				showMessage("Cannot connect to queues", MessageType.ERROR);
+				return false;
+			}
+			return true;
+		}
+
+		public void msg(string str) {
+			if (!chk_queues())
+				return;
+			if (q->push(str, 0)<1) {
+				stderr.printf("Oops on push\n");
+				q->free();
+				q = null;
+				p->free();
+				p = null;
+			}
+		}
+
+		static MainWindow viewer;
+
+		static int main (string[] args) {
+			Gtk.init (ref args);
+			viewer = new MainWindow();
+			if (args.length > 1)
+				viewer.loadFile (args[1]);
+			viewer.resize(600,400);
+			viewer.set_position(WindowPosition.CENTER);
+			viewer.delete_event.connect ((x,y) => { Gtk.main_quit(); return false; });
+			setup_treeview(viewer.tv);
+			viewer.show_all ();
+			//	viewer.showMessage("This software is beta and does not guaranties correct functionality", MessageType.WARNING);
+			Timeout.add(200, (SourceFunc)(readFunc));
+			Gtk.main ();
+			return 0;
+		}
+
+	}-
+}

src/hash.h

@@ -1,10 +0,0 @@
-#ifndef _INCLUDE_HASH_H_
-#define _INCLUDE_HASH_H_
-
-#define usho unsigned short
-#define BSIZE 0x20000
-
-usho do_hash(usho *b, int len);
-usho do_hash_file(char *filename);
-
-#endif

src/hexdump.c

@@ -1,65 +0,0 @@
-/*
- *  radare - advanced commandline hexadecimal editor
- *  Copyright (C) 2006,2007  pancake <pancake@youterm.com>
- *
- *  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 3 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, see <http://www.gnu.org/licenses/>.
- */
-
-#include <stdio.h>
-#include <string.h>
-#include "hexdump.h"
-
-char getprintablechar(char a)
-{
-	if (a>=' '&&a<='~')
-		return a;
-	return '.';
-}
-
-int is_printable (int c)
-{
-	if (c<' '||c>'~') return 0;
-	return 1;
-}
-
-/*
- * Helper function
- */
-void dump_bytes(unsigned char *buf, int len)
-{
-	int i,j,seek = 0;
-	int inc = 16;
-
-	for(i=0; i<len; i+=inc) {
-		fprintf(stderr, "0x%08x | ", seek+i);
-		for(j=i;j<i+inc;j++) {
-			if (j>=len) {
-				fprintf(stderr, "   ");
-				continue;
-			}
-			fprintf(stderr, "%02x ", buf[j]);
-		}
-		fprintf(stderr, "  ");
-		for(j=i; j<i+inc; j++) {
-			if (j >= len)
-				fprintf(stderr, " ");
-			else
-			if ( is_printable(buf[j]) )
-				fprintf(stderr, "%c", buf[j]);
-			else	fprintf(stderr, ".");
-		}
-		fprintf(stderr, "\n");
-	}
-	fflush(stderr);
-}

src/hexdump.h

@@ -1,3 +0,0 @@
-char getprintablechar(char a);
-int is_printable (int c);
-void dump_bytes(unsigned char *buf, int len);

src/image.c

@@ -0,0 +1,608 @@
+/*
+    0xFFFF - Open Free Fiasco Firmware Flasher
+    Copyright (C) 2012  Pali Rohár <pali.rohar@gmail.com>
+
+    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 3 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, see <http://www.gnu.org/licenses/>.
+
+*/
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <unistd.h>
+
+#include "global.h"
+#include "device.h"
+#include "image.h"
+
+#define IMAGE_STORE_CUR(image) do { if ( image->is_shared_fd ) { image->cur = lseek(image->fd, 0, SEEK_CUR) - image->offset; if ( image->cur > image->size ) image->cur = image->size; } } while (0)
+#define IMAGE_RESTORE_CUR(image) do { if ( image->is_shared_fd ) { if ( image->cur <= image->size ) lseek(image->fd, image->offset + image->cur, SEEK_SET); else lseek(image->fd, image->offset + image->size, SEEK_SET); } } while (0)
+
+/* format: type-device:hwrevs_version */
+static void image_missing_values_from_name(struct image * image, const char * name) {
+
+	char * str;
+	char * ptr;
+	char * ptr2;
+	char * type = NULL;
+	char * device = NULL;
+	char * hwrevs = NULL;
+	char * version = NULL;
+	enum device new_device;
+
+	str = strdup(name);
+	if ( ! str )
+		return;
+
+	ptr = strchr(str, '_');
+	if ( ptr ) {
+		*ptr = 0;
+		++ptr;
+		version = strdup(ptr);
+	}
+
+	ptr = strchr(str, '-');
+	if ( ptr ) {
+		*ptr = 0;
+		++ptr;
+		type = strdup(str);
+		ptr2 = strchr(ptr, ':');
+		if ( ptr2 ) {
+			*ptr2 = 0;
+			++ptr2;
+			hwrevs = strdup(ptr2);
+		}
+		device = strdup(ptr);
+	} else {
+		type = strdup(str);
+	}
+
+	if ( ! image->type )
+		image->type = image_type_from_string(type);
+	free(type);
+
+	if ( ! image->devices || image->devices->device || image->devices->device == DEVICE_ANY ) {
+		new_device = device_from_string(device);
+		if ( new_device ) {
+			if ( ! image->devices ) image->devices = calloc(1, sizeof(struct device_list));
+			if ( image->devices )
+				image->devices->device = new_device;
+		}
+	}
+	free(device);
+
+	if ( image->devices && image->devices->device && ! image->devices->hwrevs )
+		image->devices->hwrevs = hwrevs_alloc_from_string(hwrevs);
+	else
+		free(hwrevs);
+
+	if ( ! image->version )
+		image->version = version;
+	else
+		free(version);
+
+	free(str);
+
+}
+
+/* format: type-device:hwrevs_version */
+char * image_name_alloc_from_values(struct image * image) {
+
+	char * name;
+	char * ptr;
+	char * hwrevs;
+	size_t length;
+	const char * type;
+	const char * device;
+
+	type = image_type_to_string(image->type);
+
+	if ( ! type )
+		type = "unknown";
+
+	if ( image->devices )
+		device = device_to_string(image->devices->device);
+	else
+		device = NULL;
+
+	if ( image->devices && image->devices->hwrevs )
+		hwrevs = hwrevs_alloc_to_string(image->devices->hwrevs);
+	else
+		hwrevs = NULL;
+
+	length = 1 + strlen(type);
+
+	if ( device )
+		length += 1 + strlen(device);
+	if ( hwrevs )
+		length += 1 + strlen(hwrevs);
+	if ( image->version )
+		length += 1 + strlen(image->version);
+
+	name = calloc(1, length);
+	if ( ! name )
+		ALLOC_ERROR_RETURN(NULL);
+
+	strcpy(name, type);
+	ptr = name + strlen(name);
+
+	if ( device )
+		ptr += sprintf(ptr, "-%s", device);
+	if ( hwrevs )
+		ptr += sprintf(ptr, ":%s", hwrevs);
+	if ( image->version )
+		ptr += sprintf(ptr, "_%s", image->version);
+
+	free(hwrevs);
+
+	return name;
+
+}
+
+static int image_append(struct image * image, const char * type, const char * device, const char * hwrevs, const char * version, const char * layout) {
+
+	enum image_type detected_type;
+
+	image->hash = image_hash_from_data(image);
+
+	image->devices = calloc(1, sizeof(struct device_list));
+	if ( ! image->devices )
+		return -1;
+
+	image->devices->device = DEVICE_ANY;
+
+	if ( device && device[0] ) {
+		image->devices->device = device_from_string(device);
+		if ( ! noverify && image->devices->device == DEVICE_UNKNOWN ) {
+			ERROR("Specified Device %s is unknown", device);
+			image_free(image);
+			return -1;
+		}
+	}
+
+	detected_type = image_type_from_data(image);
+	image->type = detected_type;
+
+	if ( type && type[0] ) {
+		image->type = image_type_from_string(type);
+		if ( ! noverify && image->type == IMAGE_UNKNOWN ) {
+			ERROR("Specified Image type %s is unknown", type);
+			image_free(image);
+			return -1;
+		}
+		if ( ! noverify && detected_type != image->type && detected_type != IMAGE_UNKNOWN ) {
+			ERROR("Image type mishmash (detected %s, got %s)", image_type_to_string(detected_type), type);
+			image_free(image);
+			return -1;
+		}
+	}
+
+	if ( hwrevs && hwrevs[0] )
+		image->devices->hwrevs = hwrevs_alloc_from_string(hwrevs);
+	else
+		image->devices->hwrevs = NULL;
+
+	if ( version && version[0] )
+		image->version = strdup(version);
+	else
+		image->version = NULL;
+
+	if ( layout && layout[0] )
+		image->layout = strdup(layout);
+	else
+		image->layout = NULL;
+
+	return 0;
+
+}
+
+static void image_align(struct image * image) {
+
+	size_t align = 0;
+
+	if ( image->type == IMAGE_MMC )
+		align = 8;
+	else
+		align = 7;
+
+	if ( align == 0 )
+		return;
+
+	if ( ( image->size & ( ( 1ULL << align ) - 1 ) ) == 0 )
+		return;
+
+	align = ((image->size >> align) + 1) << align;
+
+	image->align = align - image->size;
+	image->size = align;
+
+	image->hash = image_hash_from_data(image);
+
+}
+
+static struct image * image_alloc(void) {
+
+	struct image * image = calloc(1, sizeof(struct image));
+	if ( ! image )
+		ALLOC_ERROR_RETURN(NULL);
+	return image;
+
+}
+
+struct image * image_alloc_from_file(const char * file, const char * type, const char * device, const char * hwrevs, const char * version, const char * layout) {
+
+	struct image * image = image_alloc();
+	if ( ! image )
+		return NULL;
+
+	image->is_shared_fd = 0;
+	image->fd = open(file, O_RDONLY);
+	if ( image->fd < 0 ) {
+		ERROR_INFO("Cannot open image file %s", file);
+		free(image);
+		return NULL;
+	}
+
+	image->size = lseek(image->fd, 0, SEEK_END);
+	image->offset = 0;
+	image->cur = 0;
+	image->orig_filename = strdup(file);
+	lseek(image->fd, 0, SEEK_SET);
+
+	if ( image_append(image, type, device, hwrevs, version, layout) < 0 )
+		return NULL;
+
+	if ( ( ! type || ! type[0] ) && ( ! device || ! device[0] ) && ( ! hwrevs || ! hwrevs[0] ) && ( ! version || ! version[0] ) )
+		image_missing_values_from_name(image, file);
+
+	image_align(image);
+
+	return image;
+
+}
+
+struct image * image_alloc_from_shared_fd(int fd, size_t size, size_t offset, uint16_t hash, const char * type, const char * device, const char * hwrevs, const char * version, const char * layout) {
+
+	struct image * image = image_alloc();
+	if ( ! image )
+		return NULL;
+
+	image->is_shared_fd = 1;
+	image->fd = fd;
+	image->size = size;
+	image->offset = offset;
+	image->cur = 0;
+
+	if ( image_append(image, type, device, hwrevs, version, layout) < 0 )
+		return NULL;
+
+	if ( ! noverify && image->hash != hash ) {
+		ERROR("Image hash mishmash (counted %#04x, got %#04x)", image->hash, hash);
+		image_free(image);
+		return NULL;
+	}
+
+	image_align(image);
+
+	return image;
+
+}
+
+void image_free(struct image * image) {
+
+	if ( ! image->is_shared_fd ) {
+		close(image->fd);
+		image->fd = -1;
+	}
+
+	while ( image->devices ) {
+		struct device_list * next = image->devices->next;
+		free(image->devices->hwrevs);
+		free(image->devices);
+		image->devices = next;
+	}
+
+	free(image->version);
+	free(image->layout);
+	free(image->orig_filename);
+
+	free(image);
+
+}
+
+void image_seek(struct image * image, size_t whence) {
+
+	if ( whence > image->size )
+		return;
+
+	if ( whence >= image->size - image->align ) {
+		lseek(image->fd, image->size - image->align - 1, SEEK_SET);
+		image->acur = whence - ( image->size - image->align );
+	} else {
+		lseek(image->fd, image->offset + whence, SEEK_SET);
+		image->acur = 0;
+	}
+
+	IMAGE_STORE_CUR(image);
+
+}
+
+size_t image_read(struct image * image, void * buf, size_t count) {
+
+	size_t cur;
+	ssize_t ret;
+	size_t new_count = 0;
+	size_t ret_count = 0;
+
+	IMAGE_RESTORE_CUR(image);
+
+	if ( ! image->is_shared_fd || image->cur < image->size - image->align ) {
+
+		if ( image->is_shared_fd && image->cur + count > image->size - image->align )
+			new_count = image->size - image->align - image->cur;
+		else
+			new_count = count;
+
+		ret = read(image->fd, buf, new_count);
+		if ( ret > 0 )
+			ret_count += ret;
+
+		IMAGE_STORE_CUR(image);
+
+		if ( ret < 0 )
+			return ret;
+
+	}
+
+	if ( ret_count == count )
+		return ret_count;
+
+	cur = lseek(image->fd, 0, SEEK_CUR) - image->offset;
+
+	if ( image->align && cur == image->size - image->align && image->acur < image->align ) {
+
+		if ( image->acur + count - ret_count > image->align )
+			new_count = image->align - image->acur;
+		else
+			new_count = count - ret_count;
+
+		memset((unsigned char *)buf+ret_count, 0xFF, new_count);
+		ret_count += new_count;
+		image->acur += new_count;
+
+	}
+
+	return ret_count;
+
+}
+
+void image_list_add(struct image_list ** list, struct image * image) {
+
+	struct image_list * last = calloc(1, sizeof(struct image_list));
+	if ( ! last )
+		ALLOC_ERROR_RETURN();
+
+	last->image = image;
+
+	if ( ! *list ) {
+		*list = last;
+		return;
+	}
+
+	while ( (*list)->next )
+		list = &((*list)->next);
+
+	last->prev = *list;
+	(*list)->next = last;
+
+}
+
+void image_list_del(struct image_list * list) {
+
+	if ( ! list )
+		return;
+
+	image_list_unlink(list);
+	image_free(list->image);
+	free(list);
+
+}
+
+void image_list_unlink(struct image_list * list) {
+
+	if ( ! list )
+		return;
+
+	if ( list->prev )
+		list->prev->next = list->next;
+
+	if ( list->next )
+		list->next->prev = list->prev;
+
+	list->prev = NULL;
+	list->next = NULL;
+
+}
+
+static uint16_t do_hash(uint16_t * b, int len) {
+
+	uint16_t result = 0;
+
+	for ( len >>= 1; len--; b = b+1 )
+		result^=b[0];
+
+	return result;
+
+}
+
+uint16_t image_hash_from_data(struct image * image) {
+
+	unsigned char buf[0x20000];
+	uint16_t hash = 0;
+	int ret;
+
+	image_seek(image, 0);
+	while ( ( ret = image_read(image, &buf, sizeof(buf)) ) )
+		hash ^= do_hash((uint16_t *)&buf, ret);
+
+	return hash;
+}
+
+static const char * image_types[] = {
+	[IMAGE_XLOADER] = "xloader",
+	[IMAGE_2ND] = "2nd",
+	[IMAGE_SECONDARY] = "secondary",
+	[IMAGE_KERNEL] = "kernel",
+	[IMAGE_INITFS] = "initfs",
+	[IMAGE_ROOTFS] = "rootfs",
+	[IMAGE_MMC] = "mmc",
+	[IMAGE_CMT_2ND] = "cmt-2nd",
+	[IMAGE_CMT_ALGO] = "cmt-algo",
+	[IMAGE_CMT_MCUSW] = "cmt-mcusw",
+};
+
+enum image_type image_type_from_data(struct image * image) {
+
+	unsigned char buf[512];
+
+	memset(buf, 0, sizeof(buf));
+	image_seek(image, 0);
+	image_read(image, buf, sizeof(buf));
+
+	if ( memcmp(buf+52, "2NDAPE", 6) == 0 )
+		return IMAGE_2ND;
+	else if ( memcmp(buf+20, "2ND", 3) == 0 )
+		return IMAGE_2ND;
+	else if ( memcmp(buf+4, "NOLOScnd", 8) == 0 )
+		return IMAGE_SECONDARY;
+	else if ( memcmp(buf+20, "X-LOADER", 8) == 0 )
+		return IMAGE_XLOADER;
+	else if ( memcmp(buf+12, "NOLOXldr", 8) == 0 )
+		return IMAGE_XLOADER;
+	else if ( memcmp(buf+4, "NOLOXldr", 8) == 0 )
+		return IMAGE_2ND;
+	else if ( memcmp(buf+36, "\x18\x28\x6f\x01", 4) == 0 ) /* ARM Linux kernel magic number */
+		return IMAGE_KERNEL;
+	else if ( memcmp(buf, "\x14\x00\x00\xea", 4) == 0 ) /* ARM U-Boot - instruction branch +0x50 */
+		return IMAGE_KERNEL;
+	else if ( memcmp(buf, "UBI#", 4) == 0 ) /* UBI EC header */
+		return IMAGE_ROOTFS;
+	else if ( memcmp(buf+510, "\x55\xaa", 2) == 0 ) /* FAT boot sector signature */
+		return IMAGE_MMC;
+	else if ( memcmp(buf, "\xb0\x00\x01\x03\x9d\x00\x00\x00", 8) == 0 )
+		return IMAGE_CMT_2ND;
+	else if ( memcmp(buf, "\xb1\x00\x00\x00\x82\x00\x00\x00", 8) == 0 )
+		return IMAGE_CMT_ALGO;
+	else if ( memcmp(buf, "\xb2\x00\x00\x01\x44\x00\x00\x00", 8) == 0 )
+		return IMAGE_CMT_MCUSW;
+	else if ( memcmp(buf, "\x45\x3d\xcd\x28", 4) == 0 ) /* CRAMFS MAGIC */
+		return IMAGE_INITFS;
+	else if ( memcmp(buf, "\x85\x19", 2) == 0 ) { /* JFFS2 MAGIC */
+		if ( image->size < 0x300000 )
+			return IMAGE_INITFS;
+		else
+			return IMAGE_ROOTFS;
+	}
+
+	return IMAGE_UNKNOWN;
+
+}
+
+enum image_type image_type_from_string(const char * type) {
+
+	size_t i;
+
+	if ( ! type )
+		return IMAGE_UNKNOWN;
+
+	for ( i = 0; i < sizeof(image_types)/sizeof(image_types[0]); ++i )
+		if ( image_types[i] && strcmp(image_types[i], type) == 0 )
+			return i;
+
+	return IMAGE_UNKNOWN;
+
+}
+
+const char * image_type_to_string(enum image_type type) {
+
+	if ( type > sizeof(image_types)/sizeof(image_types[0]) )
+		return NULL;
+
+	return image_types[type];
+
+}
+
+int image_hwrev_is_valid(struct image * image, int16_t hwrev) {
+
+	struct device_list * device_ptr = image->devices;
+
+	while ( device_ptr ) {
+		if ( hwrev_is_valid(device_ptr->hwrevs, hwrev) )
+			return 1;
+		device_ptr = device_ptr->next;
+	}
+
+	return 0;
+
+}
+
+void image_print_info(struct image * image) {
+
+	const char * str;
+	struct device_list * device = image->devices;
+
+	if ( image->orig_filename )
+		printf("File: %s\n", image->orig_filename);
+
+	str = image_type_to_string(image->type);
+	printf("    Image type: %s\n", str ? str : "unknown");
+	printf("    Image size: %d bytes\n", image->size);
+
+	if ( image->version )
+		printf("    Image version: %s\n", image->version);
+
+	if ( image->layout )
+		printf("    Image layout: included\n");
+
+	while ( device ) {
+
+		char * str2 = NULL;
+		struct device_list * next = device->next;
+
+		if ( device->device == DEVICE_UNKNOWN )
+			str = "unknown";
+		else
+			str = device_to_string(device->device);
+
+		if ( str )
+			printf("    Valid for: device %s", str);
+
+		if ( str && device->hwrevs )
+			str2 = hwrevs_alloc_to_string(device->hwrevs);
+
+		if ( str2 ) {
+			printf(", HW revisions: %s\n", str2);
+			free(str2);
+		} else if ( str ) {
+			printf("\n");
+		}
+
+		device = next;
+	}
+
+}

src/image.h

@@ -0,0 +1,83 @@
+/*
+    0xFFFF - Open Free Fiasco Firmware Flasher
+    Copyright (C) 2012  Pali Rohár <pali.rohar@gmail.com>
+
+    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 3 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, see <http://www.gnu.org/licenses/>.
+
+*/
+
+#ifndef IMAGE_H
+#define IMAGE_H
+
+#include <stdint.h>
+#include <sys/types.h>
+
+#include "device.h"
+
+enum image_type {
+	IMAGE_UNKNOWN = 0,
+	IMAGE_XLOADER,
+	IMAGE_2ND,
+	IMAGE_SECONDARY,
+	IMAGE_KERNEL,
+	IMAGE_INITFS,
+	IMAGE_ROOTFS,
+	IMAGE_MMC,
+	IMAGE_CMT_2ND,
+	IMAGE_CMT_ALGO,
+	IMAGE_CMT_MCUSW,
+	IMAGE_COUNT,
+};
+
+struct image {
+	enum image_type type;
+	struct device_list * devices;
+	char * version;
+	char * layout;
+	uint16_t hash;
+	uint32_t size;
+
+	int fd;
+	int is_shared_fd;
+	uint32_t align;
+	size_t offset;
+	size_t cur;
+	size_t acur;
+	char * orig_filename;
+};
+
+struct image_list {
+	struct image * image;
+	struct image_list * prev;
+	struct image_list * next;
+};
+
+struct image * image_alloc_from_file(const char * file, const char * type, const char * device, const char * hwrevs, const char * version, const char * layout);
+struct image * image_alloc_from_shared_fd(int fd, size_t size, size_t offset, uint16_t hash, const char * type, const char * device, const char * hwrevs, const char * version, const char * layout);
+void image_free(struct image * image);
+void image_seek(struct image * image, size_t whence);
+size_t image_read(struct image * image, void * buf, size_t count);
+void image_print_info(struct image * image);
+void image_list_add(struct image_list ** list, struct image * image);
+void image_list_del(struct image_list * list);
+void image_list_unlink(struct image_list * list);
+
+uint16_t image_hash_from_data(struct image * image);
+enum image_type image_type_from_data(struct image * image);
+char * image_name_alloc_from_values(struct image * image);
+enum image_type image_type_from_string(const char * type);
+const char * image_type_to_string(enum image_type type);
+int image_hwrev_is_valid(struct image * image, int16_t hwrev);
+
+#endif

src/libusb-sniff.c

@@ -0,0 +1,194 @@
+/*
+    libusb-sniff.c - Library for usb sniffing nokia's flasher-3.5
+    Copyright (C) 2011-2012  Pali Rohár <pali.rohar@gmail.com>
+
+    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 3 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, see <http://www.gnu.org/licenses/>.
+
+*/
+
+/* compile: gcc libusb-sniff.c -o libusb-sniff.so -W -Wall -O2 -fPIC -ldl -shared -m32 */
+/* usage: sudo USBSNIFF_WAIT=1 LD_PRELOAD=./libusb-sniff.so flasher-3.5 ... */
+/* usage: sudo USBSNIFF_SKIP_READ=1 USBSNIFF_SKIP_WRITE=1 LD_PRELOAD=./libusb-sniff.so flasher-3.5 ... */
+
+#define _GNU_SOURCE
+#include <stdio.h>
+#include <dlfcn.h>
+#include <usb.h>
+
+static char to_ascii(char c) {
+
+	if ( c >= 32 && c <= 126 )
+		return c;
+	return '.';
+
+}
+
+static void dump_bytes(const char * buf, size_t size) {
+
+	size_t i, ascii_cnt = 0;
+	char ascii[17] = { 0, };
+
+	for ( i = 0; i < size; i++ ) {
+		if ( i % 16 == 0 ) {
+			if ( i != 0 ) {
+				printf("  |%s|\n", ascii);
+				ascii[0] = 0;
+				ascii_cnt = 0;
+			}
+			printf("%04X:", (unsigned int)i);
+		}
+		printf(" %02X", buf[i] & 0xFF);
+		ascii[ascii_cnt] = to_ascii(buf[i]);
+		ascii[ascii_cnt + 1] = 0;
+		ascii_cnt++;
+	}
+
+	if ( ascii[0] ) {
+		if ( size % 16 )
+			for ( i = 0; i < 16 - (size % 16); i++ )
+				printf("   ");
+		printf("  |%s|\n", ascii);
+	}
+
+}
+
+int usb_bulk_write(usb_dev_handle * dev, int ep, const char * bytes, int size, int timeout) {
+
+	static int (*real_usb_bulk_write)(usb_dev_handle * dev, int ep, const char * bytes, int size, int timeout) = NULL;
+
+	if ( ! real_usb_bulk_write )
+		real_usb_bulk_write = dlsym(RTLD_NEXT, "usb_bulk_write");
+
+	if ( ! getenv("USBSNIFF_SKIP_WRITE") ) {
+
+		printf("\n==== usb_bulk_write (ep=%d size=%d timeout=%d) ====\n", ep, size, timeout);
+		dump_bytes(bytes, size);
+		printf("====\n");
+
+		if ( getenv("USBSNIFF_WAIT") ) {
+			printf("Press ENTER"); fflush(stdout); getchar();
+		}
+
+	}
+
+	return real_usb_bulk_write(dev, ep, bytes, size, timeout);
+
+}
+
+int usb_bulk_read(usb_dev_handle * dev, int ep, char * bytes, int size, int timeout) {
+
+	static int (*real_usb_bulk_read)(usb_dev_handle * dev, int ep, char * bytes, int size, int timeout) = NULL;
+	int ret;
+
+	if ( ! real_usb_bulk_read )
+		real_usb_bulk_read = dlsym(RTLD_NEXT, "usb_bulk_read");
+
+	ret = real_usb_bulk_read(dev, ep, bytes, size, timeout);
+
+	if ( ! getenv("USBSNIFF_SKIP_READ") ) {
+
+		printf("\n==== usb_bulk_read (ep=%d size=%d timeout=%d) ret = %d ====\n", ep, size, timeout, ret);
+		if ( ret > 0 ) {
+			dump_bytes(bytes, ret);
+			printf("====\n");
+		}
+
+		if ( getenv("USBSNIFF_WAIT") ) {
+			printf("Press ENTER"); fflush(stdout); getchar();
+		}
+
+	}
+
+	return ret;
+
+}
+
+int usb_control_msg(usb_dev_handle *dev, int requesttype, int request, int value, int index, char *bytes, int size, int timeout) {
+
+	static int (*real_usb_control_msg)(usb_dev_handle *dev, int requesttype, int request, int value, int index, char *bytes, int size, int timeout) = NULL;
+	int ret;
+
+	if ( ! real_usb_control_msg )
+		real_usb_control_msg = dlsym(RTLD_NEXT, "usb_control_msg");
+
+	if ( requesttype == 64 && ! getenv("USBSNIFF_SKIP_CONTROL") ) {
+
+		printf("\n==== usb_control_msg(requesttype=%d, request=%d, value=%d, index=%d, size=%d, timeout=%d) ====\n", requesttype, request, value, index, size, timeout);
+		dump_bytes(bytes, size);
+		printf("====\n");
+
+		if ( getenv("USBSNIFF_WAIT") ) {
+			printf("Press ENTER"); fflush(stdout); getchar();
+		}
+
+	}
+
+	ret = real_usb_control_msg(dev, requesttype, request, value, index, bytes, size, timeout);
+
+	if ( requesttype != 64 && ! getenv("USBSNIFF_SKIP_CONTROL") ) {
+
+		printf("\n==== usb_control_msg(requesttype=%d, request=%d, value=%d, index=%d, size=%d, timeout=%d) ret = %d ====\n", requesttype, request, value, index, size, timeout, ret);
+		if ( ret > 0 ) {
+			dump_bytes(bytes, ret);
+			printf("====\n");
+		}
+
+		if ( getenv("USBSNIFF_WAIT") ) {
+			printf("Press ENTER"); fflush(stdout); getchar();
+		}
+
+	}
+
+	return ret;
+
+}
+
+int usb_set_configuration(usb_dev_handle *dev, int configuration) {
+
+	static int (*real_usb_set_configuration)(usb_dev_handle *dev, int configuration) = NULL;
+
+	if ( ! real_usb_set_configuration )
+		real_usb_set_configuration = dlsym(RTLD_NEXT, "usb_set_configuration");
+
+	printf("\n==== usb_set_configuration (configuration=%d) ====\n", configuration);
+
+	return real_usb_set_configuration(dev, configuration);
+
+}
+
+int usb_claim_interface(usb_dev_handle *dev, int interface) {
+
+	static int (*real_usb_claim_interface)(usb_dev_handle *dev, int interface) = NULL;
+
+	if ( ! real_usb_claim_interface )
+		real_usb_claim_interface = dlsym(RTLD_NEXT, "usb_claim_interface");
+
+	printf("\n==== usb_claim_interface (interface=%d) ====\n", interface);
+
+	return real_usb_claim_interface(dev, interface);
+
+}
+
+int usb_set_altinterface(usb_dev_handle *dev, int alternate) {
+
+	static int (*real_usb_set_altinterface)(usb_dev_handle *dev, int alternate) = NULL;
+
+	if ( ! real_usb_set_altinterface )
+		real_usb_set_altinterface = dlsym(RTLD_NEXT, "usb_set_altinterface");
+
+	printf("\n==== usb_set_altinterface (alternate=%d) ====\n", alternate);
+
+	return real_usb_set_altinterface(dev, alternate);
+
+}

src/local.c

@@ -0,0 +1,615 @@
+/*
+    0xFFFF - Open Free Fiasco Firmware Flasher
+    Copyright (C) 2012  Pali Rohár <pali.rohar@gmail.com>
+
+    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 3 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, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include <sys/statvfs.h>
+#include <sys/types.h>
+#include <sys/mman.h>
+
+#include <libgen.h>
+#include <unistd.h>
+#include <fcntl.h>
+#include <dirent.h>
+
+#include "local.h"
+#include "global.h"
+#include "device.h"
+#include "image.h"
+#include "cal.h"
+#include "disk.h"
+
+static int failed;
+
+static enum device device = DEVICE_UNKNOWN;
+static int16_t hwrev = -1;
+static char kernel_ver[256];
+static char initfs_ver[256];
+static char nolo_ver[256];
+static char sw_ver[256];
+static char content_ver[256];
+static char rd_mode[256];
+static int usb_host_mode = -1;
+static int root_device = -1;
+
+#define min(a, b) (a < b ? a : b)
+#define local_cal_copy(dest, from, len) strncpy(dest, from, min(len, sizeof(dest)-1))
+#define local_cal_read(cal, str, ptr, len) ( cal_read_block(cal, str, &ptr, &len, 0) == 0 && ptr )
+#define local_cal_store(cal, str, dest) do { void * ptr; unsigned long int len; if ( local_cal_read(cal, str, ptr, len) ) local_cal_copy(dest, ptr, len); } while ( 0 )
+
+static void local_cal_parse(void) {
+
+	struct cal * cal = NULL;
+	char buf[128];
+
+	printf("Reading CAL...\n");
+
+	if ( cal_init(&cal) < 0 || ! cal )
+		return;
+
+	local_cal_store(cal, "kernel-ver", kernel_ver);
+	local_cal_store(cal, "initfs-ver", kernel_ver);
+	local_cal_store(cal, "nolo-ver", nolo_ver);
+	local_cal_store(cal, "sw-release-ver", sw_ver);
+	local_cal_store(cal, "content-ver", content_ver);
+	local_cal_store(cal, "r&d_mode", rd_mode);
+
+	/* overwritten hw revision */
+	memset(buf, 0, sizeof(buf));
+	local_cal_store(cal, "hw-ver", buf);
+
+	if ( buf[0] && sscanf(buf, "%hd", &hwrev) != 1 )
+		hwrev = -1;
+
+	if ( hwrev == -1 ) {
+
+		/* original hw revision */
+		memset(buf, 0, sizeof(buf));
+		local_cal_store(cal, "phone-info", buf);
+		buf[4] = 0;
+
+		if ( buf[0] && sscanf(buf, "%hd", &hwrev) != 1 )
+			hwrev = -1;
+
+	}
+
+	buf[0] = 0;
+	local_cal_store(cal, "usb_host_mode", buf);
+	usb_host_mode = buf[0];
+
+	memset(buf, 0, sizeof(buf));
+	local_cal_store(cal, "root_device", buf);
+
+	if ( strcmp(buf, "mmc") == 0 )
+		root_device = 1;
+	else if ( strcmp(buf, "usb") == 0 )
+		root_device = 2;
+	else
+		root_device = 0;
+
+	cal_finish(cal);
+
+}
+
+int local_init(void) {
+
+	char buf[1024];
+	char * ptr;
+	char * ptr2;
+	FILE * file;
+
+	if ( failed )
+		return -1;
+
+	file = fopen("/proc/cpuinfo", "r");
+	if ( ! file ) {
+		failed = 1;
+		return -1;
+	}
+
+	while ( fgets(buf, sizeof(buf), file) ) {
+
+		if ( strncmp(buf, "Hardware", strlen("Hardware")) == 0 ) {
+
+			ptr = buf + strlen("Hardware");
+
+			while ( ptr < buf + sizeof(buf) && *ptr > 0 && *ptr <= 32 )
+				++ptr;
+
+			if ( *ptr != ':' )
+				continue;
+
+			++ptr;
+
+			while ( ptr < buf + sizeof(buf) && *ptr > 0 && *ptr <= 32 )
+				++ptr;
+
+			if ( ! *ptr )
+				continue;
+
+			ptr2 = buf + strlen(buf);
+
+			while ( *ptr2 <= 32 ) {
+				*ptr2 = 0;
+				--ptr2;
+			}
+
+			if ( strcmp(ptr, "Nokia 770") == 0 )
+				device = DEVICE_SU_18;
+			else if ( strcmp(ptr, "Nokia N800") == 0 )
+				device = DEVICE_RX_34;
+			else if ( strcmp(ptr, "Nokia N810") == 0 )
+				device = DEVICE_RX_44;
+			else if ( strcmp(ptr, "Nokia N810 WiMAX") == 0 )
+				device = DEVICE_RX_48;
+			else if ( strcmp(ptr, "Nokia RX-51 board") == 0 )
+				device = DEVICE_RX_51;
+
+			if ( device ) {
+				printf("Found local device: %s\n", device_to_long_string(device));
+				fclose(file);
+				local_cal_parse();
+				return 0;
+			}
+
+		}
+
+	}
+
+	failed = 1;
+	printf("Not a local device\n");
+	fclose(file);
+	return -1;
+
+}
+
+enum device local_get_device(void) {
+
+	return device;
+
+}
+
+int local_flash_image(struct image * image) {
+
+	ERROR("Not implemented yet");
+	(void)image;
+	return -1;
+
+}
+
+static int local_nanddump(const char * file, int mtd, int offset, int length) {
+
+	struct statvfs buf;
+	char * command;
+	char * path;
+	size_t size;
+	int ret;
+
+	path = strdup(file);
+	if ( ! path )
+		return 1;
+
+	ret = statvfs(dirname(path), &buf);
+
+	free(path);
+
+	if ( ret == 0 && buf.f_bsize * buf.f_bfree < (long unsigned int)length ) {
+		ERROR("Not enought free space (have: %lu, need: %d)", buf.f_bsize * buf.f_bfree, length);
+		return 1;
+	}
+
+	size = snprintf(NULL, 0, "nanddump -i -o -b -s %d -l %d -f %s /dev/mtd%dro", offset, length, file, mtd);
+
+	command = malloc(size+1);
+	if ( ! command )
+		return 1;
+
+	snprintf(command, size+1, "nanddump -i -o -b -s %d -l %d -f %s /dev/mtd%dro", offset, length, file, mtd);
+
+	ret = system(command);
+
+	free(command);
+
+	return ret;
+
+}
+
+struct nanddump_args {
+	int valid;
+	int mtd;
+	int offset;
+	int length;
+};
+
+static struct nanddump_args nanddump_n900[] = {
+	[IMAGE_XLOADER]   = { 1, 0, 0x00000000, 0x00004000 },
+	[IMAGE_SECONDARY] = { 1, 0, 0x00004000, 0x0001C000 },
+	[IMAGE_KERNEL]    = { 1, 3, 0x00000800, 0x001FF800 },
+	[IMAGE_INITFS]    = { 1, 4, 0x00000800, 0x001FF800 },
+	[IMAGE_ROOTFS]    = { 1, 5, 0x00000000, 0x0fb40000 },
+};
+
+/* FIXME: Is this table correct? */
+static struct nanddump_args nanddump[] = {
+	[IMAGE_XLOADER]   = { 1, 0, 0x00000200, 0x00003E00 },
+	[IMAGE_SECONDARY] = { 1, 0, 0x00004000, 0x0001C000 },
+	[IMAGE_KERNEL]    = { 1, 2, 0x00000800, 0x001FF800 },
+	[IMAGE_INITFS]    = { 1, 3, 0x00000800, 0x001FF800 },
+	[IMAGE_ROOTFS]    = { 1, 4, 0x00000000, 0x0fb80000 },
+};
+
+int local_dump_image(enum image_type image, const char * file) {
+
+	int ret = -1;
+	int fd = -1;
+	unsigned char * addr = NULL;
+	off_t nlen, len;
+	int align;
+	DIR * dir;
+	DIR * dir2;
+	struct dirent * dirent;
+	struct dirent * dirent2;
+	char * ptr;
+	int i;
+	char buf[1024];
+	char blk[1024];
+
+	printf("Dump %s image to file %s...\n", image_type_to_string(image), file);
+
+	if ( image == IMAGE_MMC ) {
+
+		/* Find block device in /dev/ for MyDocs (mmc device, partition 1) */
+
+		dir = opendir("/sys/class/mmc_host/");
+		if ( ! dir ) {
+			ERROR("Cannot find MyDocs mmc device");
+			goto clean;
+		}
+
+		blk[0] = 0;
+
+		while ( ( dirent = readdir(dir) ) ) {
+
+			snprintf(buf, sizeof(buf), "/sys/class/mmc_host/%s/slot_name", dirent->d_name);
+
+			fd = open(buf, O_RDONLY);
+			if ( fd < 0 )
+				continue;
+
+			buf[0] = 0;
+			read(fd, buf, sizeof(buf));
+			close(fd);
+
+			if ( strncmp(buf, "internal", strlen("internal")) != 0 )
+				continue;
+
+			snprintf(buf, sizeof(buf), "/sys/class/mmc_host/%s/%s:0001", dirent->d_name, dirent->d_name);
+
+			dir2 = opendir(buf);
+			if ( ! dir2 )
+				continue;
+
+			while ( ( dirent2 = readdir(dir2) ) ) {
+
+				if ( strncmp(dirent2->d_name, "block:mmcblk", strlen("block:mmcblk")) != 0 )
+					continue;
+
+				snprintf(buf, sizeof(buf), "/sys/class/mmc_host/%s/%s:0001/%s", dirent->d_name, dirent->d_name, dirent2->d_name);
+
+				blk[0] = 0;
+				if ( readlink(buf, blk, sizeof(blk)) < 0 )
+					continue;
+
+				ptr = strrchr(blk, '/');
+				if ( ! ptr ) {
+					blk[0] = 0;
+					continue;
+				}
+
+				strcpy(blk, "/dev/");
+				i = strlen("/dev/");
+				++ptr;
+
+				while ( *ptr )
+					blk[i++] = *(ptr++);
+
+				strcpy(blk+i, "p1");
+				break;
+
+			}
+
+			closedir(dir2);
+
+			if ( blk[0] )
+				break;
+
+		}
+
+		closedir(dir);
+
+		if ( ! blk[0] ) {
+			ERROR("Cannot find MyDocs mmc device");
+			goto clean;
+		}
+
+		ret = disk_dump_raw(blk, image_type_to_string(image));
+
+	} else {
+
+		if ( device == DEVICE_RX_51 ) {
+
+			if ( image >= sizeof(nanddump_n900)/sizeof(nanddump_n900[0]) || ! nanddump_n900[image].valid ) {
+				ERROR("Unsuported image type: %s", image_type_to_string(image));
+				goto clean;
+			}
+
+			ret = local_nanddump(file, nanddump_n900[image].mtd, nanddump_n900[image].offset, nanddump_n900[image].length);
+
+		} else {
+
+			if ( image >= sizeof(nanddump)/sizeof(nanddump[0]) || ! nanddump[image].valid ) {
+				ERROR("Unsuported image type: %s", image_type_to_string(image));
+				goto clean;
+			}
+
+			ret = local_nanddump(file, nanddump[image].mtd, nanddump[image].offset, nanddump[image].length);
+
+		}
+
+	}
+
+	if ( ret != 0 ) {
+		ret = -1;
+		goto clean;
+	}
+
+	fd = open(file, O_RDWR);
+	if ( fd < 0 )
+		goto clean;
+
+	len = lseek(fd, 0, SEEK_END);
+	if ( len == (off_t)-1 || len == 0 )
+		goto clean;
+
+	addr = mmap(NULL, len, PROT_READ, MAP_PRIVATE, fd, 0);
+
+	if ( addr == MAP_FAILED )
+		addr = NULL;
+
+	if ( ! addr )
+		goto clean;
+
+	for ( nlen = len; nlen > 0; --nlen )
+		if ( addr[nlen-1] != 0xFF )
+			break;
+
+	if ( image == IMAGE_MMC )
+		align = 8;
+	else
+		align = 7;
+
+	if ( ( nlen & ( ( 1ULL << align ) - 1 ) ) != 0 )
+		nlen = ((nlen >> align) + 1) << align;
+
+	if ( nlen == 0 ) {
+		printf("File %s is empty, removing it...\n", file);
+		unlink(file);
+	} else if ( nlen != len ) {
+		printf("Truncating file %s to %d bytes...\n", file, (int)nlen);
+		ftruncate(fd, nlen);
+	}
+
+clean:
+	if ( addr )
+		munmap(addr, len);
+
+	if ( fd >= 0 )
+		close(fd);
+
+	printf("\n");
+	return ret;
+
+}
+
+int local_check_badblocks(const char * device) {
+
+	ERROR("Not implemented yet");
+	(void)device;
+	return -1;
+
+}
+
+int local_reboot_device(void) {
+
+	if ( system("dsmetool -b") == 0 )
+		return 0;
+	return system("reboot");
+
+}
+
+int local_get_root_device(void) {
+
+	return root_device;
+
+}
+
+int local_set_root_device(int device) {
+
+	ERROR("Not implemented yet");
+	(void)device;
+	return -1;
+
+}
+
+int local_get_usb_host_mode(void) {
+
+	return usb_host_mode;
+
+}
+
+int local_set_usb_host_mode(int enable) {
+
+	ERROR("Not implemented yet");
+	(void)enable;
+	return -1;
+
+}
+
+int local_get_rd_mode(void) {
+
+	if ( strncmp(rd_mode, "master", strlen("master")) == 0 )
+		return 1;
+	else
+		return 0;
+
+}
+
+int local_set_rd_mode(int enable) {
+
+	ERROR("Not implemented yet");
+	(void)enable;
+	return -1;
+
+}
+
+int local_get_rd_flags(char * flags, size_t size) {
+
+	const char * ptr;
+
+	if ( strncmp(rd_mode, "master", strlen("master")) == 0 )
+		ptr = rd_mode + strlen("master");
+	else
+		ptr = rd_mode;
+
+	if ( *ptr == ',' )
+		++ptr;
+
+	if ( ! *ptr ) {
+		flags[0] = 0;
+		return 0;
+	}
+
+	strncpy(flags, ptr, size);
+	flags[size-1] = 0;
+	return 0;
+
+}
+
+int local_set_rd_flags(const char * flags) {
+
+	ERROR("Not implemented yet");
+	(void)flags;
+	return -1;
+
+}
+
+int16_t local_get_hwrev(void) {
+
+	return hwrev;
+
+}
+
+int local_set_hwrev(int16_t hwrev) {
+
+	ERROR("Not implemented yet");
+	(void)hwrev;
+	return -1;
+
+}
+
+int local_get_kernel_ver(char * ver, size_t size) {
+
+	strncpy(ver, kernel_ver, size);
+	ver[size-1] = 0;
+	return 0;
+
+}
+
+int local_set_kernel_ver(const char * ver) {
+
+	ERROR("Not implemented yet");
+	(void)ver;
+	return -1;
+
+}
+
+int local_get_initfs_ver(char * ver, size_t size) {
+
+	strncpy(ver, initfs_ver, size);
+	ver[size-1] = 0;
+	return 0;
+
+}
+
+int local_set_initfs_ver(const char * ver) {
+
+	ERROR("Not implemented yet");
+	(void)ver;
+	return -1;
+
+}
+
+int local_get_nolo_ver(char * ver, size_t size) {
+
+	strncpy(ver, nolo_ver, size);
+	ver[size-1] = 0;
+	return 0;
+
+}
+
+int local_set_nolo_ver(const char * ver) {
+
+	ERROR("Not implemented yet");
+	(void)ver;
+	return -1;
+
+}
+
+int local_get_sw_ver(char * ver, size_t size) {
+
+	strncpy(ver, sw_ver, size);
+	ver[size-1] = 0;
+	return 0;
+
+}
+
+int local_set_sw_ver(const char * ver) {
+
+	ERROR("Not implemented yet");
+	(void)ver;
+	return -1;
+
+}
+
+int local_get_content_ver(char * ver, size_t size) {
+
+	strncpy(ver, content_ver, size);
+	ver[size-1] = 0;
+	return 0;
+
+}
+
+int local_set_content_ver(const char * ver) {
+
+	ERROR("Not implemented yet");
+	(void)ver;
+	return -1;
+
+}

src/local.h

@@ -0,0 +1,65 @@
+/*
+    0xFFFF - Open Free Fiasco Firmware Flasher
+    Copyright (C) 2012  Pali Rohár <pali.rohar@gmail.com>
+
+    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 3 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, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef LOCAL_H
+#define LOCAL_H
+
+#include "image.h"
+#include "device.h"
+
+int local_init(void);
+
+enum device local_get_device(void);
+
+int local_flash_image(struct image * image);
+int local_dump_image(enum image_type image, const char * file);
+int local_check_badblocks(const char * device);
+
+int local_reboot_device(void);
+
+int local_get_root_device(void);
+int local_set_root_device(int device);
+
+int local_get_usb_host_mode(void);
+int local_set_usb_host_mode(int enable);
+
+int local_get_rd_mode(void);
+int local_set_rd_mode(int enable);
+
+int local_get_rd_flags(char * flags, size_t size);
+int local_set_rd_flags(const char * flags);
+
+int16_t local_get_hwrev(void);
+int local_set_hwrev(int16_t hwrev);
+
+int local_get_kernel_ver(char * ver, size_t size);
+int local_set_kernel_ver(const char * ver);
+
+int local_get_initfs_ver(char * ver, size_t size);
+int local_set_initfs_ver(const char * ver);
+
+int local_get_nolo_ver(char * ver, size_t size);
+int local_set_nolo_ver(const char * ver);
+
+int local_get_sw_ver(char * ver, size_t size);
+int local_set_sw_ver(const char * ver);
+
+int local_get_content_ver(char * ver, size_t size);
+int local_set_content_ver(const char * ver);
+
+#endif

src/main.h

@@ -1,100 +0,0 @@
-
-#ifndef _INCLUDE_MAIN_H_
-#define _INCLUDE_MAIN_H_
-
-#define _FILE_OFFSET_BITS 64
-#define _GNU_SOURCE
-
-// Forward declaration for use in function arguments.
-struct devices;
-
-int reverse_extract_pieces(char *dir);
-void flash_image(char *filename, char *piece, char *version);
-int fiasco_read_image(char *file);
-void check_nolo_order();
-extern struct usb_dev_handle *dev;
-unsigned long get_file_size(char *file);
-void progressbar(unsigned long long part, unsigned long long total);
-const char *fpid_file(const char *filename);
-int add_piece(char *piece);
-
-#include <usb.h>
-
-extern struct usb_device *device;
-extern struct usb_dev_handle *dev;
-int is_valid_device(struct usb_device_descriptor *udd);
-void list_valid_devices();
-int usb_device_found(struct usb_device_descriptor *udd, struct devices *it_device);
-int console(const char *device);
-int connect_via_usb();
-int console_prompt();
-
-//
-void cmd_info(char *line);
-int check_badblocks(char *mtddev);
-int dump_config();
-
-extern int verbose;
-#define D if (verbose)
-
-#define CMD_WRITE 64
-#define CMD_QUERY 192
-
-#define NOLO_GET_STATUS   1
-#define NOLO_GET_BOARD_ID 2
-#define NOLO_GET_VERSION  3
-
-struct piece_t {
-	char *name;
-	char *type;
-	char *vers;
-};
-
-struct devices {
-  char *name;
-  unsigned short vendor_id;
-  unsigned short product_id;
-  unsigned short flags;
-};
-
-#define SUPPORTED_DEVICES 6
-extern struct devices supported_devices[SUPPORTED_DEVICES];
-
-extern int pcs_n;
-extern struct piece_t pcs[10];
-
-enum {
-	PIECE_XLOADER = 0,
-	PIECE_2ND,
-	PIECE_SECONDARY,
-	PIECE_KERNEL,
-	PIECE_INITFS,
-	PIECE_ROOTFS,
-	PIECE_OMAPNAND,
-	PIECE_LAST
-};
-
-extern char *pieces[];
-extern char *modes[];
-extern char *root_devices[];
-
-// fiasco
-int openfiasco(char *name);
-int fiasco_new(const char *filename, const char *name);
-void fiasco_data_read(struct header_t *header);
-int fiasco_add_eof(int fd);
-extern void (*fiasco_callback)(struct header_t *header);
-int fiasco_add(int fd, const char *name, const char *file, const char *version);
-int fiasco_pack(int optind, char *argv[]);
-struct header_t {
-	int fd;
-	char fwname[128];
-	char name[128];
-	char version[128];
-	unsigned short hash;
-	unsigned int size;
-	unsigned char *data;
-};
-
-
-#endif

src/mkii.c

@@ -0,0 +1,239 @@
+/*
+    0xFFFF - Open Free Fiasco Firmware Flasher
+    Copyright (C) 2012  Pali Rohár <pali.rohar@gmail.com>
+
+    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 3 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, see <http://www.gnu.org/licenses/>.
+
+*/
+
+#include "mkii.h"
+#include "global.h"
+#include "image.h"
+#include "device.h"
+#include "usb-device.h"
+
+int mkii_init(struct usb_device_info * dev) {
+
+	ERROR("Mk II protocol is not implemented yet");
+	(void)dev;
+	return -1;
+
+}
+
+enum device mkii_get_device(struct usb_device_info * dev) {
+
+	ERROR("Not implemented yet");
+	(void)dev;
+	return DEVICE_UNKNOWN;
+
+}
+
+int mkii_flash_image(struct usb_device_info * dev, struct image * image) {
+
+	ERROR("Not implemented yet");
+	(void)dev;
+	(void)image;
+	return -1;
+
+}
+
+int mkii_reboot_device(struct usb_device_info * dev) {
+
+	ERROR("Not implemented yet");
+	(void)dev;
+	return -1;
+
+}
+
+int mkii_get_root_device(struct usb_device_info * dev) {
+
+	ERROR("Not implemented yet");
+	(void)dev;
+	return -1;
+
+}
+
+int mkii_set_root_device(struct usb_device_info * dev, int device) {
+
+	ERROR("Not implemented yet");
+	(void)dev;
+	(void)device;
+	return -1;
+
+}
+
+int mkii_get_usb_host_mode(struct usb_device_info * dev) {
+
+	ERROR("Not implemented yet");
+	(void)dev;
+	return -1;
+
+}
+
+int mkii_set_usb_host_mode(struct usb_device_info * dev, int enable) {
+
+	ERROR("Not implemented yet");
+	(void)dev;
+	(void)enable;
+	return -1;
+
+}
+
+int mkii_get_rd_mode(struct usb_device_info * dev) {
+
+	ERROR("Not implemented yet");
+	(void)dev;
+	return -1;
+
+}
+
+int mkii_set_rd_mode(struct usb_device_info * dev, int enable) {
+
+	ERROR("Not implemented yet");
+	(void)dev;
+	(void)enable;
+	return -1;
+
+}
+
+int mkii_get_rd_flags(struct usb_device_info * dev, char * flags, size_t size) {
+
+	ERROR("Not implemented yet");
+	(void)dev;
+	(void)flags;
+	(void)size;
+	return -1;
+
+}
+
+int mkii_set_rd_flags(struct usb_device_info * dev, const char * flags) {
+
+	ERROR("Not implemented yet");
+	(void)dev;
+	(void)flags;
+	return -1;
+
+}
+
+int16_t mkii_get_hwrev(struct usb_device_info * dev) {
+
+	ERROR("Not implemented yet");
+	(void)dev;
+	return -1;
+
+}
+
+int mkii_set_hwrev(struct usb_device_info * dev, int16_t hwrev) {
+
+	ERROR("Not implemented yet");
+	(void)dev;
+	(void)hwrev;
+	return -1;
+
+}
+
+int mkii_get_kernel_ver(struct usb_device_info * dev, char * ver, size_t size) {
+
+	ERROR("Not implemented yet");
+	(void)dev;
+	(void)ver;
+	(void)size;
+	return -1;
+
+}
+
+int mkii_set_kernel_ver(struct usb_device_info * dev, const char * ver) {
+
+	ERROR("Not implemented yet");
+	(void)dev;
+	(void)ver;
+	return -1;
+
+}
+
+int mkii_get_initfs_ver(struct usb_device_info * dev, char * ver, size_t size) {
+
+	ERROR("Not implemented yet");
+	(void)dev;
+	(void)ver;
+	(void)size;
+	return -1;
+
+}
+
+int mkii_set_initfs_ver(struct usb_device_info * dev, const char * ver) {
+
+	ERROR("Not implemented yet");
+	(void)dev;
+	(void)ver;
+	return -1;
+
+}
+
+int mkii_get_nolo_ver(struct usb_device_info * dev, char * ver, size_t size) {
+
+	ERROR("Not implemented yet");
+	(void)dev;
+	(void)ver;
+	(void)size;
+	return -1;
+
+}
+
+int mkii_set_nolo_ver(struct usb_device_info * dev, const char * ver) {
+
+	ERROR("Not implemented yet");
+	(void)dev;
+	(void)ver;
+	return -1;
+
+}
+
+int mkii_get_sw_ver(struct usb_device_info * dev, char * ver, size_t size) {
+
+	ERROR("Not implemented yet");
+	(void)dev;
+	(void)ver;
+	(void)size;
+	return -1;
+
+}
+
+int mkii_set_sw_ver(struct usb_device_info * dev, const char * ver) {
+
+	ERROR("Not implemented yet");
+	(void)dev;
+	(void)ver;
+	return -1;
+
+}
+
+int mkii_get_content_ver(struct usb_device_info * dev, char * ver, size_t size) {
+
+	ERROR("Not implemented yet");
+	(void)dev;
+	(void)ver;
+	(void)size;
+	return -1;
+
+}
+
+int mkii_set_content_ver(struct usb_device_info * dev, const char * ver) {
+
+	ERROR("Not implemented yet");
+	(void)dev;
+	(void)ver;
+	return -1;
+
+}

src/mkii.h

@@ -0,0 +1,64 @@
+/*
+    0xFFFF - Open Free Fiasco Firmware Flasher
+    Copyright (C) 2012  Pali Rohár <pali.rohar@gmail.com>
+
+    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 3 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, see <http://www.gnu.org/licenses/>.
+
+*/
+
+#ifndef MKII_H
+#define MKII_H
+
+#include "image.h"
+#include "device.h"
+#include "usb-device.h"
+
+int mkii_init(struct usb_device_info * dev);
+
+enum device mkii_get_device(struct usb_device_info * dev);
+
+int mkii_flash_image(struct usb_device_info * dev, struct image * image);
+int mkii_reboot_device(struct usb_device_info * dev);
+
+int mkii_get_root_device(struct usb_device_info * dev);
+int mkii_set_root_device(struct usb_device_info * dev, int device);
+
+int mkii_get_usb_host_mode(struct usb_device_info * dev);
+int mkii_set_usb_host_mode(struct usb_device_info * dev, int enable);
+
+int mkii_get_rd_mode(struct usb_device_info * dev);
+int mkii_set_rd_mode(struct usb_device_info * dev, int enable);
+
+int mkii_get_rd_flags(struct usb_device_info * dev, char * flags, size_t size);
+int mkii_set_rd_flags(struct usb_device_info * dev, const char * flags);
+
+int16_t mkii_get_hwrev(struct usb_device_info * dev);
+int mkii_set_hwrev(struct usb_device_info * dev, int16_t hwrev);
+
+int mkii_get_kernel_ver(struct usb_device_info * dev, char * ver, size_t size);
+int mkii_set_kernel_ver(struct usb_device_info * dev, const char * ver);
+
+int mkii_get_initfs_ver(struct usb_device_info * dev, char * ver, size_t size);
+int mkii_set_initfs_ver(struct usb_device_info * dev, const char * ver);
+
+int mkii_get_nolo_ver(struct usb_device_info * dev, char * ver, size_t size);
+int mkii_set_nolo_ver(struct usb_device_info * dev, const char * ver);
+
+int mkii_get_sw_ver(struct usb_device_info * dev, char * ver, size_t size);
+int mkii_set_sw_ver(struct usb_device_info * dev, const char * ver);
+
+int mkii_get_content_ver(struct usb_device_info * dev, char * ver, size_t size);
+int mkii_set_content_ver(struct usb_device_info * dev, const char * ver);
+
+#endif

src/nolo.c

@@ -0,0 +1,832 @@
+/*
+ *  0xFFFF - Open Free Fiasco Firmware Flasher
+ *  Copyright (C) 2007-2009  pancake <pancake@youterm.com>
+ *  Copyright (C) 2012  Pali Rohár <pali.rohar@gmail.com>
+ *
+ *  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 3 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, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+#include <arpa/inet.h>
+
+#include <usb.h>
+
+#include "nolo.h"
+#include "image.h"
+#include "global.h"
+#include "printf-utils.h"
+
+/* Request type */
+#define NOLO_WRITE		64
+#define NOLO_QUERY		192
+
+/* Request */
+#define NOLO_STATUS		1
+#define NOLO_GET_NOLO_VERSION	3
+#define NOLO_IDENTIFY		4
+#define NOLO_SET		16
+#define NOLO_GET		17
+#define NOLO_STRING		18
+#define NOLO_SET_STRING		19
+#define NOLO_GET_STRING		20
+#define NOLO_SEND_IMAGE		66
+#define NOLO_SET_SW_RELEASE	67
+#define NOLO_FLASH_IMAGE	80
+#define NOLO_SEND_FLASH_FINISH	82
+#define NOLO_SEND_FLASH_IMAGE	84
+#define NOLO_BOOT		130
+#define NOLO_REBOOT		131
+
+/* Indexes - Flash image */
+#define NOLO_IMAGE_BOOTLOADER	1
+#define NOLO_IMAGE_KERNEL	3
+#define NOLO_IMAGE_INITFS	4
+#define NOLO_IMAGE_CMT		66
+
+/* Indexes - Set & Get */
+#define NOLO_RD_MODE		0
+#define NOLO_ROOT_DEVICE	1
+#define NOLO_USB_HOST_MODE	2
+#define NOLO_ADD_RD_FLAGS	3
+#define NOLO_DEL_RD_FLAGS	4
+
+/* Values - R&D flags */
+#define NOLO_RD_FLAG_NO_OMAP_WD		0x002
+#define NOLO_RD_FLAG_NO_EXT_WD		0x004
+#define NOLO_RD_FLAG_NO_LIFEGUARD	0x008
+#define NOLO_RD_FLAG_SERIAL_CONSOLE	0x010
+#define NOLO_RD_FLAG_NO_USB_TIMEOUT	0x020
+#define NOLO_RD_FLAG_STI_CONSOLE	0x040
+#define NOLO_RD_FLAG_NO_CHARGING	0x080
+#define NOLO_RD_FLAG_FORCE_POWER_KEY	0x100
+
+/* Values - Boot mode */
+#define NOLO_BOOT_MODE_NORMAL		0
+#define NOLO_BOOT_MODE_UPDATE		1
+
+static int nolo_identify_string(struct usb_device_info * dev, const char * str, char * out, size_t size) {
+
+	char buf[512];
+	char * ptr;
+	int ret;
+
+	memset(buf, 0, sizeof(buf));
+
+	ret = usb_control_msg(dev->udev, NOLO_QUERY, NOLO_IDENTIFY, 0, 0, (char *)buf, sizeof(buf), 2000);
+	if ( ret < 0 )
+		ERROR_RETURN("NOLO_IDENTIFY failed", -1);
+
+	ptr = memmem(buf, ret, str, strlen(str));
+	if ( ! ptr )
+		ERROR_RETURN("Substring was not found", -1);
+
+	ptr += strlen(str) + 1;
+
+	while ( ptr-buf < ret && *ptr < 32 )
+		++ptr;
+
+	if ( ! *ptr )
+		return -1;
+
+	strncpy(out, ptr, size-1);
+	out[size-1] = 0;
+	return strlen(out);
+
+}
+
+static int nolo_set_string(struct usb_device_info * dev, char * str, char * arg) {
+
+	if ( usb_control_msg(dev->udev, NOLO_WRITE, NOLO_STRING, 0, 0, str, strlen(str), 2000) < 0 )
+		ERROR_RETURN("NOLO_STRING failed", -1);
+
+	if ( usb_control_msg(dev->udev, NOLO_WRITE, NOLO_SET_STRING, 0, 0, arg, strlen(arg), 2000) < 0 )
+		ERROR_RETURN("NOLO_SET_STRING failed", -1);
+
+	return 0;
+
+}
+
+static int nolo_get_string(struct usb_device_info * dev, char * str, char * out, size_t size) {
+
+	int ret;
+
+	if ( usb_control_msg(dev->udev, NOLO_WRITE, NOLO_STRING, 0, 0, str, strlen(str), 2000) < 0 )
+		ERROR_RETURN("NOLO_STRING failed", -1);
+
+	if ( ( ret = usb_control_msg(dev->udev, NOLO_QUERY, NOLO_GET_STRING, 0, 0, out, size-1, 2000) ) < 0 )
+		ERROR_RETURN("NOLO_GET_STRING failed", -1);
+
+	out[size-1] = 0;
+	out[ret] = 0;
+	return strlen(out);
+
+}
+
+static int nolo_get_version_string(struct usb_device_info * dev, const char * str, char * out, size_t size) {
+
+	int ret;
+	char buf[512];
+
+	if ( strlen(str) > 500 )
+		return -1;
+
+	sprintf(buf, "version:%s", str);
+
+	ret = nolo_get_string(dev, buf, out, size);
+	if ( ret < 0 )
+		return ret;
+
+	if ( ! out[0] )
+		return -1;
+
+	return ret;
+
+}
+
+int nolo_init(struct usb_device_info * dev) {
+
+	uint32_t val = 1;
+	enum device device;
+
+	printf("Initializing NOLO...\n");
+
+	while ( val != 0 )
+		if ( usb_control_msg(dev->udev, NOLO_QUERY, NOLO_STATUS, 0, 0, (char *)&val, 4, 2000) == -1 )
+			ERROR_RETURN("NOLO_STATUS failed", -1);
+
+	device = nolo_get_device(dev);
+
+	if ( ! dev->device )
+		dev->device = device;
+
+	if ( dev->device && device && dev->device != device ) {
+		ERROR("Device mishmash, expected %s, got %s", device_to_string(dev->device), device_to_string(device));
+		return -1;
+	}
+
+	dev->hwrev = nolo_get_hwrev(dev);
+
+	return 0;
+}
+
+enum device nolo_get_device(struct usb_device_info * dev) {
+
+	char buf[20];
+	if ( nolo_identify_string(dev, "prod_code", buf, sizeof(buf)) < 0 )
+		return DEVICE_UNKNOWN;
+	else if ( buf[0] )
+		return device_from_string(buf);
+	else
+		return DEVICE_UNKNOWN;
+
+}
+
+static int nolo_send_image(struct usb_device_info * dev, struct image * image, int flash) {
+
+	char buf[0x20000];
+	char * ptr;
+	const char * type;
+	uint8_t len;
+	uint16_t hash;
+	uint32_t size;
+	uint32_t need;
+	uint32_t readed;
+	int request;
+	int ret;
+
+	if ( flash )
+		printf("Send and flash image:\n");
+	else
+		printf("Load image:\n");
+	image_print_info(image);
+
+	if ( image->type == IMAGE_2ND || image->type == IMAGE_MMC )
+		ERROR_RETURN("Sending 2nd and mmc images are not supported", -1);
+
+	if ( ! flash && image->type == IMAGE_ROOTFS )
+		ERROR_RETURN("Rootfs image must be sent in flash mode", -1);
+
+	ptr = buf;
+
+	/* Signature */
+	memcpy(ptr, "\x2E\x19\x01\x01", 4);
+	ptr += 4;
+
+	/* Space */
+	memcpy(ptr, "\x00", 1);
+	ptr += 1;
+
+	/* Hash */
+	hash = htons(image->hash);
+	memcpy(ptr, &hash, 2);
+	ptr += 2;
+
+	/* Type */
+	type = image_type_to_string(image->type);
+	if ( ! type )
+		ERROR_RETURN("Unknown image type", -1);
+	memset(ptr, 0, 12);
+	strncpy(ptr, type, 12);
+	ptr += 12;
+
+	/* Size */
+	size = htonl(image->size);
+	memcpy(ptr, &size, 4);
+	ptr += 4;
+
+	/* Space */
+	memcpy(ptr, "\x00\x00\x00\x00", 4);
+	ptr += 4;
+
+	/* Device & hwrev */
+	if ( image->devices ) {
+
+		int i;
+		uint8_t len;
+		char buf[9];
+		char ** bufs = NULL;
+		struct device_list * device = image->devices;
+
+		while ( device ) {
+			if ( device->device == dev->device && hwrev_is_valid(device->hwrevs, dev->hwrev) )
+				break;
+			device = device->next;
+		}
+
+		if ( device )
+			bufs = device_list_alloc_to_bufs(device);
+
+		if ( bufs ) {
+
+			memset(buf, 0, sizeof(buf));
+			snprintf(buf, 8, "%d", dev->hwrev);
+
+			for ( i = 0; bufs[i]; ++i ) {
+				len = ((uint8_t*)bufs[i])[0];
+				if ( memmem(bufs[i]+1, len, buf, strlen(buf)) )
+					break;
+			}
+
+			if ( bufs[i] ) {
+				/* Device & hwrev string header */
+				memcpy(ptr, "\x32", 1);
+				ptr += 1;
+				/* Device & hwrev string size */
+				memcpy(ptr, &len, 1);
+				ptr += 1;
+				/* Device & hwrev string */
+				memcpy(ptr, bufs[i]+1, len);
+				ptr += len;
+			}
+
+			free(bufs);
+
+		}
+
+	}
+
+	/* Version */
+	if ( image->version ) {
+		len = strnlen(image->version, 255) + 1;
+		/* Version string header */
+		memcpy(ptr, "\x31", 1);
+		ptr += 1;
+		/* Version string size */
+		memcpy(ptr, &len, 1);
+		ptr += 1;
+		/* Version string */
+		memcpy(ptr, image->version, len);
+		ptr += len;
+	}
+
+	if ( flash )
+		request = NOLO_SEND_FLASH_IMAGE;
+	else
+		request = NOLO_SEND_IMAGE;
+
+	printf("Sending image header...\n");
+	if ( usb_control_msg(dev->udev, NOLO_WRITE, request, 0, 0, buf, ptr-buf, 2000) < 0 )
+		ERROR_RETURN("Sending image header failed", -1);
+
+	if ( flash )
+		printf("Sending and flashing image...\n");
+	else
+		printf("Sending image...\n");
+	printf_progressbar(0, image->size);
+	image_seek(image, 0);
+	readed = 0;
+	while ( readed < image->size ) {
+		need = image->size - readed;
+		if ( need > sizeof(buf) )
+			need = sizeof(buf);
+		ret = image_read(image, buf, need);
+		if ( ret == 0 )
+			break;
+		if ( usb_bulk_write(dev->udev, 2, buf, ret, 5000) != ret )
+			PRINTF_ERROR_RETURN("Sending image failed", -1);
+		readed += ret;
+		printf_progressbar(readed, image->size);
+	}
+
+	if ( flash ) {
+		printf("Finishing flashing...\n");
+		if ( usb_control_msg(dev->udev, NOLO_WRITE, NOLO_SEND_FLASH_FINISH, 0, 0, NULL, 0, 30000) < 0 )
+			ERROR_RETURN("Finishing failed", -1);
+	}
+
+	printf("Done\n");
+
+	return 0;
+
+}
+
+int nolo_load_image(struct usb_device_info * dev, struct image * image) {
+
+	if ( image->type != IMAGE_KERNEL && image->type != IMAGE_INITFS )
+		ERROR_RETURN("Only kernel or initfs image can be loaded", -1);
+
+	return nolo_send_image(dev, image, 0);
+
+}
+
+int nolo_flash_image(struct usb_device_info * dev, struct image * image) {
+
+	int ret;
+	int flash;
+	int index;
+	unsigned long long int part;
+	unsigned long long int total;
+	unsigned long long int last_total;
+	char status[20];
+	char buf[128];
+
+	if ( image->type == IMAGE_ROOTFS )
+		flash = 1;
+	else
+		flash = 0;
+
+	ret = nolo_send_image(dev, image, flash);
+	if ( ret < 0 )
+		return ret;
+
+	if ( image->type == IMAGE_SECONDARY )
+		index = NOLO_IMAGE_BOOTLOADER;
+	else if ( image->type == IMAGE_KERNEL )
+		index = NOLO_IMAGE_KERNEL;
+	else if ( image->type == IMAGE_CMT_MCUSW )
+		index = NOLO_IMAGE_CMT;
+	else
+		index = -1;
+
+	if ( image->type == IMAGE_CMT_MCUSW )
+		nolo_set_string(dev, "cmt:verify", "1");
+
+	if ( ! flash && index >= 0 ) {
+
+		printf("Flashing image...\n");
+		if ( usb_control_msg(dev->udev, NOLO_WRITE, NOLO_FLASH_IMAGE, 0, index, NULL, 0, 10000) )
+			ERROR_RETURN("Flashing failed", -1);
+
+		printf("Done\n");
+
+	}
+
+	if ( image->type == IMAGE_CMT_MCUSW ) {
+
+		int state = 0;
+		last_total = 0;
+
+		if ( nolo_get_string(dev, "cmt:status", buf, sizeof(buf)) < 0 )
+			ERROR_RETURN("cmt:status failed", -1);
+
+		if ( strncmp(buf, "idle", strlen("idle")) == 0 )
+			state = 4;
+		else
+			printf("Erasing CMT...\n");
+
+		while ( state != 4 ) {
+
+			if ( nolo_get_string(dev, "cmt:status", buf, sizeof(buf)) < 0 )
+				PRINTF_ERROR_RETURN("cmt:status failed", -1);
+
+			if ( strncmp(buf, "finished", strlen("finished")) == 0 ) {
+
+				if ( state <= 0 ) {
+					printf_progressbar(last_total, last_total);
+					printf("Done\n");
+				}
+				if ( state <= 1 )
+					printf("Programming CMT...\n");
+				if ( state <= 2 ) {
+					printf_progressbar(last_total, last_total);
+					printf("Done\n");
+				}
+
+				state = 4;
+
+			} else {
+
+				if ( sscanf(buf, "%s:%llu/%llu", status, &part, &total) != 3 )
+					PRINTF_ERROR_RETURN("cmt:status unknown", -1);
+
+				if ( strcmp(status, "program") == 0 && state <= 0 ) {
+					printf_progressbar(last_total, last_total);
+					printf("Done\n");
+					state = 1;
+				}
+
+				if ( strcmp(status, "program") == 0 && state <= 1 ) {
+					printf("Programming CMT...\n");
+					state = 2;
+				}
+
+				printf_progressbar(part, total);
+				last_total = total;
+
+				if ( strcmp(status, "erase") == 0 && state <= 0 && part == total ) {
+					printf("Done\n");
+					state = 1;
+				}
+
+				if ( strcmp(status, "program") == 0 && state <= 2 && part == total ) {
+					printf("Done\n");
+					state = 3;
+				}
+
+			}
+
+			usleep(0xc350); // 0.5s
+
+		}
+
+	}
+
+	return 0;
+
+}
+
+int nolo_boot_device(struct usb_device_info * dev, const char * cmdline) {
+
+	int size = 0;
+	int mode = NOLO_BOOT_MODE_NORMAL;
+
+	if ( cmdline && strncmp(cmdline, "update", strlen("update")) == 0 && cmdline[strlen("update")] <= 32 ) {
+		mode = NOLO_BOOT_MODE_UPDATE;
+		cmdline += strlen("update");
+		if ( *cmdline ) ++cmdline;
+		while ( *cmdline && *cmdline <= 32 )
+			++cmdline;
+		if ( *cmdline ) {
+			printf("Booting kernel to update mode with cmdline: %s...\n", cmdline);
+			size = strlen(cmdline);
+		} else {
+			printf("Booting kernel to update mode with default cmdline...\n");
+			cmdline = NULL;
+		}
+	} else if ( cmdline && cmdline[0] ) {
+		printf("Booting kernel with cmdline: '%s'...\n", cmdline);
+		size = strlen(cmdline)+1;
+	} else {
+		printf("Booting kernel with default cmdline...\n");
+		cmdline = NULL;
+	}
+
+	if ( usb_control_msg(dev->udev, NOLO_WRITE, NOLO_BOOT, mode, 0, (char *)cmdline, size, 2000) < 0 )
+		ERROR_RETURN("Booting failed", -1);
+
+	return 0;
+
+}
+
+int nolo_reboot_device(struct usb_device_info * dev) {
+
+	printf("Rebooting device...\n");
+	if ( usb_control_msg(dev->udev, NOLO_WRITE, NOLO_REBOOT, 0, 0, NULL, 0, 2000) < 0 )
+		ERROR_RETURN("NOLO_REBOOT failed", -1);
+	return 0;
+
+}
+
+int nolo_get_root_device(struct usb_device_info * dev) {
+
+	uint8_t device;
+	if ( usb_control_msg(dev->udev, NOLO_QUERY, NOLO_GET, 0, NOLO_ROOT_DEVICE, (char *)&device, 1, 2000) < 0 )
+		ERROR_RETURN("Cannot get root device", -1);
+	return device;
+
+}
+
+int nolo_set_root_device(struct usb_device_info * dev, int device) {
+
+	printf("Setting root device to %d...\n", device);
+	if ( simulate )
+		return 0;
+	if ( usb_control_msg(dev->udev, NOLO_WRITE, NOLO_SET, device, NOLO_ROOT_DEVICE, NULL, 0, 2000) < 0 )
+		ERROR_RETURN("Cannot set root device", -1);
+	return 0;
+
+}
+
+int nolo_get_usb_host_mode(struct usb_device_info * dev) {
+
+	uint32_t enabled;
+	if ( usb_control_msg(dev->udev, NOLO_QUERY, NOLO_GET, 0, NOLO_USB_HOST_MODE, (void *)&enabled, 4, 2000) < 0 )
+		ERROR_RETURN("Cannot get USB host mode status", -1);
+	return enabled ? 1 : 0;
+
+}
+
+int nolo_set_usb_host_mode(struct usb_device_info * dev, int enable) {
+
+	printf("%s USB host mode...\n", enable ? "Enabling" : "Disabling");
+	if ( simulate )
+		return 0;
+	if ( usb_control_msg(dev->udev, NOLO_WRITE, NOLO_SET, enable, NOLO_USB_HOST_MODE, NULL, 0, 2000) < 0 )
+		ERROR_RETURN("Cannot change USB host mode status", -1);
+	return 0;
+
+}
+
+int nolo_get_rd_mode(struct usb_device_info * dev) {
+
+	uint8_t enabled;
+	if ( usb_control_msg(dev->udev, NOLO_QUERY, NOLO_GET, 0, NOLO_RD_MODE, (char *)&enabled, 1, 2000) < 0 )
+		ERROR_RETURN("Cannot get R&D mode status", -1);
+	return enabled ? 1 : 0;
+
+}
+
+int nolo_set_rd_mode(struct usb_device_info * dev, int enable) {
+
+	printf("%s R&D mode...\n", enable ? "Enabling" : "Disabling");
+	if ( simulate )
+		return 0;
+	if ( usb_control_msg(dev->udev, NOLO_WRITE, NOLO_SET, enable, NOLO_RD_MODE, NULL, 0, 2000) < 0 )
+		ERROR_RETURN("Cannot change R&D mode status", -1);
+	return 0;
+
+}
+
+#define APPEND_STRING(ptr, buf, size, string) do { if ( (int)size > ptr-buf ) ptr += snprintf(ptr, size-(ptr-buf), "%s,", string); } while (0)
+
+int nolo_get_rd_flags(struct usb_device_info * dev, char * flags, size_t size) {
+
+	uint16_t add_flags;
+	char * ptr = flags;
+
+	if ( usb_control_msg(dev->udev, NOLO_QUERY, NOLO_GET, 0, NOLO_ADD_RD_FLAGS, (char *)&add_flags, 2, 2000) < 0 )
+		ERROR_RETURN("Cannot get R&D flags", -1);
+
+	if ( add_flags & NOLO_RD_FLAG_NO_OMAP_WD )
+		APPEND_STRING(ptr, flags, size, "no-omap-wd");
+	if ( add_flags & NOLO_RD_FLAG_NO_EXT_WD )
+		APPEND_STRING(ptr, flags, size, "no-ext-wd");
+	if ( add_flags & NOLO_RD_FLAG_NO_LIFEGUARD )
+		APPEND_STRING(ptr, flags, size, "no-lifeguard-reset");
+	if ( add_flags & NOLO_RD_FLAG_SERIAL_CONSOLE )
+		APPEND_STRING(ptr, flags, size, "serial-console");
+	if ( add_flags & NOLO_RD_FLAG_NO_USB_TIMEOUT )
+		APPEND_STRING(ptr, flags, size, "no-usb-timeout");
+	if ( add_flags & NOLO_RD_FLAG_STI_CONSOLE )
+		APPEND_STRING(ptr, flags, size, "sti-console");
+	if ( add_flags & NOLO_RD_FLAG_NO_CHARGING )
+		APPEND_STRING(ptr, flags, size, "no-charging");
+	if ( add_flags & NOLO_RD_FLAG_FORCE_POWER_KEY )
+		APPEND_STRING(ptr, flags, size, "force-power-key");
+
+	if ( ptr != flags && *(ptr-1) == ',' )
+		*(--ptr) = 0;
+
+	return ptr-flags;
+
+}
+
+#undef APPEND_STRING
+
+int nolo_set_rd_flags(struct usb_device_info * dev, const char * flags) {
+
+	const char * ptr = flags;
+	const char * endptr = ptr;
+
+	int add_flags = 0;
+	int del_flags = 0;
+
+	if ( flags && flags[0] )
+		printf("Setting R&D flags to: %s...\n", flags);
+	else
+		printf("Clearing all R&D flags...\n");
+
+	while ( ptr && *ptr ) {
+
+		while ( *ptr <= 32 )
+			++ptr;
+
+		if ( ! *ptr )
+			break;
+
+		endptr = strchr(ptr, ',');
+		if ( endptr )
+			endptr -= 1;
+		else
+			endptr = ptr+strlen(ptr);
+
+		if ( strncmp("no-omap-wd", ptr, endptr-ptr) == 0 )
+			add_flags |= NOLO_RD_FLAG_NO_OMAP_WD;
+		if ( strncmp("no-ext-wd", ptr, endptr-ptr) == 0 )
+			add_flags |= NOLO_RD_FLAG_NO_EXT_WD;
+		if ( strncmp("no-lifeguard-reset", ptr, endptr-ptr) == 0 )
+			add_flags |= NOLO_RD_FLAG_NO_LIFEGUARD;
+		if ( strncmp("serial-console", ptr, endptr-ptr) == 0 )
+			add_flags |= NOLO_RD_FLAG_SERIAL_CONSOLE;
+		if ( strncmp("no-usb-timeout", ptr, endptr-ptr) == 0 )
+			add_flags |= NOLO_RD_FLAG_NO_USB_TIMEOUT;
+		if ( strncmp("sti-console", ptr, endptr-ptr) == 0 )
+			add_flags |= NOLO_RD_FLAG_STI_CONSOLE;
+		if ( strncmp("no-charging", ptr, endptr-ptr) == 0 )
+			add_flags |= NOLO_RD_FLAG_NO_CHARGING;
+		if ( strncmp("force-power-key", ptr, endptr-ptr) == 0 )
+			add_flags |= NOLO_RD_FLAG_FORCE_POWER_KEY;
+
+		if ( *(endptr+1) )
+			ptr = endptr+2;
+		else
+			break;
+
+	}
+
+	if ( ! ( add_flags & NOLO_RD_FLAG_NO_OMAP_WD ) )
+		del_flags |= NOLO_RD_FLAG_NO_OMAP_WD;
+	if ( ! ( add_flags & NOLO_RD_FLAG_NO_EXT_WD ) )
+		del_flags |= NOLO_RD_FLAG_NO_EXT_WD;
+	if ( ! ( add_flags & NOLO_RD_FLAG_NO_LIFEGUARD ) )
+		del_flags |= NOLO_RD_FLAG_NO_LIFEGUARD;
+	if ( ! ( add_flags & NOLO_RD_FLAG_SERIAL_CONSOLE ) )
+		del_flags |= NOLO_RD_FLAG_SERIAL_CONSOLE;
+	if ( ! ( add_flags & NOLO_RD_FLAG_NO_USB_TIMEOUT ) )
+		del_flags |= NOLO_RD_FLAG_NO_USB_TIMEOUT;
+	if ( ! ( add_flags & NOLO_RD_FLAG_STI_CONSOLE ) )
+		del_flags |= NOLO_RD_FLAG_STI_CONSOLE;
+	if ( ! ( add_flags & NOLO_RD_FLAG_NO_CHARGING ) )
+		del_flags |= NOLO_RD_FLAG_NO_CHARGING;
+	if ( ! ( add_flags & NOLO_RD_FLAG_FORCE_POWER_KEY ) )
+		del_flags |= NOLO_RD_FLAG_FORCE_POWER_KEY;
+
+	if ( simulate )
+		return 0;
+
+	if ( usb_control_msg(dev->udev, NOLO_WRITE, NOLO_SET, add_flags, NOLO_ADD_RD_FLAGS, NULL, 0, 2000) < 0 )
+		ERROR_RETURN("Cannot add R&D flags", -1);
+
+	if ( usb_control_msg(dev->udev, NOLO_WRITE, NOLO_SET, del_flags, NOLO_DEL_RD_FLAGS, NULL, 0, 2000) < 0 )
+		ERROR_RETURN("Cannot del R&D flags", -1);
+
+	return 0;
+
+}
+
+int16_t nolo_get_hwrev(struct usb_device_info * dev) {
+
+	char buf[10];
+	if ( nolo_identify_string(dev, "hw_rev", buf, sizeof(buf)) <= 0 )
+		return -1;
+	return atoi(buf);
+
+}
+
+int nolo_set_hwrev(struct usb_device_info * dev, int16_t hwrev) {
+
+	char buf[9];
+	memset(buf, 0, sizeof(buf));
+	snprintf(buf, 8, "%d", hwrev);
+	printf("Setting HW revision to: %s\n", buf);
+	return nolo_set_string(dev, "hw_rev", buf);
+
+}
+
+int nolo_get_kernel_ver(struct usb_device_info * dev, char * ver, size_t size) {
+
+	return nolo_get_version_string(dev, "kernel", ver, size);
+
+}
+
+int nolo_set_kernel_ver(struct usb_device_info * dev, const char * ver) {
+
+	printf("nolo_set_kernel_ver is not implemented yet\n");
+	(void)dev;
+	(void)ver;
+	return -1;
+
+}
+
+int nolo_get_initfs_ver(struct usb_device_info * dev, char * ver, size_t size) {
+
+	return nolo_get_version_string(dev, "initfs", ver, size);
+
+}
+
+int nolo_set_initfs_ver(struct usb_device_info * dev, const char * ver) {
+
+	printf("nolo_set_initfs_ver is not implemented yet\n");
+	(void)dev;
+	(void)ver;
+	return -1;
+
+}
+
+int nolo_get_nolo_ver(struct usb_device_info * dev, char * ver, size_t size) {
+
+	uint32_t version;
+
+	if ( usb_control_msg(dev->udev, NOLO_QUERY, NOLO_GET_NOLO_VERSION, 0, 0, (char *)&version, 4, 2000) < 0 )
+		ERROR_RETURN("Cannot get NOLO version", -1);
+
+	if ( (version & 255) > 1 )
+		ERROR_RETURN("Invalid NOLO version", -1);
+
+	return snprintf(ver, size, "%d.%d.%d", version >> 20 & 15, version >> 16 & 15, version >> 8 & 255);
+
+}
+
+int nolo_set_nolo_ver(struct usb_device_info * dev, const char * ver) {
+
+	printf("nolo_set_nolo_ver is not implemented yet\n");
+	(void)dev;
+	(void)ver;
+	return -1;
+
+}
+
+int nolo_get_sw_ver(struct usb_device_info * dev, char * ver, size_t size) {
+
+	return nolo_get_version_string(dev, "sw-release", ver, size);
+
+}
+
+int nolo_set_sw_ver(struct usb_device_info * dev, const char * ver) {
+
+	char buf[512];
+	char * ptr;
+	uint8_t len;
+	const char * str = "OSSO UART+USB";
+
+	printf("Setting Software release string to: %s\n", ver);
+
+	if ( strlen(ver) > UINT8_MAX )
+		ERROR_RETURN("Software release string is too long", -1);
+
+	ptr = buf;
+
+	memcpy(ptr, "\xe8", 1);
+	ptr += 1;
+
+	len = strlen(str)+1;
+	memcpy(ptr, &len, 1);
+	ptr += 1;
+
+	memcpy(ptr, str, len);
+	ptr += len;
+
+	memcpy(ptr, "\x31", 1);
+	ptr += 1;
+
+	len = strlen(ver)+1;
+	memcpy(ptr, &len, 1);
+	ptr += 1;
+
+	memcpy(ptr, ver, len);
+	ptr += len;
+
+	if ( usb_control_msg(dev->udev, NOLO_WRITE, NOLO_SET_SW_RELEASE, 0, 0, buf, ptr-buf, 2000) < 0 )
+		ERROR_RETURN("NOLO_SET_SW_RELEASE failed", -1);
+
+	return 0;
+
+}
+
+int nolo_get_content_ver(struct usb_device_info * dev, char * ver, size_t size) {
+
+	return nolo_get_version_string(dev, "content", ver, size);
+
+}
+
+int nolo_set_content_ver(struct usb_device_info * dev, const char * ver) {
+
+	printf("nolo_set_content_ver is not implemented yet\n");
+	(void)dev;
+	(void)ver;
+	return -1;
+
+}

src/nolo.h

@@ -0,0 +1,65 @@
+/*
+ *  0xFFFF - Open Free Fiasco Firmware Flasher
+ *  Copyright (C) 2007  pancake <pancake@youterm.com>
+ *  Copyright (C) 2012  Pali Rohár <pali.rohar@gmail.com>
+ *
+ *  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 3 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, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef NOLO_H
+#define NOLO_H
+
+#include "image.h"
+#include "usb-device.h"
+
+int nolo_init(struct usb_device_info * dev);
+
+enum device nolo_get_device(struct usb_device_info * dev);
+
+int nolo_load_image(struct usb_device_info * dev, struct image * image);
+int nolo_flash_image(struct usb_device_info * dev, struct image * image);
+int nolo_boot_device(struct usb_device_info * dev, const char * cmdline);
+int nolo_reboot_device(struct usb_device_info * dev);
+
+int nolo_get_root_device(struct usb_device_info * dev);
+int nolo_set_root_device(struct usb_device_info * dev, int device);
+
+int nolo_get_usb_host_mode(struct usb_device_info * dev);
+int nolo_set_usb_host_mode(struct usb_device_info * dev, int enable);
+
+int nolo_get_rd_mode(struct usb_device_info * dev);
+int nolo_set_rd_mode(struct usb_device_info * dev, int enable);
+
+int nolo_get_rd_flags(struct usb_device_info * dev, char * flags, size_t size);
+int nolo_set_rd_flags(struct usb_device_info * dev, const char * flags);
+
+int16_t nolo_get_hwrev(struct usb_device_info * dev);
+int nolo_set_hwrev(struct usb_device_info * dev, int16_t hwrev);
+
+int nolo_get_kernel_ver(struct usb_device_info * dev, char * ver, size_t size);
+int nolo_set_kernel_ver(struct usb_device_info * dev, const char * ver);
+
+int nolo_get_initfs_ver(struct usb_device_info * dev, char * ver, size_t size);
+int nolo_set_initfs_ver(struct usb_device_info * dev, const char * ver);
+
+int nolo_get_nolo_ver(struct usb_device_info * dev, char * ver, size_t size);
+int nolo_set_nolo_ver(struct usb_device_info * dev, const char * ver);
+
+int nolo_get_sw_ver(struct usb_device_info * dev, char * ver, size_t size);
+int nolo_set_sw_ver(struct usb_device_info * dev, const char * ver);
+
+int nolo_get_content_ver(struct usb_device_info * dev, char * ver, size_t size);
+int nolo_set_content_ver(struct usb_device_info * dev, const char * ver);
+
+#endif

src/operations.c

@@ -0,0 +1,639 @@
+/*
+    0xFFFF - Open Free Fiasco Firmware Flasher
+    Copyright (C) 2012  Pali Rohár <pali.rohar@gmail.com>
+
+    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 3 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, see <http://www.gnu.org/licenses/>.
+
+*/
+
+#include "global.h"
+#include "device.h"
+#include "usb-device.h"
+#include "cold-flash.h"
+#include "nolo.h"
+#include "mkii.h"
+#include "disk.h"
+#include "local.h"
+
+#include "operations.h"
+
+struct device_info * dev_detect(void) {
+
+	int ret = 0;
+	struct device_info * dev = NULL;
+	struct usb_device_info * usb = NULL;
+
+	dev = calloc(1, sizeof(struct device_info));
+	if ( ! dev )
+		goto clean;
+
+	/* LOCAL */
+	if ( local_init() == 0 ) {
+		dev->method = METHOD_LOCAL;
+		dev->detected_device = local_get_device();
+		dev->detected_hwrev = local_get_hwrev();
+		return dev;
+	}
+
+	/* USB */
+	usb = usb_open_and_wait_for_device();
+	if ( usb ) {
+		dev->method = METHOD_USB;
+		dev->usb = usb;
+
+		if ( dev->usb->flash_device->protocol == FLASH_NOLO )
+			ret = nolo_init(dev->usb);
+		else if ( dev->usb->flash_device->protocol == FLASH_COLD )
+			ret = init_cold_flash(dev->usb);
+		else if ( dev->usb->flash_device->protocol == FLASH_MKII )
+			ret = mkii_init(dev->usb);
+		else if ( dev->usb->flash_device->protocol == FLASH_DISK )
+			ret = disk_init(dev->usb);
+		else {
+			ERROR("Unknown USB mode");
+			goto clean;
+		}
+
+		if ( ret < 0 )
+			goto clean;
+
+		dev->detected_device = dev_get_device(dev);
+		dev->detected_hwrev = dev_get_hwrev(dev);
+
+		if ( dev->detected_device && dev->usb->device && dev->detected_device != dev->usb->device ) {
+			ERROR("Bad device, expected %s, got %s", device_to_string(dev->usb->device), device_to_string(dev->detected_device));
+			goto clean;
+		}
+
+		return dev;
+	}
+
+clean:
+	usb_close_device(usb);
+	free(dev);
+	return NULL;
+
+}
+
+void dev_free(struct device_info * dev) {
+
+	if ( dev->usb )
+		usb_close_device(dev->usb);
+	free(dev);
+
+}
+
+enum device dev_get_device(struct device_info * dev) {
+
+	if ( dev->method == METHOD_LOCAL )
+		return local_get_device();
+
+	if ( dev->method == METHOD_USB ) {
+
+		enum usb_flash_protocol protocol = dev->usb->flash_device->protocol;
+
+		if ( protocol == FLASH_COLD )
+			return DEVICE_UNKNOWN;
+		else if ( protocol == FLASH_NOLO )
+			return nolo_get_device(dev->usb);
+		else if ( protocol == FLASH_MKII )
+			return mkii_get_device(dev->usb);
+/*		else if ( protocol == FLASH_DISK )
+			return disk_get_device(dev->usb);*/
+
+	}
+
+	return DEVICE_UNKNOWN;
+
+}
+
+int dev_load_image(struct device_info * dev, struct image * image) {
+
+	if ( dev->method == METHOD_LOCAL ) {
+		ERROR("Loading image on local device is not supported");
+		return -1;
+	}
+
+	if ( dev->method == METHOD_USB ) {
+
+		enum usb_flash_protocol protocol = dev->usb->flash_device->protocol;
+
+		if ( protocol == FLASH_NOLO )
+			return nolo_load_image(dev->usb, image);
+
+		usb_switch_to_nolo(dev->usb);
+		return -EAGAIN;
+
+	}
+
+	return -1;
+
+}
+
+int dev_cold_flash_images(struct device_info * dev, struct image * x2nd, struct image * secondary) {
+
+	if ( dev->method == METHOD_LOCAL ) {
+		ERROR("Cold Flashing on local device is not supported");
+		return -1;
+	}
+
+	if ( dev->method == METHOD_USB ) {
+
+		enum usb_flash_protocol protocol = dev->usb->flash_device->protocol;
+
+		if ( protocol == FLASH_COLD )
+			return cold_flash(dev->usb, x2nd, secondary);
+
+		usb_switch_to_cold(dev->usb);
+		return -EAGAIN;
+
+	}
+
+	return -1;
+
+}
+
+int dev_flash_image(struct device_info * dev, struct image * image) {
+
+	if ( dev->method == METHOD_LOCAL )
+		return local_flash_image(image);
+
+	if ( dev->method == METHOD_USB ) {
+
+		enum usb_flash_protocol protocol = dev->usb->flash_device->protocol;
+
+		if ( protocol == FLASH_NOLO )
+			return nolo_flash_image(dev->usb, image);
+		else if ( protocol == FLASH_MKII )
+			return mkii_flash_image(dev->usb, image);
+		else {
+			usb_switch_to_nolo(dev->usb);
+			return -EAGAIN;
+		}
+
+	}
+
+	return -1;
+
+}
+
+int dev_dump_image(struct device_info * dev, enum image_type image, const char * file) {
+
+	if ( dev->method == METHOD_LOCAL )
+		return local_dump_image(image, file);
+
+	if ( dev->method == METHOD_USB ) {
+		ERROR("Dump image via USB is not supported");
+		return -1;
+	}
+
+	return -1;
+
+}
+
+int dev_check_badblocks(struct device_info * dev, const char * device) {
+
+	if ( dev->method == METHOD_LOCAL )
+		return local_check_badblocks(device);
+
+	if ( dev->method == METHOD_USB ) {
+		ERROR("Check for badblocks via USB is not supported");
+		return -1;
+	}
+
+	return -1;
+
+}
+
+int dev_boot_device(struct device_info * dev, const char * cmdline) {
+
+	if ( dev->method == METHOD_LOCAL ) {
+		ERROR("Booting device on local device does not make sense");
+		return -1;
+	}
+
+	if ( dev->method == METHOD_USB ) {
+
+		enum usb_flash_protocol protocol = dev->usb->flash_device->protocol;
+
+		if ( protocol == FLASH_NOLO )
+			return nolo_boot_device(dev->usb, cmdline);
+		else {
+			usb_switch_to_nolo(dev->usb);
+			return 0;
+		}
+
+	}
+
+	return -1;
+
+}
+
+int dev_reboot_device(struct device_info * dev) {
+
+	if ( dev->method == METHOD_LOCAL )
+		return local_reboot_device();
+
+	if ( dev->method == METHOD_USB ) {
+
+		enum usb_flash_protocol protocol = dev->usb->flash_device->protocol;
+
+		if ( protocol == FLASH_COLD )
+			return leave_cold_flash(dev->usb);
+		else if ( protocol == FLASH_NOLO )
+			return nolo_reboot_device(dev->usb);
+		else if ( protocol == FLASH_MKII )
+			return mkii_reboot_device(dev->usb);
+		else {
+			ERROR("Rebooting device in RAW disk mode is not supported");
+			return -1;
+		}
+
+	}
+
+	return -1;
+
+}
+
+int dev_get_root_device(struct device_info * dev) {
+
+	if ( dev->method == METHOD_LOCAL )
+		return local_get_root_device();
+
+	if ( dev->method == METHOD_USB ) {
+
+		enum usb_flash_protocol protocol = dev->usb->flash_device->protocol;
+
+		if ( protocol == FLASH_NOLO )
+			return nolo_get_root_device(dev->usb);
+
+	}
+
+	return -1;
+
+}
+
+int dev_set_root_device(struct device_info * dev, int device) {
+
+	if ( dev->method == METHOD_LOCAL )
+		return local_set_root_device(device);
+
+	if ( dev->method == METHOD_USB ) {
+
+		if ( dev->usb->flash_device->protocol == FLASH_NOLO )
+			return nolo_set_root_device(dev->usb, device);
+
+		if ( dev->usb->flash_device->protocol == FLASH_COLD ) {
+			usb_switch_to_nolo(dev->usb);
+			return -EAGAIN;
+		}
+
+	}
+
+	return -1;
+
+}
+
+int dev_get_usb_host_mode(struct device_info * dev) {
+
+	if ( dev->method == METHOD_LOCAL )
+		return local_get_usb_host_mode();
+
+	if ( dev->method == METHOD_USB ) {
+
+		if ( dev->usb->flash_device->protocol == FLASH_NOLO )
+			return nolo_get_usb_host_mode(dev->usb);
+
+	}
+
+	return -1;
+
+}
+
+int dev_set_usb_host_mode(struct device_info * dev, int enable) {
+
+	if ( dev->method == METHOD_LOCAL )
+		return local_set_usb_host_mode(enable);
+
+	if ( dev->method == METHOD_USB ) {
+
+		if ( dev->usb->flash_device->protocol == FLASH_NOLO )
+			return nolo_set_usb_host_mode(dev->usb, enable);
+
+		if ( dev->usb->flash_device->protocol == FLASH_COLD ) {
+			usb_switch_to_nolo(dev->usb);
+			return -EAGAIN;
+		}
+
+	}
+
+	return -1;
+
+}
+
+int dev_get_rd_mode(struct device_info * dev) {
+
+	if ( dev->method == METHOD_LOCAL )
+		return local_get_rd_mode();
+
+	if ( dev->method == METHOD_USB ) {
+
+		if ( dev->usb->flash_device->protocol == FLASH_NOLO )
+			return nolo_get_rd_mode(dev->usb);
+
+	}
+
+	return -1;
+
+}
+
+int dev_set_rd_mode(struct device_info * dev, int enable) {
+
+	if ( dev->method == METHOD_LOCAL )
+		return local_set_rd_mode(enable);
+
+	if ( dev->method == METHOD_USB ) {
+
+		if ( dev->usb->flash_device->protocol == FLASH_NOLO )
+			return nolo_set_rd_mode(dev->usb, enable);
+
+		if ( dev->usb->flash_device->protocol == FLASH_COLD ) {
+			usb_switch_to_nolo(dev->usb);
+			return -EAGAIN;
+		}
+
+	}
+
+	return -1;
+
+}
+
+int dev_get_rd_flags(struct device_info * dev, char * flags, size_t size) {
+
+	if ( dev->method == METHOD_LOCAL )
+		return local_get_rd_flags(flags, size);
+
+	if ( dev->method == METHOD_USB ) {
+
+		if ( dev->usb->flash_device->protocol == FLASH_NOLO )
+			return nolo_get_rd_flags(dev->usb, flags, size);
+
+	}
+
+	return -1;
+
+}
+
+int dev_set_rd_flags(struct device_info * dev, const char * flags) {
+
+	if ( dev->method == METHOD_LOCAL )
+		return local_set_rd_flags(flags);
+
+	if ( dev->method == METHOD_USB ) {
+
+		if ( dev->usb->flash_device->protocol == FLASH_NOLO )
+			return nolo_set_rd_flags(dev->usb, flags);
+
+		if ( dev->usb->flash_device->protocol == FLASH_COLD ) {
+			usb_switch_to_nolo(dev->usb);
+			return -EAGAIN;
+		}
+
+	}
+
+	return -1;
+
+}
+
+int16_t dev_get_hwrev(struct device_info * dev) {
+
+	if ( dev->method == METHOD_LOCAL )
+		return local_get_hwrev();
+
+	if ( dev->method == METHOD_USB ) {
+
+		if ( dev->usb->flash_device->protocol == FLASH_NOLO )
+			return nolo_get_hwrev(dev->usb);
+
+	}
+
+	return -1;
+
+}
+
+int dev_set_hwrev(struct device_info * dev, int16_t hwrev) {
+
+	if ( dev->method == METHOD_LOCAL )
+		return local_set_hwrev(hwrev);
+
+	if ( dev->method == METHOD_USB ) {
+
+		if ( dev->usb->flash_device->protocol == FLASH_NOLO )
+			return nolo_set_hwrev(dev->usb, hwrev);
+
+		if ( dev->usb->flash_device->protocol == FLASH_COLD ) {
+			usb_switch_to_nolo(dev->usb);
+			return -EAGAIN;
+		}
+
+	}
+
+	return -1;
+
+}
+
+int dev_get_kernel_ver(struct device_info * dev, char * ver, size_t size) {
+
+	if ( dev->method == METHOD_LOCAL )
+		return local_get_kernel_ver(ver, size);
+
+	if ( dev->method == METHOD_USB ) {
+
+		if ( dev->usb->flash_device->protocol == FLASH_NOLO )
+			return nolo_get_kernel_ver(dev->usb, ver, size);
+
+	}
+
+	return -1;
+
+}
+
+int dev_set_kernel_ver(struct device_info * dev, const char * ver) {
+
+	if ( dev->method == METHOD_LOCAL )
+		return local_set_kernel_ver(ver);
+
+	if ( dev->method == METHOD_USB ) {
+
+		if ( dev->usb->flash_device->protocol == FLASH_NOLO )
+			return nolo_set_kernel_ver(dev->usb, ver);
+
+		if ( dev->usb->flash_device->protocol == FLASH_COLD ) {
+			usb_switch_to_nolo(dev->usb);
+			return -EAGAIN;
+		}
+
+	}
+
+	return -1;
+
+}
+
+int dev_get_initfs_ver(struct device_info * dev, char * ver, size_t size) {
+
+	if ( dev->method == METHOD_LOCAL )
+		return local_get_initfs_ver(ver, size);
+
+	if ( dev->method == METHOD_USB ) {
+
+		if ( dev->usb->flash_device->protocol == FLASH_NOLO )
+			return nolo_get_initfs_ver(dev->usb, ver, size);
+
+	}
+
+	return -1;
+
+}
+
+int dev_set_initfs_ver(struct device_info * dev, const char * ver) {
+
+	if ( dev->method == METHOD_LOCAL )
+		return local_set_initfs_ver(ver);
+
+	if ( dev->method == METHOD_USB ) {
+
+		if ( dev->usb->flash_device->protocol == FLASH_NOLO )
+			return nolo_set_initfs_ver(dev->usb, ver);
+
+		if ( dev->usb->flash_device->protocol == FLASH_COLD ) {
+			usb_switch_to_nolo(dev->usb);
+			return -EAGAIN;
+		}
+
+	}
+
+	return -1;
+
+}
+
+int dev_get_nolo_ver(struct device_info * dev, char * ver, size_t size) {
+
+	if ( dev->method == METHOD_LOCAL )
+		return local_get_nolo_ver(ver, size);
+
+	if ( dev->method == METHOD_USB ) {
+
+		if ( dev->usb->flash_device->protocol == FLASH_NOLO )
+			return nolo_get_nolo_ver(dev->usb, ver, size);
+
+	}
+
+	return -1;
+
+}
+
+int dev_set_nolo_ver(struct device_info * dev, const char * ver) {
+
+	if ( dev->method == METHOD_LOCAL )
+		return local_set_nolo_ver(ver);
+
+	if ( dev->method == METHOD_USB ) {
+
+		if ( dev->usb->flash_device->protocol == FLASH_NOLO )
+			return nolo_set_nolo_ver(dev->usb, ver);
+
+		if ( dev->usb->flash_device->protocol == FLASH_COLD ) {
+			usb_switch_to_nolo(dev->usb);
+			return -EAGAIN;
+		}
+
+	}
+
+	return -1;
+
+}
+
+int dev_get_sw_ver(struct device_info * dev, char * ver, size_t size) {
+
+	if ( dev->method == METHOD_LOCAL )
+		return local_get_sw_ver(ver, size);
+
+	if ( dev->method == METHOD_USB ) {
+
+		if ( dev->usb->flash_device->protocol == FLASH_NOLO )
+			return nolo_get_sw_ver(dev->usb, ver, size);
+
+	}
+
+	return -1;
+
+}
+
+int dev_set_sw_ver(struct device_info * dev, const char * ver) {
+
+	if ( dev->method == METHOD_LOCAL )
+		return local_set_sw_ver(ver);
+
+	if ( dev->method == METHOD_USB ) {
+
+		if ( dev->usb->flash_device->protocol == FLASH_NOLO )
+			return nolo_set_sw_ver(dev->usb, ver);
+
+		if ( dev->usb->flash_device->protocol == FLASH_COLD ) {
+			usb_switch_to_nolo(dev->usb);
+			return -EAGAIN;
+		}
+
+	}
+
+	return -1;
+
+}
+
+int dev_get_content_ver(struct device_info * dev, char * ver, size_t size) {
+
+	if ( dev->method == METHOD_LOCAL )
+		return local_get_content_ver(ver, size);
+
+	if ( dev->method == METHOD_USB ) {
+
+		if ( dev->usb->flash_device->protocol == FLASH_NOLO )
+			return nolo_get_content_ver(dev->usb, ver, size);
+
+	}
+
+	return -1;
+
+}
+
+int dev_set_content_ver(struct device_info * dev, const char * ver) {
+
+	if ( dev->method == METHOD_LOCAL )
+		return local_set_content_ver(ver);
+
+	if ( dev->method == METHOD_USB ) {
+
+		if ( dev->usb->flash_device->protocol == FLASH_NOLO )
+			return nolo_set_content_ver(dev->usb, ver);
+
+		if ( dev->usb->flash_device->protocol == FLASH_COLD ) {
+			usb_switch_to_nolo(dev->usb);
+			return -EAGAIN;
+		}
+
+	}
+
+	return -1;
+
+}

src/operations.h

@@ -0,0 +1,83 @@
+/*
+    0xFFFF - Open Free Fiasco Firmware Flasher
+    Copyright (C) 2012  Pali Rohár <pali.rohar@gmail.com>
+
+    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 3 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, see <http://www.gnu.org/licenses/>.
+
+*/
+
+#ifndef OPERATIONS_H
+#define OPERATIONS_H
+
+#include "image.h"
+#include "usb-device.h"
+
+enum connection_method {
+	METHOD_UNKNOWN = 0,
+	METHOD_USB,
+	METHOD_LOCAL,
+};
+
+struct device_info {
+	enum connection_method method;
+	enum device detected_device;
+	int16_t detected_hwrev;
+	struct usb_device_info * usb;
+};
+
+struct device_info * dev_detect(void);
+void dev_free(struct device_info * dev);
+
+enum device dev_get_device(struct device_info * dev);
+
+int dev_cold_flash_images(struct device_info * dev, struct image * x2nd, struct image * secondary);
+int dev_load_image(struct device_info * dev, struct image * image);
+int dev_flash_image(struct device_info * dev, struct image * image);
+int dev_dump_image(struct device_info * dev, enum image_type image, const char * file);
+int dev_check_badblocks(struct device_info * dev, const char * device);
+
+int dev_boot_device(struct device_info * dev, const char * cmdline);
+int dev_reboot_device(struct device_info * dev);
+
+int dev_get_root_device(struct device_info * dev);
+int dev_set_root_device(struct device_info * dev, int device);
+
+int dev_get_usb_host_mode(struct device_info * dev);
+int dev_set_usb_host_mode(struct device_info * dev, int enable);
+
+int dev_get_rd_mode(struct device_info * dev);
+int dev_set_rd_mode(struct device_info * dev, int enable);
+
+int dev_get_rd_flags(struct device_info * dev, char * flags, size_t size);
+int dev_set_rd_flags(struct device_info * dev, const char * flags);
+
+int16_t dev_get_hwrev(struct device_info * dev);
+int dev_set_hwrev(struct device_info * dev, int16_t hwrev);
+
+int dev_get_kernel_ver(struct device_info * dev, char * ver, size_t size);
+int dev_set_kernel_ver(struct device_info * dev, const char * ver);
+
+int dev_get_initfs_ver(struct device_info * dev, char * ver, size_t size);
+int dev_set_initfs_ver(struct device_info * dev, const char * ver);
+
+int dev_get_nolo_ver(struct device_info * dev, char * ver, size_t size);
+int dev_set_nolo_ver(struct device_info * dev, const char * ver);
+
+int dev_get_sw_ver(struct device_info * dev, char * ver, size_t size);
+int dev_set_sw_ver(struct device_info * dev, const char * ver);
+
+int dev_get_content_ver(struct device_info * dev, char * ver, size_t size);
+int dev_set_content_ver(struct device_info * dev, const char * ver);
+
+#endif

src/pieces.c

@@ -1,76 +0,0 @@
-/*
- *  0xFFFF - Open Free Fiasco Firmware Flasher
- *  Copyright (C) 2007  pancake <pancake@youterm.com>
- *
- *  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 3 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, see <http://www.gnu.org/licenses/>.
- */
-
-#include "main.h"
-#include <stdio.h>
-#include <string.h>
-#include <stdlib.h>
-
-int pcs_n = 0;
-struct piece_t pcs[10];
-
-int add_piece(char *piece)
-{
-	int i,ok = 0;
-	char *file;
-
-	if (pcs_n==9) {
-		fprintf(stderr, "Oops...cannot add more pieces. no sense operation!\n");
-		return 0;
-	}
-
-	file = strchr(piece, '%');
-	if (file) {
-		file[0]='\0';
-		file = file + 1;
-		for(i=0;pieces[i];i++)
-			if (!strcmp(pieces[i], piece))
-				ok = 1;
-		if (!ok) {
-			printf("Invalid piece name.\n");
-			printf("Pieces: ");
-			for(i=0;pieces[i];i++)
-				printf("%s ", pieces[i]);
-			printf("\n");
-			exit(1);
-		}
-
-		pcs[pcs_n].name = strdup(file);
-		pcs[pcs_n].type = strdup(piece);
-		pcs[pcs_n].vers = NULL; // TODO version string not yet supported
-	} else {
-		/*/ autodetect piece type */
-		pcs[pcs_n].type = fpid_file(piece);
-		if (pcs[pcs_n].type == NULL) {
-			printf("Use -p [piece]:[file]\n");
-			printf("Pieces: ");
-			for(i=0;pieces[i];i++)
-				printf("%s ", pieces[i]);
-			printf("\n");
-			exit(1);
-		} else {
-			pcs[pcs_n].name = strdup(piece);
-			pcs[pcs_n].type = strdup(pcs[pcs_n].type);
-			pcs[pcs_n].vers = NULL;
-		}
-	}
-
-	pcs_n++;
-
-	return 1;
-}

src/printf-utils.c

@@ -0,0 +1,96 @@
+/*
+ *  0xFFFF - Open Free Fiasco Firmware Flasher
+ *  Copyright (C) 2007  pancake <pancake@youterm.com>
+ *  Copyright (C) 2012  Pali Rohár <pali.rohar@gmail.com>
+ *
+ *  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 3 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, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdarg.h>
+#include <unistd.h>
+
+#include "global.h"
+
+#include "printf-utils.h"
+
+int printf_prev = 0;
+
+void printf_progressbar(unsigned long long part, unsigned long long total) {
+
+	char *columns = getenv("COLUMNS");
+	int pc;
+	int tmp, cols = 80;
+
+	/* percentage calculation */
+	pc = (int)(part*100/total);
+	(pc<0)?pc=0:(pc>100)?pc=100:0;
+
+#if HAVE_SQUEUE
+	if (qmode) {
+		char msg[128];
+		sprintf(msg, "%d%%", pc);
+		squeue_push2(p, "bar", msg, 0);
+	} else {
+#endif
+		PRINTF_BACK();
+		PRINTF_ADD("\x1b[K  %3d%% [", pc);
+		if (columns)
+			cols = atoi(columns);
+		if (cols > 115)
+			cols = 115;
+		cols-=15;
+		for(tmp=cols*pc/100;tmp;tmp--) PRINTF_ADD("#");
+		for(tmp=cols-(cols*pc/100);tmp;tmp--) PRINTF_ADD("-");
+		PRINTF_ADD("]");
+		if (part == total) PRINTF_END();
+		fflush(stdout);
+#if HAVE_SQUEUE
+	}
+#endif
+
+}
+
+void printf_and_wait(const char * format, ...) {
+
+	va_list ap;
+	char c;
+	fd_set rfds;
+	struct timeval tv;
+
+	tv.tv_sec = 0;
+	tv.tv_usec = 0;
+
+	FD_ZERO(&rfds);
+	FD_SET(0, &rfds);
+
+	while ( select(1, &rfds, NULL, NULL, &tv) == 1 )
+		read(0, &c, 1);
+
+	va_start(ap, format);
+	vprintf(format, ap);
+	va_end(ap);
+	fflush(stdout);
+
+	FD_ZERO(&rfds);
+	FD_SET(0, &rfds);
+
+	while ( select(1, &rfds, NULL, NULL, NULL) == 1 ) {
+		read(0, &c, 1);
+		if ( c == '\n' )
+			break;
+	}
+
+}

src/printf-utils.h

@@ -0,0 +1,37 @@
+/*
+ *  0xFFFF - Open Free Fiasco Firmware Flasher
+ *  Copyright (C) 2007  pancake <pancake@youterm.com>
+ *  Copyright (C) 2012  Pali Rohár <pali.rohar@gmail.com>
+ *
+ *  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 3 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, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef PRINTF_UTILS_H
+#define PRINTF_UTILS_H
+
+#include "global.h"
+
+extern int printf_prev;
+
+#define PRINTF_BACK() do { if ( printf_prev ) { printf("\r%-*s\r", printf_prev, ""); printf_prev = 0; } } while (0)
+#define PRINTF_ADD(...) do { printf_prev += printf(__VA_ARGS__); } while (0)
+#define PRINTF_LINE(...) do { PRINTF_BACK(); PRINTF_ADD(__VA_ARGS__); fflush(stdout); } while (0)
+#define PRINTF_END() do { if ( printf_prev ) { printf("\n"); printf_prev = 0; } } while (0)
+#define PRINTF_ERROR(...) do { PRINTF_END(); ERROR_INFO(__VA_ARGS__); } while (0)
+#define PRINTF_ERROR_RETURN(str, ...) do { PRINTF_ERROR("%s", str); return __VA_ARGS__; } while (0)
+
+void printf_progressbar(unsigned long long part, unsigned long long total);
+void printf_and_wait(const char * format, ...);
+
+#endif

src/qmode.c

@@ -0,0 +1,161 @@
+/*
+ *  0xFFFF - Open Free Fiasco Firmware Flasher
+ *  Copyright (C) 2008  pancake <pancake@youterm.com>
+ *  Copyright (C) 2012  Pali Rohár <pali.rohar@gmail.com>
+ *
+ *  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 3 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, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+#include <signal.h>
+
+#include <unistd.h>
+#include <sys/types.h>
+#include <sys/wait.h>
+#include <sys/stat.h>
+
+#include "global.h"
+
+#include "qmode.h"
+#include "nolo.h"
+
+#if HAVE_SQUEUE
+
+#include "squeue/squeue.h"
+extern int qmode;
+extern struct squeue_t *p;
+
+#endif
+
+#if HAVE_SQUEUE
+
+struct squeue_t *q;
+struct squeue_t *p;
+
+static int fork_enabled = 0;
+static int dofork()
+{
+	if (fork_enabled)
+		return fork();
+	return 0;
+}
+
+static void process_message(char *msg)
+{
+	char *str;
+	char *arg;
+	int c=1;
+	if (msg == NULL)
+		return;
+	printf("[x] (%s)\n", msg);
+	str = strdup(msg);
+	arg = strchr(str, ':');
+	if (c!=0) {
+		arg[0]='\0';
+		arg = arg +1;
+/*		if (!strcmp(str, "flash")) {
+			const char *type = fpid_file(arg);
+			if (type == NULL) {
+				squeue_push2(p, "error", "Unknown piece format", 1);
+			} else flash_image(arg, type, NULL, NULL, NULL);
+		} else*/
+		if (!strcmp(str, "reset")) {
+//			if (reboot_board() == 0) {
+//				squeue_push2(p,"info", "Device reboots", 1);
+//			} else squeue_push2(p,"error", "Cannot reboot device", 1);
+		} else
+		if (!strcmp(str, "info")) {
+//			get_rd_flags();
+//			squeue_push2(p, "info", strbuf, 1);
+//			get_nolo_version();
+//			squeue_push2(p, "info", strbuf, 1);
+//			get_usb_mode();
+//			squeue_push2(p, "info", strbuf, 1);
+		} else
+			squeue_push2(p, "error", "invalid command", 0);
+	} else {
+		squeue_push2(p, "error", "invalid command format", 0);
+	}
+	free(str);
+}
+
+static void cc(int signum)
+{
+	squeue_close(p);
+	squeue_close(q);
+	printf("pipes closed\n");
+	squeue_release("/tmp/0xFFFF.1");
+	squeue_release("/tmp/0xFFFF.2");
+	exit(1);
+}
+
+int queue_mode(void)
+{
+	int pid = 0;
+	char *msg;
+
+	signal(SIGINT, cc);
+
+	pid = dofork();
+	if (pid) {
+		wait(&pid);
+		return 0;
+	} else {
+		p = squeue_open("/tmp/0xFFFF.1", Q_CREAT);
+		q = squeue_open("/tmp/0xFFFF.2", Q_CREAT);
+		if (p == NULL || q == NULL) {
+			fprintf(stderr, "Cannot open queue files\n");
+			return 0;
+		}
+		chmod("/tmp/0xFFFF.1", 0666);
+		chmod("/tmp/0xFFFF.2", 0666);
+		pid = dofork();
+		if (pid) {
+			printf( "Entering into shared queue server mode.\n"
+			"Type $ kill -9 %d # to stop\n"
+			"NOTE: Manually remove the /tmp/.0xFFFF.* files to solve perm problems\n", pid);
+		} else {
+			do {
+#if HAVE_USB
+/*				if (connect_via_usb()) {
+					fprintf(stderr, "Cannot connect to device. It is possibly not in boot stage.\n");
+					squeue_push2(p, "error", "Cannot connect to the device", 1);
+					return 0;
+				}*/
+#endif
+				printf("Waiting for a client in shared queues..\n");
+				setsid();
+				while(1) {
+					msg = squeue_get(q, 1);
+					if (msg) {
+						process_message(msg);
+						squeue_pop(q);
+					}
+				}
+			printf("Connection restarted\n");
+			} while (1);
+		}
+	}
+	return 0;
+}
+#else
+int queue_mode(void)
+{
+	/* dummy */
+	fprintf(stderr, "No HAVE_SQUEUE support\n");
+	return 1;
+}
+#endif

src/qmode.h

@@ -1,6 +1,7 @@
 /*
  *  0xFFFF - Open Free Fiasco Firmware Flasher
- *  Copyright (C) 2007  pancake <pancake@youterm.com>
+ *  Copyright (C) 2008  pancake <pancake@youterm.com>
+ *  Copyright (C) 2012  Pali Rohár <pali.rohar@gmail.com>
  *
  *  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
@@ -16,45 +17,9 @@
  *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
-#include <stdio.h>
-#include "hash.h"
+#ifndef QMODE_H
+#define QMODE_H
 
-usho do_hash(usho *b, int len)
-{
-	usho result = 0;
-	for(len>>=1;len--;b=b+1)
-		result^=b[0];
-	return result;
-}
+int queue_mode(void);
 
-usho do_hash_file(char *filename)
-{
-	unsigned char buf[BSIZE];
-	FILE *fd = fopen(filename, "r");
-	usho hash = 0;
-	int ret;
-
-	if (fd == NULL) {
-		fprintf(stderr, "ERROR: File '%s' not found.\n", filename);
-		return -1;
-	}
-
-	do {	ret   = fread(&buf, 1, BSIZE, fd);
-		if (ret == -1)
-			return 0;
-		hash ^= do_hash((usho *)&buf, ret);
-	} while(ret);
-
-	fclose(fd);
-
-	return hash;
-}
-
-#if 0
-main()
-{
-	usho us = do_hash_file("zImage");
-	unsigned char *h= (unsigned char *)&us;
-	printf("%x %x\n",h[0],h[1]);
-}
 #endif

src/query.c

@@ -1,339 +0,0 @@
-/*
- *  0xFFFF - Open Free Fiasco Firmware Flasher
- *  Copyright (C) 2007  pancake <pancake@youterm.com>
- *
- *  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 3 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, see <http://www.gnu.org/licenses/>.
- */
-
-#include "main.h"
-#include <stdio.h>
-#include <string.h>
-#include <stdlib.h>
-#include <usb.h>
-
-/* wait for status = 0 */
-int get_status()
-{
-	int ret = 0;
-	if (usb_control_msg(dev, CMD_QUERY, 1, 0, 0, (char *)&ret, 4, 2000) == -1) {
-		fprintf(stderr, "Cannot get device status.\n");
-		exit(1);
-	}
-
-	return ret;
-}
-
-/**
- * request type: CMD_WRITE
- * request     : 16
- * value       : 0|1 (=> client|host)
- * index       : 2
- */
-int set_usb_mode(unsigned int mode)
-{
-	if (mode > 1)
-	{
-		printf("Invalid USB mode specified '%d'.\n", mode);
-		return -1;
-	}
-	
-	if (usb_control_msg(dev, CMD_WRITE, 16, mode, 2, 0, 0, 2000) == -1) {
-		fprintf(stderr, "Cannot set USB mode.\n");
-		return -1;
-	}
-
-	printf("Set USB mode to: '%s'.\n", (mode) ? "host" : "client");
-
-	return 0;
-}
-
-/**
- * request type: CMD_QUERY
- * request     : 17
- * index       : 2
- * 
- * return value: 0|1 (=> client|host)
- */
-int get_usb_mode()
-{
-	unsigned short mode = 0;
-
-	if (usb_control_msg(dev, CMD_QUERY, 17, 0, 2, (void *) &mode, sizeof(mode), 2000) == -1) {
-		fprintf(stderr, "Cannot query device.\n");
-		return -1;
-	}
-
-	printf("Device's USB mode is '%s'\n", (mode) ? "host" : "client");
-
-	return 0;
-}
-
-/*
- * Boots the Kernel with the given command-line.
- */
-int boot_board(char *cmdline)
-{
-	if (usb_control_msg(dev, CMD_WRITE, 130, 0, 0, cmdline, strlen(cmdline), 2000) == -1) {
-		fprintf(stderr, "Cannot boot kernel.\n");
-		perror("boot_board");
-		return -1;
-	}
-
-	printf("Booting kernel with arguments: '%s'.\n", cmdline);
-
-	return 0;
-}
-
-/*
- * Reboots the omap mobo.
- */
-int reboot_board()
-{
-	// 131 = reboot
-	if (usb_control_msg(dev, CMD_WRITE, 131, 0, 0, 0, 0, 2000) == -1) {
-		fprintf(stderr, "Cannot reboot board.\n");
-		return -1;
-	}
-
-	printf("Mobo rebooted!\n");
-
-	return 0;
-}
-
-int set_rd_mode(unsigned short mode)
-{
-	if (((short)mode)==-1)
-		return 1;
-
-	if (usb_control_msg(dev, CMD_WRITE, 16, mode, 0, 0, 0, 2000) == -1) {
-		fprintf(stderr, "Cannot set R&D flags.\n");
-		return 1;
-	}
-
-	printf("rd mode changed to %s\n", mode?"on":"off");
-
-	return 0;
-}
-
-/*
- * query root device
- */
-int get_hw_revision()
-{
-	unsigned char string[512];
-	int i = 0;
-
-	if (usb_control_msg(dev, CMD_QUERY, 4, 0, 0, (char *)string, 512, 2000) == -1) {
-		fprintf(stderr, "Cannot query hw revision.\n");
-		return -1;
-	}
-
-	printf("HW revision string: '");
-	for(i=0;i<44;i++) { // XXX ??
-		if (string[i]==0) {
-			printf(" ");
-		} else {
-			if (string[i]>19)
-				printf("%c", string[i]);
-		}
-	}
-	printf("'\n");
-
-	return 0;
-}
-
-int get_rd_mode()
-{
-	char isrd = 1;
-
-	if (usb_control_msg(dev, CMD_QUERY, 17, 0, 0, (char *)&isrd, 1, 2000) == -1) {
-		fprintf(stderr, "Cannot query rd mode.\n");
-		return -1;
-	}
-	printf("RD mode is: %s\n", isrd?"on":"off");
-
-	return isrd;
-}
-
-int get_root_device()
-{
-	unsigned char opcode;
-
-	if (usb_control_msg(dev, CMD_QUERY, 17, 0, 1, (char *)&opcode, 1, 2000) < 0) {
-		fprintf(stderr, "Cannot query root device\n");
-		return -1;
-	}
-
-	if (opcode>2) { // use sizeof || enum
-		printf("Invalid root device received from the device '%d'.\n", opcode);
-	}
-
-	printf("Root device is: %s\n", root_devices[opcode]);
-
-	return 0;
-}
-
-/**
- * request type: CMD_WRITE
- * request     : 16
- * value       : 0|1|2 (=> flash|mmc|usb)
- * index       : 1
- */
-int set_root_device(unsigned short root_device)
-{
-	if (root_device>2) {
-		printf("Invalid root device specified '%d'.\n", root_device);
-		return -1;
-	}
-
-	if (usb_control_msg(dev, CMD_WRITE, 16, root_device, 1, 0, 0, 2000) == -1) {
-		fprintf(stderr, "Cannot set root device\n");
-		return -1;
-	}
-
-	printf("Root device set to: %s\n", root_devices[root_device]);
-
-	return 0;
-}
-
-/**
- * Set flags:
- * request type: CMD_WRITE
- * request     : 16
- * value       : flags to set, see below
- * index       : 3
- * 
- * Clear flags:
- * request type: CMD_WRITE
- * request     : 16
- * value       : flags to clear, see below
- * index       : 4
- 
- * Flags are composed of:
- * 0x02 - disable OMAP watchdog (possibly)
- * 0x04 - disable RETU watchdog (possibly)
- * 0x08 - disable lifeguard reset
- * 0x10 - enable serial console
- * 0x20 - disable USB timeout
- * 
- * The function encapsule the NOLO API in a way that it works like
- * a chmod 707. The bits that are not set will be cleared after the
- * call. This is done by issuing a 'clear flags' command with all the
- * non set bits.  
- * 
- */
-int set_rd_flags(unsigned short flags)
-{
-	unsigned short reverse_flags = 0;
-	
-	if (flags & ~(0x02 | 0x04 | 0x08 | 0x10 | 0x20)) {
-		printf("Invalid rd flags specified '%x'.\n", flags);
-		return -1;
-	}
-	
-	if (!(flags & 0x02))
-	  reverse_flags |= 0x02;
-
-	if (!(flags & 0x04))
-	  reverse_flags |= 0x04;
-
-	if (!(flags & 0x08))
-	  reverse_flags |= 0x08;
-
-	if (!(flags & 0x10))
-	  reverse_flags |= 0x10;
-
-	if (!(flags & 0x20))
-	  reverse_flags |= 0x20;
-	  
-	if (usb_control_msg(dev, CMD_WRITE, 16, flags, 3, 0, 0, 2000) == -1) {
-		fprintf(stderr, "Cannot set rd flags\n");
-		return -1;
-	}
-
-	if (usb_control_msg(dev, CMD_WRITE, 16, reverse_flags, 4, 0, 0, 2000) == -1) {
-		fprintf(stderr, "Cannot set rd flags\n");
-		return -1;
-	}
-
-	printf("Set rd flags successfully!\n");
-	printf("disable OMAP watchdog  : %s\n", (flags & 0x02) ? "set" : "not set"); 
-	printf("disable RETU watchdog  : %s\n", (flags & 0x04) ? "set" : "not set"); 
-	printf("disable lifeguard reset: %s\n", (flags & 0x08) ? "set" : "not set"); 
-	printf("enable serial console  : %s\n", (flags & 0x10) ? "set" : "not set"); 
-	printf("disable USB timeout    : %s\n", (flags & 0x20) ? "set" : "not set"); 
-
-	return 0;
-}
-
-int get_rd_flags()
-{
-	unsigned short flags = 0;
-	
-	if (usb_control_msg(dev, CMD_QUERY, 17, 0, 3, (void *) &flags, sizeof(flags), 2000) == -1) {
-		fprintf(stderr, "Cannot get rd flags\n");
-		return -1;
-	}
-	
-	printf("Current rd flag setting:\n");
-	printf("disable OMAP watchdog  : %s\n", (flags & 0x02) ? "set" : "not set"); 
-	printf("disable RETU watchdog  : %s\n", (flags & 0x04) ? "set" : "not set"); 
-	printf("disable lifeguard reset: %s\n", (flags & 0x08) ? "set" : "not set"); 
-	printf("enable serial console  : %s\n", (flags & 0x10) ? "set" : "not set"); 
-	printf("disable USB timeout    : %s\n", (flags & 0x20) ? "set" : "not set");
-	
-	return 0; 
-}
-
-int get_nolo_version()
-{
-	unsigned int version; // ensure uint is at least 32 bits
-
-	//if (usb_control_msg(dev, CMD_QUERY, 3, 0, 1, (char *)&version, 4 , 2000) < 0) {
-	if (usb_control_msg(dev, CMD_QUERY, 3, 0, 0, (char *)&version, 4 , 2000) < 0) {
-		fprintf(stderr, "Cannot query nolo version. Old bootloader version?\n");
-		exit(1);
-	}
-
-	printf("NOLO Version %d.%d.%d\n",
-		version >> 20 & 15,
-		version >> 16 & 15,
-		version >> 8 & 255);
-
-	if ((version & 255)> 1)
-		printf("Invalid API version (%d)\n", version&255);
-
-	return 0;
-}
-
-int get_sw_version()
-{
-	int ret;
-	char bytes[1024];
-
-	strcpy(bytes, "version:sw-release");
-	ret = usb_control_msg(dev, CMD_WRITE, 18, 0, 0, (char *)&bytes, 18, 2000);
-	if (ret<0) {
-		fprintf(stderr, "error: cannot write query 18\n");
-		return 0;
-	}
-	ret = usb_control_msg(dev, CMD_QUERY, 20, 0, 0, (char *)&bytes, 512, 2000);
-	if (ret<0) {
-		fprintf(stderr, "error: b0rken swversion read!\n");
-		return 0;
-	}
-	printf("SWVERSION GOT: %s\n", bytes); //???+strlen(bytes)+1));
-	return 1;
-}
-

src/query.h

@@ -1,28 +0,0 @@
-#ifndef QUERY_H_
-#define QUERY_H_
-
-int boot_board(char *cmdline);
-
-int reboot_board();
-
-int get_status();
-
-int get_usb_mode();
-int set_usb_mode(unsigned int);
-
-int get_rd_mode();
-int set_rd_mode(unsigned short mode);
-
-int get_rd_flags();
-int set_rd_flags(unsigned short flags);
-
-int get_hw_revision();
-
-int get_root_device();
-int set_root_device(unsigned short);
-
-int get_nolo_version();
-
-int get_sw_version();
-
-#endif /*QUERY_H_*/

src/serial.c

@@ -1,86 +0,0 @@
-/*
- *  0xFFFF - Open Free Fiasco Firmware Flasher
- *  Copyright (C) 2007  pancake <pancake@youterm.com>
- *
- *  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 3 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, see <http://www.gnu.org/licenses/>.
- */
-
-#include "main.h"
-#include <stdio.h>
-#include <string.h>
-#include <stdlib.h>
-#include <getopt.h>
-#include <termios.h>
-#include <unistd.h>
-#include <fcntl.h>
-#include <stdio.h>
-#include <signal.h>
-#include <fcntl.h>
-#include <getopt.h>
-
-int open_serial(const char *file)
-{
-	struct termios tc;
-	int fd = open (file, O_RDWR | O_SYNC);
-	if (fd < 0) {
-		perror (file);
-		return -1;
-	}
-	// 115200 baud, 8n1, no flow control
-	tcgetattr(fd, &tc);
-	tc.c_iflag = IGNPAR;
-	tc.c_oflag = 0;
-	tc.c_cflag = CS8 | CREAD | CLOCAL;
-	tc.c_lflag = 0;
-	cfsetispeed(&tc, B115200);
-	cfsetospeed(&tc, B115200);
-	tcsetattr(fd, TCSANOW, &tc);
-	return fd;
-}
-
-int console(const char *device)
-{
-	char str[513];
-	int fd = open_serial(device);
-	int pid;
-
-	if (fd == -1) {
-		fprintf(stderr, "Cannot open serial device %s\n", device);
-		return 1;
-	}
-
-	pid = fork();
-	if (pid) {
-		while(1) {
-			fgets(str, 512, stdin);
-			if (write(fd, str, strlen(str)-1) == -1) {
-				perror("write");
-				exit (1);
-			}
-		}
-	} else {
-		char buf;
-		while(1) {
-			if (read(fd, &buf,1) == -1) {
-				perror("read");
-				exit (1);
-			}
-			write(1, &buf, 1);
-		}
-	}
-
-	close(fd);
-
-	return 0;
-}

src/squeue/squeue.c

@@ -0,0 +1,294 @@
+#include "squeue.h"
+#define _XOPEN_SOURCE 500     /* Or: #define _BSD_SOURCE */
+#include <unistd.h>
+#include <errno.h>
+#include <stdlib.h>
+#include <sys/ipc.h>
+#include <signal.h>
+#include <sys/shm.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <sys/mman.h>
+#include <fcntl.h>
+#include <stdio.h>
+#include <unistd.h>
+#include <string.h>
+
+#define POOL_SIZE ITEM_MAX*ITEM_SIZE
+#define ITEM_SIZE 512
+#define ITEM_MAX 10
+
+int squeue_release(const char *file)
+{
+	int shmid;
+	key_t k = ftok(file, 0xa3);
+	
+	if (k == -1) {
+		perror("ftok");
+		return -1;
+	}
+	
+	shmid = shmget(k, POOL_SIZE, 0666);
+	if (shmid == -1)
+		return -1; // not released
+	return shmctl(shmid, IPC_RMID,NULL);
+}
+
+extern int errno;
+struct squeue_t *squeue_open(const char *file, int mode)
+{
+	struct squeue_t *q;
+	char *pool;
+	int shmid;
+	key_t k;
+
+	k = ftok(file, 0x34);
+	if (k == -1) {
+		perror("ftok");
+		squeue_release(file);
+		close(creat(file, 0666));
+		chmod(file, 0666);
+		k = ftok(file, 0xa3);
+		if (k == -1) {
+			perror("ftok");
+			return NULL;
+		}
+	}
+_retry:
+	shmid = shmget(k, POOL_SIZE, 0666|(mode==Q_CREAT)?IPC_CREAT:0);
+	if (shmid == -1) {
+		perror("shmget1");
+		shmid = shmget(k, POOL_SIZE, 0666|((mode==Q_CREAT)?IPC_CREAT:0));
+		if (shmid == -1) {
+			perror("shmget2");
+			if (errno == EEXIST)
+				shmid = shmget(k, POOL_SIZE, 0666 |IPC_CREAT);
+
+			if (shmid == -1) {
+				if (mode == Q_WAIT) {
+					usleep(100);
+					goto _retry;
+				}
+				perror("shmget");
+				return NULL;
+			}
+		}
+	}
+
+	if (mode == Q_WAIT)
+		mode = Q_OPEN;
+
+	/* fix perms */
+	if (mode == Q_CREAT) {
+		struct shmid_ds sd;
+		shmctl(shmid, IPC_STAT, &sd);
+		sd.shm_perm.uid = 1000;
+		sd.shm_perm.gid = 1000;
+		sd.shm_perm.mode = sd.shm_perm.mode|0666;
+		shmctl(shmid, IPC_SET, &sd);
+	}
+
+	pool = shmat(shmid, NULL, 0);
+	if (pool == (void *)-1) {
+		perror("shmat");
+		return NULL;
+	}
+
+	if (mode == Q_CREAT)
+		memset(pool, '\0', POOL_SIZE);
+
+	q = (struct squeue_t *)malloc(sizeof(struct squeue_t));
+	memset(q, '\0', sizeof(struct squeue_t));
+	q->shmid = shmid;
+	q->pool  = pool;
+	q->mode  = mode;
+
+	return q;
+}
+
+void squeue_free(struct squeue_t *q)
+{
+	free(q);
+}
+
+int squeue_close(struct squeue_t *q)
+{
+	char *pool;
+
+	if (q==NULL)
+		return -1;
+
+	pool = q->pool;
+	shmctl(q->shmid, IPC_RMID, NULL);
+	free(q);
+	return shmdt(pool);
+}
+
+int squeue_push(struct squeue_t *q, const char *str, int lock)
+{
+	int i;
+
+	if (q==NULL)
+		return -1;
+//	if (q->mode == Q_CREAT) {
+//		printf("squeue_push: cannot push from the creator\n");
+//		return -1;
+//	}
+
+	if (str==NULL||strlen(str)>ITEM_SIZE)
+		return -1;
+	do {
+		if (q->squeue_idx >= ITEM_MAX) {
+			while (q->pool[0]!='\0') {
+				q->squeue_locks++;
+				if (!lock) {
+					printf("buffer is full\n");
+					return -1;
+				}
+				usleep(100);
+			}
+			q->squeue_idx = 0;
+		}
+		
+		for(i=q->squeue_idx*ITEM_SIZE;i<POOL_SIZE;i+=ITEM_SIZE) {
+			if (q->pool[i]=='\0') {
+				strcpy(q->pool+i, str);
+				q->squeue_idx++;
+				return 1;
+			}
+		}
+		q->squeue_locks++;
+	} while (lock);
+	q->squeue_lost++;
+
+	return 0;
+}
+
+int squeue_push2(struct squeue_t *q, const char *head, const char *str, int lock)
+{
+	int ret;
+	char *buf = malloc(strlen(head) + strlen(str) + 2);
+	strcpy(buf, head);
+	strcat(buf, ":");
+	strcat(buf, str);
+	ret = squeue_push(q, buf, lock);
+	free(buf);
+	return ret;
+}
+
+int squeue_pop(struct squeue_t *q)
+{
+	int i;
+	int two = 1;
+
+	if (q==NULL)
+		return -1;
+//	if (q->mode == Q_OPEN) { // cannot pop when not owner of squeue
+//		fprintf(stderr, "squeue_pop: cannot pop when you are not owner.\n");
+//		return -1;
+//	}
+	for(two=1;two--;q->head_idx = 0)
+		for(i=q->head_idx*ITEM_SIZE;i<POOL_SIZE;i+=ITEM_SIZE) {
+			if (q->pool[i]!='\0') {
+				q->pool[i]='\0';
+				q->head_idx++;
+				q->squeue_pops++;
+				return 1;
+			}
+		}
+	q->squeue_oops++;
+	fprintf(stderr, "WARNING: race condition detected in squeue.\n");
+	return 0;
+}
+
+char *squeue_get(struct squeue_t *q, int lock)
+{
+	int i=0;
+	int two = 1;
+
+	if(q==NULL)
+		return NULL;
+//	if (q->mode == Q_OPEN) { // cannot pop when not owner of squeue
+//		fprintf(stderr, "squeue_get: cannot pop when you are not owner.\n");
+//		return NULL;
+//	}
+	do {
+		for(two=1;two--;q->head_idx = 0) {
+			for(i=q->head_idx*ITEM_SIZE;i<POOL_SIZE;i+=ITEM_SIZE)
+				if (q->pool[i]!='\0')
+					return q->pool+i;
+		}
+		if (lock)
+			usleep(100);
+	} while (lock);
+	return NULL;
+}
+
+void squeue_stats(struct squeue_t *q)
+{
+	if(q==NULL)
+		return;
+	printf("Queue locks: %d\n", q->squeue_locks);
+	printf("Queue lost: %d\n", q->squeue_lost);
+	printf("Queue oops: %d\n", q->squeue_oops);
+	printf("Queue pops: %d\n", q->squeue_pops);
+}
+
+#if _MAIN_
+struct squeue_t *q;
+
+int sigc()
+{
+	squeue_stats(q);
+	exit(1);
+}
+
+int main()
+{
+	char buf[102];
+	int i;
+	int pid;
+
+	signal(SIGINT, sigc);
+
+	squeue_release("/dev/null");
+
+	pid = fork();
+	if (pid) {
+		q = squeue_open("/dev/null", Q_CREAT);
+		if (q == NULL) {
+			perror("oops");
+			kill(pid, SIGINT);
+			return;
+		}
+		squeue_push(q, "Hello World", 0);
+		squeue_push(q, "jeje msg 2", 0);
+
+		while(1) {
+			char *uh = squeue_get(q,1);
+			if (uh) {
+				printf("get: (%s)\n", uh);
+				squeue_pop(q);
+			}
+			usleep(100);
+		}
+		squeue_close(q);
+	} else {
+		q = squeue_open("/dev/null", Q_WAIT);
+		if (q == NULL) {
+			perror("oops");
+			return;
+		}
+		for(i=0;i<128;i++) {
+			sprintf(buf, "puta%d", i);
+			squeue_push(q, buf, 1);
+			usleep(100);
+		}
+		squeue_stats(q);
+		printf("cya\n");
+		squeue_close(q);
+	}
+
+	return 0;
+}
+#endif

src/squeue/squeue.h

@@ -0,0 +1,28 @@
+struct squeue_t {
+	int shmid;
+	int mode;
+	char *pool;
+	/* pointers */
+	int head_idx;
+	int squeue_idx;
+	/* counters */
+	int squeue_locks;
+	int squeue_lost;
+	int squeue_oops;
+	int squeue_pops;
+};
+
+
+#define Q_OPEN 0
+#define Q_CREAT 1
+#define Q_WAIT 2
+
+int squeue_release(const char *file);
+struct squeue_t *squeue_open(const char *file, int init);
+int squeue_close(struct squeue_t *q);
+void squeue_free(struct squeue_t *q);
+int squeue_push(struct squeue_t *q, const char *str, int lock);
+int squeue_push2(struct squeue_t *q, const char *head, const char *str, int lock);
+int squeue_pop(struct squeue_t *q);
+char *squeue_get(struct squeue_t *q, int lock);
+void squeue_stats(struct squeue_t *q);

src/squeue/squeue.vapi

@@ -0,0 +1,45 @@
+using GLib;
+
+[CCode (lower_case_cprefix = "squeue_", cheader_filename = "squeue.h")]
+namespace SQueues {
+	[CCode (cname = "struct squeue_t", free_function = "squeue_free")]
+	public struct SQueue {
+		int shmid;
+		int mode;
+		char *pool;
+		/* pointers */
+		int head_idx;
+		int queue_idx;
+		/* counters */
+		int locks;
+		int lost;
+		int oops;
+		int pops;
+		[CCode (cname = "squeue_open")]
+		public static SQueue* open(string file, int mode);
+		[CCode (cname = "squeue_push")]
+		public int push(string msg, int l);
+		[CCode (cname = "squeue_push2")]
+		public int push2(string cmd, string msg, int l);
+		[CCode (cname = "squeue_get")]
+		public unowned string get(int l);
+		[CCode (cname = "squeue_pop")]
+		public int pop();
+		[CCode (cname = "squeue_stats")]
+		public int stats();
+		[CCode (cname = "squeue_close")]
+		public int close();
+		[CCode (cname = "squeue_free")]
+		public int free();
+		[CCode (cname = "squeue_release")]
+		public static int release(string file);
+		
+	}
+
+	[CCode (cprefix = "Q_", cheader_fileneme = "squeue.h")]
+        public enum SQueueMode {
+		OPEN   = 0,
+		CREAT  = 1,
+		WAIT   = 2
+	}
+}

src/usb-device.c

@@ -0,0 +1,349 @@
+/*
+    0xFFFF - Open Free Fiasco Firmware Flasher
+    Copyright (C) 2012  Pali Rohár <pali.rohar@gmail.com>
+
+    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 3 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, see <http://www.gnu.org/licenses/>.
+
+*/
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdint.h>
+#include <string.h>
+#include <errno.h>
+#include <ctype.h>
+
+#include <usb.h>
+
+#include "global.h"
+#include "device.h"
+#include "usb-device.h"
+#include "printf-utils.h"
+#include "nolo.h"
+#include "cold-flash.h"
+#include "mkii.h"
+
+static struct usb_flash_device usb_devices[] = {
+	{ 0x0421, 0x0105,  2,  1, -1, FLASH_NOLO, { DEVICE_SU_18, DEVICE_RX_44, DEVICE_RX_48, DEVICE_RX_51, 0 } },
+	{ 0x0421, 0x0106,  0, -1, -1, FLASH_COLD, { DEVICE_RX_51, 0 } },
+/*	{ 0x0421, 0x01c7,  0, -1, -1, FLASH_DISK, { DEVICE_RX_51, 0 } }, */
+/*	{ 0x0421, 0x01c8,  1,  1, -1, FLASH_MKII, { DEVICE_RX_51, 0 } }, */
+/*	{ 0x0421, 0x0431,  0, -1, -1, FLASH_DISK, { DEVICE_SU_18, DEVICE_RX_34, 0 } }, */
+	{ 0x0421, 0x3f00,  2,  1, -1, FLASH_NOLO, { DEVICE_RX_34, 0 } },
+};
+
+static const char * usb_flash_protocols[] = {
+	[FLASH_NOLO] = "NOLO",
+	[FLASH_COLD] = "Cold flashing",
+	[FLASH_MKII] = "Mk II protocol",
+	[FLASH_DISK] = "RAW disk",
+};
+
+const char * usb_flash_protocol_to_string(enum usb_flash_protocol protocol) {
+
+	if ( protocol > sizeof(usb_flash_protocols) )
+		return NULL;
+
+	return usb_flash_protocols[protocol];
+
+}
+
+static void usb_flash_device_info_print(const struct usb_flash_device * dev) {
+
+	int i;
+
+	PRINTF_ADD("USB device: %s", device_to_string(dev->devices[0]));
+
+	for ( i = 1; dev->devices[i]; ++i )
+		PRINTF_ADD("/%s", device_to_string(dev->devices[i]));
+
+	PRINTF_ADD(" (%#04x:%#04x) in %s mode", dev->vendor, dev->product, usb_flash_protocol_to_string(dev->protocol));
+
+}
+
+static void usb_descriptor_info_print(usb_dev_handle * udev, struct usb_device * dev, char * product, size_t size) {
+
+	char buf[1024];
+	char buf2[1024];
+	unsigned int x;
+	int ret;
+	int i;
+
+	memset(buf, 0, sizeof(buf));
+	usb_get_string_simple(udev, dev->descriptor.iProduct, buf, sizeof(buf));
+	PRINTF_LINE("USB device product string: %s", buf[0] ? buf : "(not detected)");
+	PRINTF_END();
+
+	if ( product && buf[0] )
+		strncpy(product, buf, size);
+
+	memset(buf, 0, sizeof(buf));
+	memset(buf2, 0, sizeof(buf2));
+	ret = usb_get_string_simple(udev, dev->descriptor.iSerialNumber, buf, sizeof(buf));
+	if ( ! isalnum(buf[0]) )
+		buf[0] = 0;
+	for ( i = 0; i < ret; i+=2 ) {
+		sscanf(buf+i, "%2x", &x);
+		if ( x > 32 && x < 128 )
+			buf2[i/2] = x;
+		else {
+			buf2[0] = 0;
+			break;
+		}
+	}
+	if ( ! isalnum(buf2[0]) )
+		buf2[0] = 0;
+	PRINTF_LINE("USB device serial number string: %s", buf2[0] ? buf2 : ( buf[0] ? buf : "(not detected)" ));
+	PRINTF_END();
+
+}
+
+static struct usb_device_info * usb_device_is_valid(struct usb_device * dev) {
+
+	int i;
+	char product[1024];
+	struct usb_device_info * ret = NULL;
+
+	for ( i = 0; usb_devices[i].vendor; ++i ) {
+
+		if ( dev->descriptor.idVendor == usb_devices[i].vendor && dev->descriptor.idProduct == usb_devices[i].product ) {
+
+			printf("\b\b  ");
+			PRINTF_END();
+			PRINTF_ADD("Found ");
+			usb_flash_device_info_print(&usb_devices[i]);
+			PRINTF_END();
+
+			PRINTF_LINE("Opening USB...");
+			usb_dev_handle * udev = usb_open(dev);
+			if ( ! udev ) {
+				PRINTF_ERROR("usb_open failed");
+				fprintf(stderr, "\n");
+				return NULL;
+			}
+
+			usb_descriptor_info_print(udev, dev, product, sizeof(product));
+
+#if defined(LIBUSB_HAS_GET_DRIVER_NP) && defined(LIBUSB_HAS_DETACH_KERNEL_DRIVER_NP)
+			PRINTF_LINE("Detaching kernel from USB interface...");
+			usb_detach_kernel_driver_np(udev, usb_devices[i].interface);
+#endif
+
+			PRINTF_LINE("Claiming USB interface...");
+			if ( usb_claim_interface(udev, usb_devices[i].interface) < 0 ) {
+				PRINTF_ERROR("usb_claim_interface failed");
+				fprintf(stderr, "\n");
+				usb_close(udev);
+				return NULL;
+			}
+
+			if ( usb_devices[i].alternate >= 0 ) {
+				PRINTF_LINE("Setting alternate USB interface...");
+				if ( usb_set_altinterface(udev, usb_devices[i].alternate) < 0 ) {
+					PRINTF_ERROR("usb_claim_interface failed");
+					fprintf(stderr, "\n");
+					usb_close(udev);
+					return NULL;
+				}
+			}
+
+			if ( usb_devices[i].configuration >= 0 ) {
+				PRINTF_LINE("Setting USB configuration...");
+				if ( usb_set_configuration(udev, usb_devices[i].configuration) < 0 ) {
+					PRINTF_ERROR("usb_set_configuration failed");
+					fprintf(stderr, "\n");
+					usb_close(udev);
+					return NULL;
+				}
+			}
+
+			ret = calloc(1, sizeof(struct usb_device_info));
+			if ( ! ret ) {
+				ALLOC_ERROR();
+				usb_close(udev);
+				return NULL;
+			}
+
+			if ( strstr(product, "N900") )
+				ret->device = DEVICE_RX_51;
+			else
+				ret->device = DEVICE_UNKNOWN;
+
+			/* TODO: Autodetect more devices */
+
+			if ( device_to_string(ret->device) )
+				PRINTF_LINE("Detected USB device: %s", device_to_string(ret->device));
+			else
+				PRINTF_LINE("Detected USB device: (not detected)");
+			PRINTF_END();
+
+			if ( ret->device ) {
+				enum device * device;
+				for ( device = usb_devices[i].devices; *device; ++device )
+					if ( *device == ret->device )
+						break;
+				if ( ! *device ) {
+					ERROR("Device mishmash");
+					fprintf(stderr, "\n");
+					usb_close(udev);
+					return NULL;
+				}
+			}
+
+			ret->hwrev = -1;
+			ret->flash_device = &usb_devices[i];
+			ret->udev = udev;
+			break;
+		}
+	}
+
+	return ret;
+
+}
+
+static struct usb_device_info * usb_search_device(struct usb_device * dev, int level) {
+
+	int i;
+	struct usb_device_info * ret = NULL;
+
+	if ( ! dev )
+		return NULL;
+
+	ret = usb_device_is_valid(dev);
+	if ( ret )
+		return ret;
+
+	for ( i = 0; i < dev->num_children; i++ ) {
+		ret = usb_search_device(dev->children[i], level + 1);
+		if ( ret )
+			break;
+	}
+
+	return ret;
+
+}
+
+struct usb_device_info * usb_open_and_wait_for_device(void) {
+
+	struct usb_bus * bus;
+	struct usb_device_info * ret = NULL;
+	int i = 0;
+	static char progress[] = {'/','-','\\', '|'};
+
+	usb_init();
+	usb_find_busses();
+
+	PRINTF_BACK();
+	printf("\n");
+
+	while ( 1 ) {
+
+		PRINTF_LINE("Waiting for USB device... %c", progress[++i%sizeof(progress)]);
+
+		usb_find_devices();
+
+		for ( bus = usb_get_busses(); bus; bus = bus->next ) {
+
+			if ( bus->root_dev )
+				ret = usb_search_device(bus->root_dev, 0);
+			else {
+				struct usb_device *dev;
+				for ( dev = bus->devices; dev; dev = dev->next ) {
+					ret = usb_search_device(dev, 0);
+					if ( ret )
+						break;
+				}
+			}
+
+			if ( ret )
+				break;
+
+		}
+
+		if ( ret )
+			break;
+
+		usleep(0xc350); // 0.5s
+
+	}
+
+	PRINTF_BACK();
+	printf("\n");
+
+	if ( ! ret )
+		return NULL;
+
+	return ret;
+
+}
+
+void usb_close_device(struct usb_device_info * dev) {
+
+	usb_close(dev->udev);
+	free(dev);
+
+}
+
+void usb_switch_to_nolo(struct usb_device_info * dev) {
+
+	printf("\nSwitching to NOLO mode...\n");
+
+	if ( dev->flash_device->protocol == FLASH_COLD )
+		leave_cold_flash(dev);
+	else if ( dev->flash_device->protocol == FLASH_MKII )
+		mkii_reboot_device(dev);
+	else if ( dev->flash_device->protocol == FLASH_DISK )
+		printf_and_wait("Unplug USB cable, turn device off, press ENTER and plug USB cable again");
+
+}
+
+void usb_switch_to_cold(struct usb_device_info * dev) {
+
+	printf("\nSwitching to Cold Flash mode...\n");
+
+	if ( dev->flash_device->protocol == FLASH_NOLO )
+		nolo_reboot_device(dev);
+	else if ( dev->flash_device->protocol == FLASH_MKII )
+		mkii_reboot_device(dev);
+	else if ( dev->flash_device->protocol == FLASH_DISK )
+		printf_and_wait("Unplug USB cable, turn device off, press ENTER and plug USB cable again");
+
+}
+
+void usb_switch_to_mkii(struct usb_device_info * dev) {
+
+	printf("\nSwitching to Update mode...\n");
+
+	if ( dev->flash_device->protocol == FLASH_COLD )
+		leave_cold_flash(dev);
+	else if ( dev->flash_device->protocol == FLASH_NOLO )
+		nolo_boot_device(dev, "update");
+	else if ( dev->flash_device->protocol == FLASH_DISK )
+		printf_and_wait("Unplug USB cable, turn device off, press ENTER and plug USB cable again");
+
+}
+
+void usb_switch_to_disk(struct usb_device_info * dev) {
+
+	printf("\nSwitching to RAW disk mode...\n");
+
+	if ( dev->flash_device->protocol == FLASH_COLD )
+		leave_cold_flash(dev);
+	else if ( dev->flash_device->protocol == FLASH_NOLO ) {
+		nolo_boot_device(dev, NULL);
+		printf_and_wait("Wait until device start, choose USB Mass Storage Mode and press ENTER");
+	} else if ( dev->flash_device->protocol == FLASH_MKII )
+		mkii_reboot_device(dev);
+
+}

src/usb-device.h

@@ -0,0 +1,62 @@
+/*
+    0xFFFF - Open Free Fiasco Firmware Flasher
+    Copyright (C) 2012  Pali Rohár <pali.rohar@gmail.com>
+
+    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 3 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, see <http://www.gnu.org/licenses/>.
+
+*/
+
+#ifndef USB_DEVICE_H
+#define USB_DEVICE_H
+
+#include <usb.h>
+
+#include "device.h"
+
+enum usb_flash_protocol {
+	FLASH_UNKN = 0,
+	FLASH_NOLO,
+	FLASH_COLD,
+	FLASH_MKII,
+	FLASH_DISK,
+	FLASH_COUNT,
+};
+
+struct usb_flash_device {
+	uint16_t vendor;
+	uint16_t product;
+	int interface;
+	int alternate;
+	int configuration;
+	enum usb_flash_protocol protocol;
+	enum device devices[DEVICE_COUNT];
+};
+
+struct usb_device_info {
+	enum device device;
+	int16_t hwrev;
+	const struct usb_flash_device * flash_device;
+	usb_dev_handle * udev;
+};
+
+const char * usb_flash_protocol_to_string(enum usb_flash_protocol protocol);
+struct usb_device_info * usb_open_and_wait_for_device(void);
+void usb_close_device(struct usb_device_info * dev);
+
+void usb_switch_to_nolo(struct usb_device_info * dev);
+void usb_switch_to_cold(struct usb_device_info * dev);
+void usb_switch_to_mkii(struct usb_device_info * dev);
+void usb_switch_to_disk(struct usb_device_info * dev);
+
+#endif

src/utils.c

@@ -1,55 +0,0 @@
-/*
- *  0xFFFF - Open Free Fiasco Firmware Flasher
- *  Copyright (C) 2007  pancake <pancake@youterm.com>
- *
- *  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 3 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, see <http://www.gnu.org/licenses/>.
- */
-
-#include "main.h"
-#include <usb.h>
-#include <stdio.h>
-#include <string.h>
-#include <stdlib.h>
-
-unsigned long get_file_size(char *file)
-{
-	FILE *fd = fopen(file, "r");
-	unsigned long len = 0;
-	if (fd == NULL) {
-		fprintf(stderr, "Cannot open file '%s'\n", file);
-		exit(1);
-	}
-	fseek(fd, 0, SEEK_END);
-	len = ftell(fd);
-	fclose(fd);
-	return len;
-}
-
-void progressbar(unsigned long long part, unsigned long long total)
-{
-        char *columns = getenv("COLUMNS");
-	int pc;
-        int tmp, cols = 80;
-
-	pc = (int)(part*100/total);
-        (pc<0)?pc=0:(pc>100)?pc=100:0;
-        printf("\e[K  %3d%% [", pc);
-        if (columns)
-                cols = atoi(columns);
-        cols-=15;
-        for(tmp=cols*pc/100;tmp;tmp--) printf("#");
-        for(tmp=cols-(cols*pc/100);tmp;tmp--) printf("-");
-        printf("]\r");
-        fflush(stdout);
-}