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;

INSTALL

@@ -0,0 +1,29 @@
+Installation instructions:
+==========================
+
+To build the flasher you will need gcc, make and libusb. For crosscompiling
+to arm you can use scratchbox. But you will probably need the libusb.so of
+the scratchbox environment to the device.
+
+Just type:
+
+  $ make
+
+The most interesting targets for make are:
+
+  all        normal build
+  allusb     builds 0xFFFF without libusb dependency (embedded)
+  static     builds 0xFFFF statically (no need for libusb)
+
+  install    installs into /usr/local by default
+
+  clean      clean compilation objects and generated binaries
+
+
+The installation procedure is quite simple and you can define a new PREFIX
+manually from the command line:
+
+  $ sudo make install PREFIX=/usr
+
+The default one is /usr/local (not very userfriendly but standards are
+standards :P hehe)

Makefile

@@ -0,0 +1,42 @@
+include config.mk
+PREFIX?=/usr/local
+DESTDIR?=
+
+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
+	cd src && ${MAKE} allusb
+
+logot:
+	cd logotool && ${MAKE} all
+
+clean:
+	cd src && ${MAKE} clean
+	cd libusb && ${MAKE} clean
+	cd logotool && ${MAKE} clean
+
+install:
+	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 ${DESTDIR}${PREFIX}/bin/0xFFFF
+	rm -f ${DESTDIR}${PREFIX}/bin/logotool
+	rm -f ${DESTDIR}${PREFIX}/bin/goxf
+	rm ${DESTDIR}${PREFIX}/share/applications/0xFFFF.desktop

README

@@ -1,6 +1,5 @@
 
 
-
     ------.    ,---------.--.--.
    /       |  ___        |  |  |  \\------------ -- .  
    | .__  / \/   .   ____/ _/ _/      The 0pen
@@ -11,21 +10,32 @@
                _/ ___|_.|__|
                 '`
 
-The 'Free Fiasco Firmware Flasher' aka 0xFFFF utility tries to implement
+The 'Free Fiasco Firmware Flasher' aka 0xFFFF utility implements a free
-a free (GPL'd) userspace handler for the NOLO bootloader.
+(under the GPLv3 license) userspace handler for the NOLO bootloader and
+extended features for flashing, dumping and getting information for the
+Nokia Internet Tablets.
 
 Use it with CARE. This is an experimental tool and it can brick your device.
 It's not suposed to be stable, so nokia will probably release incompatible
 bootloaders to break this tool. USE IT AT YOUR OWN RISK.
 
-This tool has been designed and tested on n770. The n800 flash should work
-but it's not tested and is known to use different request codes.
-
 PLEASE. Read carefully all the documentation inside doc/* for more information
 before building or using the flasher to avoid questions, problems or so.
 
+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

@@ -0,0 +1,60 @@
+Bug#:      1584
+Opened:    2007-06-25 23:06 GMT+3
+Reporter:  Robert Schuster <thebohemian [at] gmx.net>
+Summary:   provide system management software under free software licenses
+
+Several applications and libraries found on the N800 internet tablet/IT OS
+2007.10 are distributed under restricted and non-free license terms according
+to the Debian Free Software Guidelines, Open Source Definition and Free
+Software definition.
+
+I hereby politely ask for distributing those components under terms that are
+acceptable to the above mentioned guidelines.
+
+The applications of interest are:
+from the initfs: activate_panel, bt-cal, cal-tool, fb-chaimage, text2screen,
+wlan-cal, wlan-fw-update, retu-time, show_image, dsme, battest, bootstate,
+dsmetool, dspctl, waitfordsme and the script linuxrc
+
+the libraries of interest are:
+libbmeic.so, libcal.so, libdsme.so, libppu.so, libactivitymonitor.so,
+libcalmodule.so, libhwwd.so, libinactivity-blank.so, liblifeguard.so,
+libperipheral.so, libprocesswd.so, libstartup.so, libstate.so,
+libtemperature.so
+
+There may be other software artifacts which are of interest for which I will
+file separate bugreports if there is a need for them.
+
+Rationale:
+When Nokia/Maemo decided to use a variant of the GNU operating system and Linux
+as its kernel for implementing the Internet Tablet OS they profited from a
+wealth of knowledge and work invested in various software projects. With the
+help of free software licensing they were allowed to create a unique software
+environment which exactly implements the Maemo projects' goals. Maemo has
+gained and still gains from those software projects because they are
+independently developed further giving Maemo more possibilities in the future.
+
+One of the key goals of the GNU project is to give its user's the freedom to
+implement their own ideas. This goal is to be reached by writing free software
+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
+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 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
+the possible uses people have.
+
+By releasing the above mentioned programs/libraries under free software
+licenses people will be given the same possibilities the Maemo project had in
+the first place.
+
+Let us be free.

doc/dumping

@@ -3,30 +3,12 @@
 This technique consists on reconstructing a firmware image dumping
 pieces at certains offsets of the device internal memory.
 
-
+<b></b>
-<b>End user details:</b>
-
- * Extract the firmware pieces from a running device
- *
- * This functionality is useful to extract backups of your system
- * firmware. This is really useful when you're on a desert island
- * without an internet connection.
- *
- * This tool needs more testing, so take care and don't blame me if
- * it breaks your system. It *is* to your responsability, use at
- * your own risk
- *
- * NOTE: It's theorically possible to flash the device on the fly from
- * the running OS, but this has not yet been tested. Keep tuned for
- * updates and newz.
- *
- * Have fun!
-
 
 <b>Technical details:</b>
 
- * The internal flash memory is exposed to the system as MTD devices. So it's
+ * The internal flash memory is exposed to the system as MTD devices.
- * possible to dump the individual sections of a flashed firmware.
+ * Is possible to dump the individual sections of a flashed firmware.
  *
  * READ src/dump.c for detailed information.
 
@@ -40,6 +22,36 @@ pieces at certains offsets of the device internal memory.
    mtd2 - starts with NOLO img\x5c\x13 and \x00 padding
           0x00800 - zImage
 
-   mtd3 - rootfs.jffs2 (20M) aka 0x200000 vs 0x3900000
+	  > NOLO is a four byte marker, next four bytes
+	  > can vary since it is kernel image size
+
+   mtd3 - initfs.jffs2 (2M) aka 0x200000 vs 0x3900000
 
    mtd4 - rootfs.jffs2 (a fucking copy of the above rootfs?)
+
+
+// Extra notes //
+
+[MTD] NAND Consolidate oobinfo handling
+
+The info structure for out of band data was copied into
+the mtd structure. Make it a pointer and remove the ability
+to set it from userspace. The position of ecc bytes is
+defined by the hardware and should not be changed by software.
+
+// The oob stuff
+
+In mtd3 the OOB data is 64 bytes aka 0x40, and this oob stuff
+appears every 2KB aka 0x800 bytes.
+
+/*
+ * Obsolete legacy interface. Keep it in order not to break userspace
+ * interfaces
+ */
+struct nand_oobinfo {
+        uint32_t useecc;
+        uint32_t eccbytes;
+        uint32_t oobfree[8][2];
+        uint32_t eccpos[32];
+};
+

doc/faq

@@ -1,70 +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>
+  Just type '0xFFFF -r 1' as root
-
-  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>
+<b>*) How can I unpack a FIASCO firmware?
 
-  Of course! You're free to do what you want with your device :)
+  Just type '0xFFFF -r 1' as root
-
-  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>
+<b>*) How can I unpack a FIASCO firmware?</b>
 
-  Actually 0xFFFF allows you to:
+  Just type '0xFFFF -u FiascoFirmware.bin -e /tmp' as root
-  
-  - 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>
+<b>*) How can I flash a new rootfs?
 
-  NOLO is the 'server-side' part of the flasher from Nokia. NOLO means
+  Unpack the pieces from the fiasco firmware (the one distributed by Nokia for example) and then type:
-  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
+  # 0xFFFF -R -p rootfs.jffs 
-  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.
 
 
-<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
+  It is not recommended to use, it needs more testing, and is more secure to unpack them first manually
-  true at all. The first series of the n800 comes with the same usb-id 
+  and flash the pieces manually with multiple '-p' flags. If you are brave try:
-  than n770. That's weird!
 
-  So, the only way to identify the device is by asking nolo for the version
+  # 0xFFFF -F FiascoFirmware.fiasco
-  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 :)
+<h2>Advanced commands</h2>
+
+<b>*) How to extract the firmware pieces from a running device?</b>
+
+  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

@@ -0,0 +1,57 @@
+ 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!
+-----------------------------------------------
+
+  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          --  FW header length (big endian)
+
+
+FW HEADER
+
+   4 bytes          --  number of FW header blocks (big endian)
+             block {
+   1 byte           --  type of block
+                          0xE8 - Fiasco name
+                          0x31 - FW name
+   1 byte           --  length of block data
+   N bytes          --  block 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

@@ -0,0 +1,24 @@
+It is possible to flash directly from the device, so this brings the possibility
+to completely replace the bootloader flasher by a userland one with extended
+features for backuping and recovering data.
+
+The way to flash is using mtd-utils:
+
+ $ flash_eraseall -j /dev/mtd3
+ $ nandwrite -a -p /dev/mtd3 initfs.jffs2
+
+This is an specific example plagied from initfs_flasher of bootmenu.
+
+The '-j' flag says that this is a jffs2 partition. Theorically this
+flag is not required for zImage, and the bootloader pieces.
+
+The '-a' creates the OOB data automatically, and the '-p' flag pads
+the data to fill the block.
+
+These flags are only fine for initfs, so this will be probably wrong
+for other pieces. Using the dump functionality you can check if you
+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 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/oops

@@ -1,2 +0,0 @@
-Consequences of a weird flashing :)<br />
-<img src="img/n770bars.jpg">

doc/pieces

@@ -4,3 +4,40 @@ Fiasco firmware pieces
 The firmware for the maemo devices is composed by a set of pieces containing
 the required parts to update the whole system following a partition layout
 defined by NOLO on the internal flash memory.
+
+Nokia provides a blob packed with a proprietary format called 'FIASCO'. This
+blob contains the following pieces:
+
+ - omap-nand   -  only flashable via serial jtag
+ - xloader     -  first part of nolo
+ - secondary   -  second part of nolo (usb support and launches kernel)
+ - kernel      -  the kernel
+ - initfs      -  initial system that initializes everything and runs rootfs
+ - rootfs      -  the whole system image
+
+Some of these pieces are versioned to match board specific features
+(mostly xloader and secondary ones).
+
+This format is not supported by 0xFFFF at this moment, but there are no
+plans for doing it in short term. This is because we only need to flash
+separated pieces. We can just distribute tarballs containing the pieces
+and meta information with a whole Free OS for the internet tablets.
+
+To flash an initfs partition and reboot:
+
+  $ 0xFFFF -p initfs%initfs.jffs2 -R
+
+The format of the argument is [piece-type] % [file-name] (% [version-string]).
+
+Pieces can be automatically identified by using the '-I' flag:
+
+  $ 0xFFFF -I initfs.jffs2
+  initfs.jffs2: initfs
+
+You can dump these pieces from the internal memory of the internet
+tablet by using the mtd-utils over /dev/mtd* or just running:
+
+  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,34 +1,48 @@
 <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
   - reboot de mother board
   - extract the current firmware pieces from the device (dump)
   - set the USB host/slave mode
-  - set the R&R mode
+  - pack/unpack fiasco firmwares
+  - fine grained R&D flags support
   - identify firmware pieces
+  - dump mtd partitions (embedded mtd-utils source code)
+  - reconstruct initfs from a dump
+  - dump config partition
+  - automatic piece identifier
+  - console mode (shell like)
   </pre>
 This is the help message of the tool:
 <pre>
 <b>~$ 0xFFFF -h</b>
-0xFFFF v0.1  - The Open Free Fiasco Firmware Flasher
+0xFFFF v0.3  // The Free Fiasco Firmware Flasher
- -b [arg]      boots the kernel with arguments
+ -b [arg]       boots the kernel with arguments
- -e [path]     dump the firmware pieces into the path
+ -c             console prompt mode
- -p [[p:]file] piece-of-firmware : file-where-this-piece-is
+ -C [/dev/mtd]  check bad blocks on mtd
- -r [0|1]      disable/enable R&D mode
+ -d [vid:pid]   injects a usb device into the supported list
- -u [fiasco]   unpack target fiasco image
+ -D [0|1|2]     sets the root device to flash (0), mmc (1) or usb (2)
- -U [0|1]      disable/enable the usb host mode
+ -e [path]      dump and extract pieces to path
- -h            show this help message
+ -f <flags>     set the given RD flags (see '-f help')
- -i            show device information (let standby mode)
+ -F [fiasco]    flash a fiasco firmware image
- -I [piece]    identify a firmware piece
+ -h             show this help message
- -l            list supported usb device ids
+ -H [file]      calculate hash for file
- -d [vid:pid]  injects a usb device into the supported list
+ -i             show device information (let standby mode)
- -R            reboot the omap board
+ -I [piece]     identify a firmware piece
- -v            be verbose and noisy
+ -l, -L         list supported usb device ids
- -V            show 0xFFFF version information
+ -p [[p%]file]  piece-of-firmware % file-where-this-piece-is
+ -r [0|1]       disable/enable R&D mode
+ -R             reboot the omap board
+ -s [serial]    serial port console (minicom like terminal)
+ -u [fiasco]    unpack target fiasco image
+ -U [0|1]       disable/enable the usb host mode
+ -v             be verbose and noisy
+ -V             show 0xFFFF version information
+ -x             extract configuration entries from /dev/mtd1
 Pieces are: xloader secondary kernel initfs rootfs omap-nand 
 </pre>
 

libusb/Makefile

@@ -0,0 +1,8 @@
+#include ../config.mk
+OBJ=linux.o usb.o descriptors.o error.o
+
+all: ${OBJ}
+	${CC} ${CFLAGS} ${LDFLAGS} -fPIC -I . ${OBJ} -shared -o libusb.so
+
+clean:
+	-rm -f libusb.so ${OBJ}

libusb/bsd.c

@@ -0,0 +1,637 @@
+/*
+ * (Free|Open|Net)BSD USB support
+ *
+ * Derived from Linux version by Richard Tobin.
+ *
+ * $Id: bsd.c,v 1.33 2006/03/04 01:16:10 jerdfelt Exp $
+ * $Name:  $
+ *
+ * This library is covered by the LGPL, read LICENSE for details.
+ */
+
+/*
+ * Note: I don't have a clue what I'm doing.  I just looked at the
+ * man pages and source to try and find things that did the same as
+ * the Linux version. -- Richard
+ *
+ * johnjen@reynoldsnet.org - minor fixes with debug mode output. Consistent brace
+ * use as well as indenting. More error messages put in to test for failure
+ * modes with /dev/ permissions (when it happens). Note: I, like Richard, have
+ * no clue what I'm doing. Patches to increase/fix functionality happily
+ * accepted!
+ */
+
+/* dirkx@webweaving.org - minor changes to make things actually work
+ * 	for both read and write.
+ */
+
+#if defined(__FreeBSD__) && !defined(__FreeBSD_kernel__)
+#define __FreeBSD_kernel__ __FreeBSD__
+#endif
+
+#include <stdlib.h>
+#include <unistd.h>
+#include <string.h>
+#include <stdio.h>
+#include <fcntl.h>
+#include <errno.h>
+#include <assert.h>
+#include <sys/time.h>
+#include <sys/ioctl.h>
+
+#include <dev/usb/usb.h>
+
+#include "usbi.h"
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#ifdef HAVE_OLD_DEV_USB_USB_H
+/*
+ * It appears some of the BSD's (OpenBSD atleast) have switched over to a
+ * new naming convention, so we setup some macro's for backward
+ * compability with older versions --jerdfelt
+ */
+
+/* struct usb_ctl_request */
+#define ucr_addr		addr
+#define ucr_request		request
+#define ucr_data		data
+#define ucr_flags		flags
+#define ucr_actlen		actlen
+
+/* struct usb_alt_interface */
+#define uai_config_index	config_index
+#define uai_interface_index	interface_index
+#define uai_alt_no		alt_no
+
+/* struct usb_config_desc */
+#define ucd_config_index	config_index
+#define ucd_desc		desc
+
+/* struct usb_interface_desc */
+#define uid_config_index	config_index
+#define uid_interface_index	interface_index
+#define uid_alt_index		alt_index
+#define uid_desc		desc
+
+/* struct usb_endpoint_desc */
+#define ued_config_index	config_index
+#define ued_interface_index	interface_index
+#define ued_alt_index		alt_index
+#define ued_endpoint_index	endpoint_index
+#define ued_desc		desc
+
+/* struct usb_full_desc */
+#define ufd_config_index	config_index
+#define ufd_size		size
+#define ufd_data		data
+
+/* struct usb_string_desc */
+#define usd_string_index	string_index
+#define usd_language_id		language_id
+#define usd_desc		desc
+
+/* struct usb_ctl_report_desc */
+#define ucrd_size		size
+#define ucrd_data		data
+
+/* struct usb_device_info */
+#define udi_bus			bus
+#define udi_addr		addr
+#define udi_cookie		cookie
+#define udi_product		product
+#define udi_vendor		vendor
+#define udi_release		release
+#define udi_productNo		productNo
+#define udi_vendorNo		vendorNo
+#define udi_releaseNo		releaseNo
+#define udi_class		class
+#define udi_subclass		subclass
+#define udi_protocol		protocol
+#define udi_config		config
+#define udi_lowspeed		lowspeed
+#define udi_power		power
+#define udi_nports		nports
+#define udi_devnames		devnames
+#define udi_ports		ports
+
+/* struct usb_ctl_report */
+#define ucr_report		report
+#define ucr_data		data
+
+/* struct usb_device_stats */
+#define uds_requests		requests
+#endif
+
+static int ensure_ep_open(usb_dev_handle *dev, int ep, int mode);
+
+#define MAX_CONTROLLERS 10
+
+/* This records the file descriptors for the endpoints.  It doesn't seem
+   to work to re-open them for each read (as well as being inefficient). */
+
+struct bsd_usb_dev_handle_info {
+    int ep_fd[USB_MAX_ENDPOINTS];
+};
+
+int usb_os_open(usb_dev_handle *dev)
+{
+  int i;
+  struct bsd_usb_dev_handle_info *info;
+  char ctlpath[PATH_MAX + 1];
+
+  info = malloc(sizeof(struct bsd_usb_dev_handle_info));
+  if (!info)
+    USB_ERROR(-ENOMEM);
+  dev->impl_info = info;
+
+#ifdef __FreeBSD_kernel__
+  snprintf(ctlpath, PATH_MAX, "%s", dev->device->filename);
+#else
+  snprintf(ctlpath, PATH_MAX, "%s.00", dev->device->filename);
+#endif
+  dev->fd = open(ctlpath, O_RDWR);
+  if (dev->fd < 0) {
+    dev->fd = open(ctlpath, O_RDONLY);
+    if (dev->fd < 0) {
+      free(info);
+      USB_ERROR_STR(-errno, "failed to open %s: %s",
+                    ctlpath, strerror(errno));
+    }
+  }
+
+  /* Mark the endpoints as not yet open */
+  for (i = 0; i < USB_MAX_ENDPOINTS; i++)
+    info->ep_fd[i] = -1;
+
+  return 0;
+}
+
+int usb_os_close(usb_dev_handle *dev)
+{
+  struct bsd_usb_dev_handle_info *info = dev->impl_info;
+  int i;
+
+  /* Close any open endpoints */
+
+  for (i = 0; i < USB_MAX_ENDPOINTS; i++)
+    if (info->ep_fd[i] >= 0) {
+      if (usb_debug >= 2)
+        fprintf(stderr, "usb_os_close: closing endpoint %d\n", info->ep_fd[i]);
+      close(info->ep_fd[i]);
+    }
+
+  free(info);
+
+  if (dev->fd <= 0)
+    return 0;
+
+  if (close(dev->fd) == -1)
+    /* Failing trying to close a file really isn't an error, so return 0 */
+    USB_ERROR_STR(0, "tried to close device fd %d: %s", dev->fd,
+                  strerror(errno));
+
+  return 0;
+}
+
+int usb_set_configuration(usb_dev_handle *dev, int configuration)
+{
+  int ret;
+
+  ret = ioctl(dev->fd, USB_SET_CONFIG, &configuration);
+  if (ret < 0)
+    USB_ERROR_STR(-errno, "could not set config %d: %s", configuration,
+                  strerror(errno));
+
+  dev->config = configuration;
+
+  return 0;
+}
+
+int usb_claim_interface(usb_dev_handle *dev, int interface)
+{
+  /* BSD doesn't have the corresponding ioctl.  It seems to
+     be sufficient to open the relevant endpoints as needed. */
+
+  dev->interface = interface;
+
+  return 0;
+}
+
+int usb_release_interface(usb_dev_handle *dev, int interface)
+{
+  /* See above */
+  return 0;
+}
+
+int usb_set_altinterface(usb_dev_handle *dev, int alternate)
+{
+  int ret;
+  struct usb_alt_interface intf;
+
+  if (dev->interface < 0)
+    USB_ERROR(-EINVAL);
+
+  intf.uai_interface_index = dev->interface;
+  intf.uai_alt_no = alternate;
+
+  ret = ioctl(dev->fd, USB_SET_ALTINTERFACE, &intf);
+  if (ret < 0)
+    USB_ERROR_STR(-errno, "could not set alt intf %d/%d: %s",
+                  dev->interface, alternate, strerror(errno));
+
+  dev->altsetting = alternate;
+
+  return 0;
+}
+
+static int ensure_ep_open(usb_dev_handle *dev, int ep, int mode)
+{
+  struct bsd_usb_dev_handle_info *info = dev->impl_info;
+  int fd;
+  char buf[20];
+
+  /* Get the address for this endpoint; we could check
+   * the mode against the direction; but we've done that
+   * already in the usb_bulk_read/write.
+   */
+  ep = UE_GET_ADDR(ep);
+
+  if (info->ep_fd[ep] < 0) {
+#ifdef __FreeBSD_kernel__
+    snprintf(buf, sizeof(buf) - 1, "%s.%d", dev->device->filename, ep);
+#else
+    snprintf(buf, sizeof(buf) - 1, "%s.%02d", dev->device->filename, ep);
+#endif
+    /* Try to open it O_RDWR first for those devices which have in and out
+     * endpoints with the same address (eg 0x02 and 0x82)
+     */
+    fd = open(buf, O_RDWR);
+    if (fd < 0 && errno == ENXIO)
+      fd = open(buf, mode);
+    if (fd < 0)
+      USB_ERROR_STR(-errno, "can't open %s for bulk read: %s",
+                    buf, strerror(errno));
+    info->ep_fd[ep] = fd;
+  }
+
+  return info->ep_fd[ep];
+}
+
+int usb_bulk_write(usb_dev_handle *dev, int ep, char *bytes, int size,
+                   int timeout)
+{
+  int fd, ret;
+
+  /* Ensure the endpoint address is correct */
+  ep &= ~USB_ENDPOINT_IN;
+
+  fd = ensure_ep_open(dev, ep, O_WRONLY);
+  if (fd < 0) {
+    if (usb_debug >= 2) {
+#ifdef __FreeBSD_kernel__
+      fprintf (stderr, "usb_bulk_write: got negative open file descriptor for endpoint %d\n", UE_GET_ADDR(ep));
+#else
+      fprintf (stderr, "usb_bulk_write: got negative open file descriptor for endpoint %02d\n", UE_GET_ADDR(ep));
+#endif
+    }
+    return fd;
+  }
+
+  ret = ioctl(fd, USB_SET_TIMEOUT, &timeout);
+  if (ret < 0)
+    USB_ERROR_STR(-errno, "error setting timeout: %s",
+                  strerror(errno));
+
+  ret = write(fd, bytes, size);
+  if (ret < 0)
+#ifdef __FreeBSD_kernel__
+    USB_ERROR_STR(-errno, "error writing to bulk endpoint %s.%d: %s",
+                  dev->device->filename, UE_GET_ADDR(ep), strerror(errno));
+#else
+    USB_ERROR_STR(-errno, "error writing to bulk endpoint %s.%02d: %s",
+                dev->device->filename, UE_GET_ADDR(ep), strerror(errno));
+#endif
+
+  return size;
+}
+
+int usb_bulk_read(usb_dev_handle *dev, int ep, char *bytes, int size,
+                  int timeout)
+{
+  int fd, ret, one = 1;
+
+  /* Ensure the endpoint address is correct */
+  ep |= USB_ENDPOINT_IN;
+
+  fd = ensure_ep_open(dev, ep, O_RDONLY);
+  if (fd < 0) {
+    if (usb_debug >= 2) {
+#ifdef __FreeBSD_kernel__
+      fprintf (stderr, "usb_bulk_read: got negative open file descriptor for endpoint %d\n", UE_GET_ADDR(ep));
+#else
+      fprintf (stderr, "usb_bulk_read: got negative open file descriptor for endpoint %02d\n", UE_GET_ADDR(ep));
+#endif
+    }
+    return fd;
+  }
+
+  ret = ioctl(fd, USB_SET_TIMEOUT, &timeout);
+  if (ret < 0)
+    USB_ERROR_STR(-errno, "error setting timeout: %s", strerror(errno));
+
+  ret = ioctl(fd, USB_SET_SHORT_XFER, &one);
+  if (ret < 0)
+    USB_ERROR_STR(-errno, "error setting short xfer: %s", strerror(errno));
+
+  ret = read(fd, bytes, size);
+  if (ret < 0)
+#ifdef __FreeBSD_kernel__
+    USB_ERROR_STR(-errno, "error reading from bulk endpoint %s.%d: %s",
+                  dev->device->filename, UE_GET_ADDR(ep), strerror(errno));
+#else
+    USB_ERROR_STR(-errno, "error reading from bulk endpoint %s.%02d: %s",
+                dev->device->filename, UE_GET_ADDR(ep), strerror(errno));
+#endif
+
+  return ret;
+}
+
+int usb_interrupt_write(usb_dev_handle *dev, int ep, char *bytes, int size,
+                        int timeout)
+{
+  int fd, ret, sent = 0;
+
+  /* Ensure the endpoint address is correct */
+  ep &= ~USB_ENDPOINT_IN;
+
+  fd = ensure_ep_open(dev, ep, O_WRONLY);
+  if (fd < 0) {
+    if (usb_debug >= 2) {
+#ifdef __FreeBSD_kernel__
+      fprintf (stderr, "usb_interrupt_write: got negative open file descriptor for endpoint %d\n", UE_GET_ADDR(ep));
+#else
+      fprintf (stderr, "usb_interrupt_write: got negative open file descriptor for endpoint %02d\n", UE_GET_ADDR(ep));
+#endif
+    }
+    return fd;
+  }
+
+  ret = ioctl(fd, USB_SET_TIMEOUT, &timeout);
+  if (ret < 0)
+    USB_ERROR_STR(-errno, "error setting timeout: %s",
+                  strerror(errno));
+
+  do {
+    ret = write(fd, bytes+sent, size-sent);
+    if (ret < 0)
+#ifdef __FreeBSD_kernel__
+      USB_ERROR_STR(-errno, "error writing to interrupt endpoint %s.%d: %s",
+                    dev->device->filename, UE_GET_ADDR(ep), strerror(errno));
+#else
+      USB_ERROR_STR(-errno, "error writing to interrupt endpoint %s.%02d: %s",
+                  dev->device->filename, UE_GET_ADDR(ep), strerror(errno));
+#endif
+
+    sent += ret;
+  } while (ret > 0 && sent < size);
+
+  return sent;
+}
+
+int usb_interrupt_read(usb_dev_handle *dev, int ep, char *bytes, int size,
+                       int timeout)
+{
+  int fd, ret, retrieved = 0, one = 1;
+
+  /* Ensure the endpoint address is correct */
+  ep |= USB_ENDPOINT_IN;
+
+  fd = ensure_ep_open(dev, ep, O_RDONLY);
+  if (fd < 0) {
+    if (usb_debug >= 2) {
+#ifdef __FreeBSD_kernel__
+      fprintf (stderr, "usb_interrupt_read: got negative open file descriptor for endpoint %d\n", UE_GET_ADDR(ep));
+#else
+      fprintf (stderr, "usb_interrupt_read: got negative open file descriptor for endpoint %02d\n", UE_GET_ADDR(ep));
+#endif
+    }
+    return fd;
+  }
+
+  ret = ioctl(fd, USB_SET_TIMEOUT, &timeout);
+  if (ret < 0)
+    USB_ERROR_STR(-errno, "error setting timeout: %s", strerror(errno));
+
+  ret = ioctl(fd, USB_SET_SHORT_XFER, &one);
+  if (ret < 0)
+    USB_ERROR_STR(-errno, "error setting short xfer: %s", strerror(errno));
+
+  do {
+    ret = read(fd, bytes+retrieved, size-retrieved);
+    if (ret < 0)
+#ifdef __FreeBSD_kernel__
+      USB_ERROR_STR(-errno, "error reading from interrupt endpoint %s.%d: %s",
+                    dev->device->filename, UE_GET_ADDR(ep), strerror(errno));
+#else
+      USB_ERROR_STR(-errno, "error reading from interrupt endpoint %s.%02d: %s",
+                  dev->device->filename, UE_GET_ADDR(ep), strerror(errno));
+#endif
+    retrieved += ret;
+  } while (ret > 0 && retrieved < size);
+
+  return retrieved;
+}
+
+int usb_control_msg(usb_dev_handle *dev, int requesttype, int request,
+                     int value, int index, char *bytes, int size, int timeout)
+{
+  struct usb_ctl_request req;
+  int ret;
+
+  if (usb_debug >= 3)
+    fprintf(stderr, "usb_control_msg: %d %d %d %d %p %d %d\n",
+            requesttype, request, value, index, bytes, size, timeout);
+
+  req.ucr_request.bmRequestType = requesttype;
+  req.ucr_request.bRequest = request;
+  USETW(req.ucr_request.wValue, value);
+  USETW(req.ucr_request.wIndex, index);
+  USETW(req.ucr_request.wLength, size);
+
+  req.ucr_data = bytes;
+  req.ucr_flags = USBD_SHORT_XFER_OK;
+
+  ret = ioctl(dev->fd, USB_SET_TIMEOUT, &timeout);
+#if (__NetBSD__ || __OpenBSD__)
+  if (ret < 0 && errno != EINVAL)
+#else
+  if (ret < 0)
+#endif
+    USB_ERROR_STR(-errno, "error setting timeout: %s",
+                  strerror(errno));
+
+  ret = ioctl(dev->fd, USB_DO_REQUEST, &req);
+  if (ret < 0)
+    USB_ERROR_STR(-errno, "error sending control message: %s",
+                  strerror(errno));
+
+  return UGETW(req.ucr_request.wLength);
+}
+
+int usb_os_find_busses(struct usb_bus **busses)
+{
+  struct usb_bus *fbus = NULL;
+  int controller;
+  int fd;
+  char buf[20];
+
+  for (controller = 0; controller < MAX_CONTROLLERS; controller++) {
+    struct usb_bus *bus;
+
+    snprintf(buf, sizeof(buf) - 1, "/dev/usb%d", controller);
+    fd = open(buf, O_RDWR);
+    if (fd < 0) {
+      if (usb_debug >= 2)
+        if (errno != ENXIO && errno != ENOENT)
+          fprintf(stderr, "usb_os_find_busses: can't open %s: %s\n",
+                  buf, strerror(errno));
+      continue;
+    }
+    close(fd);
+
+    bus = malloc(sizeof(*bus));
+    if (!bus)
+      USB_ERROR(-ENOMEM);
+
+    memset((void *)bus, 0, sizeof(*bus));
+
+    strncpy(bus->dirname, buf, sizeof(bus->dirname) - 1);
+    bus->dirname[sizeof(bus->dirname) - 1] = 0;
+
+    LIST_ADD(fbus, bus);
+
+    if (usb_debug >= 2)
+      fprintf(stderr, "usb_os_find_busses: Found %s\n", bus->dirname);
+  }
+
+  *busses = fbus;
+
+  return 0;
+}
+
+int usb_os_find_devices(struct usb_bus *bus, struct usb_device **devices)
+{
+  struct usb_device *fdev = NULL;
+  int cfd, dfd;
+  int device;
+
+  cfd = open(bus->dirname, O_RDONLY);
+  if (cfd < 0)
+    USB_ERROR_STR(-errno, "couldn't open(%s): %s", bus->dirname,
+                  strerror(errno));
+
+  for (device = 1; device < USB_MAX_DEVICES; device++) {
+    struct usb_device_info di;
+    struct usb_device *dev;
+    unsigned char device_desc[DEVICE_DESC_LENGTH];
+    char buf[20];
+
+    di.udi_addr = device;
+    if (ioctl(cfd, USB_DEVICEINFO, &di) < 0)
+      continue;
+
+    /* There's a device; is it one we should mess with? */
+
+    if (strncmp(di.udi_devnames[0], "ugen", 4) != 0)
+      /* best not to play with things we don't understand */
+      continue;
+
+#ifdef __FreeBSD_kernel__
+    snprintf(buf, sizeof(buf) - 1, "/dev/%s", di.udi_devnames[0]);
+#else
+    snprintf(buf, sizeof(buf) - 1, "/dev/%s.00", di.udi_devnames[0]);
+#endif
+
+    /* Open its control endpoint */
+    dfd = open(buf, O_RDONLY);
+    if (dfd < 0) {
+      if (usb_debug >= 2)
+        fprintf(stderr, "usb_os_find_devices: couldn't open device %s: %s\n",
+                buf, strerror(errno));
+      continue;
+    }
+
+    dev = malloc(sizeof(*dev));
+    if (!dev)
+      USB_ERROR(-ENOMEM);
+
+    memset((void *)dev, 0, sizeof(*dev));
+
+    dev->bus = bus;
+
+    /* we need to report the device name as /dev/ugenx NOT /dev/ugenx.00
+     * This seemed easier than having 2 variables...
+     */
+#if (__NetBSD__ || __OpenBSD__)
+    snprintf(buf, sizeof(buf) - 1, "/dev/%s", di.udi_devnames[0]);
+#endif
+
+    strncpy(dev->filename, buf, sizeof(dev->filename) - 1);
+    dev->filename[sizeof(dev->filename) - 1] = 0;
+
+    if (ioctl(dfd, USB_GET_DEVICE_DESC, device_desc) < 0)
+      USB_ERROR_STR(-errno, "couldn't get device descriptor for %s: %s",
+                    buf, strerror(errno));
+
+    close(dfd);
+
+    usb_parse_descriptor(device_desc, "bbwbbbbwwwbbbb", &dev->descriptor);
+
+    LIST_ADD(fdev, dev);
+
+    if (usb_debug >= 2)
+      fprintf(stderr, "usb_os_find_devices: Found %s on %s\n",
+              dev->filename, bus->dirname);
+  }
+
+  close(cfd);
+
+  *devices = fdev;
+
+  return 0;
+}
+
+int usb_os_determine_children(struct usb_bus *bus)
+{
+  /* Nothing yet */
+  return 0;
+}
+
+void usb_os_init(void)
+{
+  /* nothing */
+}
+
+int usb_resetep(usb_dev_handle *dev, unsigned int ep)
+{
+  /* Not yet done, because I haven't needed it. */
+
+  USB_ERROR_STR(-ENOSYS, "usb_resetep called, unimplemented on BSD");
+}
+
+int usb_clear_halt(usb_dev_handle *dev, unsigned int ep)
+{
+  /* Not yet done, because I haven't needed it. */
+
+  USB_ERROR_STR(-ENOSYS, "usb_clear_halt called, unimplemented on BSD");
+}
+
+int usb_reset(usb_dev_handle *dev)
+{
+  /* Not yet done, because I haven't needed it. */
+
+  USB_ERROR_STR(-ENOSYS, "usb_reset called, unimplemented on BSD");
+}
+

libusb/config.h

@@ -0,0 +1,98 @@
+/* config.h.  Generated by configure.  */
+/* config.h.in.  Generated from configure.in by autoheader.  */
+
+#define LINUX_API 1
+#define BSD_API 0
+#define DARWIN_API 0
+
+/* #undef HAVE_OLD_DEV_USB_USB_H */
+
+#define HAVE_LIMITS_H 1
+#define HAVE_UNISTD_H 1
+#define HAVE_VALUES_H 1
+
+#define LIBUSB_MAJOR_VERSION 0
+#define LIBUSB_MINOR_VERSION 1
+#define LIBUSB_MICRO_VERSION 12
+#define LIBUSB_INTERFACE_AGE 4
+#define LIBUSB_BINARY_AGE 8
+
+
+/* Define to 1 if you have the <dlfcn.h> header file. */
+#define HAVE_DLFCN_H 1
+
+/* Define to 1 if you don't have `vprintf' but do have `_doprnt.' */
+/* #undef HAVE_DOPRNT */
+
+/* Define to 1 if you have the <inttypes.h> header file. */
+#define HAVE_INTTYPES_H 1
+
+/* Define to 1 if you have the <limits.h> header file. */
+#define HAVE_LIMITS_H 1
+
+/* Define to 1 if you have the `memmove' function. */
+#define HAVE_MEMMOVE 1
+
+/* Define to 1 if you have the <memory.h> header file. */
+#define HAVE_MEMORY_H 1
+
+/* Define to 1 if you have the <stdint.h> header file. */
+#define HAVE_STDINT_H 1
+
+/* Define to 1 if you have the <stdlib.h> header file. */
+#define HAVE_STDLIB_H 1
+
+/* Define to 1 if you have the <strings.h> header file. */
+#define HAVE_STRINGS_H 1
+
+/* Define to 1 if you have the <string.h> header file. */
+#define HAVE_STRING_H 1
+
+/* Define to 1 if you have the <sys/stat.h> header file. */
+#define HAVE_SYS_STAT_H 1
+
+/* Define to 1 if you have the <sys/types.h> header file. */
+#define HAVE_SYS_TYPES_H 1
+
+/* Define to 1 if you have the <unistd.h> header file. */
+#define HAVE_UNISTD_H 1
+
+/* Define to 1 if you have the <values.h> header file. */
+#define HAVE_VALUES_H 1
+
+/* Define to 1 if you have the `vprintf' function. */
+#define HAVE_VPRINTF 1
+
+/* Define to 1 if your C compiler doesn't accept -c and -o together. */
+/* #undef NO_MINUS_C_MINUS_O */
+
+/* Name of package */
+#define PACKAGE "libusb"
+
+/* Define to the address where bug reports for this package should be sent. */
+#define PACKAGE_BUGREPORT ""
+
+/* Define to the full name of this package. */
+#define PACKAGE_NAME "libusb"
+
+/* Define to the full name and version of this package. */
+#define PACKAGE_STRING "libusb 0.1.12"
+
+/* Define to the one symbol short name of this package. */
+#define PACKAGE_TARNAME "libusb"
+
+/* Define to the version of this package. */
+#define PACKAGE_VERSION "0.1.12"
+
+/* Define to 1 if you have the ANSI C header files. */
+#define STDC_HEADERS 1
+
+/* Version number of package */
+#define VERSION "0.1.12"
+
+/* Define to 1 if your processor stores words with the most significant byte
+   first (like Motorola and SPARC, unlike Intel and VAX). */
+/* #undef WORDS_BIGENDIAN */
+
+/* Define to empty if `const' does not conform to ANSI C. */
+/* #undef const */

libusb/descriptors.c

@@ -0,0 +1,520 @@
+/*
+ * Parses descriptors
+ *
+ * Copyright (c) 2001 Johannes Erdfelt <johannes@erdfelt.com>
+ *
+ * This library is covered by the LGPL, read LICENSE for details.
+ */
+
+#include <stdio.h>
+#include <string.h>
+#include <stdint.h>
+#include "usbi.h"
+
+int usb_get_descriptor_by_endpoint(usb_dev_handle *udev, int ep,
+	unsigned char type, unsigned char index, void *buf, int size)
+{
+  memset(buf, 0, size);
+
+  return usb_control_msg(udev, ep | USB_ENDPOINT_IN, USB_REQ_GET_DESCRIPTOR,
+                        (type << 8) + index, 0, buf, size, 1000);
+}
+
+int usb_get_descriptor(usb_dev_handle *udev, unsigned char type,
+	unsigned char index, void *buf, int size)
+{
+  memset(buf, 0, size);
+
+  return usb_control_msg(udev, USB_ENDPOINT_IN, USB_REQ_GET_DESCRIPTOR,
+                        (type << 8) + index, 0, buf, size, 1000);
+}
+
+int usb_parse_descriptor(unsigned char *source, char *description, void *dest)
+{
+  unsigned char *sp = source, *dp = dest;
+  uint16_t w;
+  uint32_t d;
+  char *cp;
+
+  for (cp = description; *cp; cp++) {
+    switch (*cp) {
+    case 'b':	/* 8-bit byte */
+      *dp++ = *sp++;
+      break;
+    case 'w':	/* 16-bit word, convert from little endian to CPU */
+      w = (sp[1] << 8) | sp[0]; sp += 2;
+      dp += ((unsigned long)dp & 1);	/* Align to word boundary */
+      *((uint16_t *)dp) = w; dp += 2;
+      break;
+    case 'd':	/* 32-bit dword, convert from little endian to CPU */
+      d = (sp[3] << 24) | (sp[2] << 16) | (sp[1] << 8) | sp[0]; sp += 4;
+      dp += ((unsigned long)dp & 2);	/* Align to dword boundary */
+      *((uint32_t *)dp) = d; dp += 4;
+      break;
+    /* These two characters are undocumented and just a hack for Linux */
+    case 'W':	/* 16-bit word, keep CPU endianess */
+      dp += ((unsigned long)dp & 1);	/* Align to word boundary */
+      memcpy(dp, sp, 2); sp += 2; dp += 2;
+      break;
+    case 'D':	/* 32-bit dword, keep CPU endianess */
+      dp += ((unsigned long)dp & 2);	/* Align to dword boundary */
+      memcpy(dp, sp, 4); sp += 4; dp += 4;
+      break;
+    }
+  }
+
+  return sp - source;
+}
+
+/*
+ * This code looks surprisingly similar to the code I wrote for the Linux
+ * kernel. It's not a coincidence :)
+ */
+
+static int usb_parse_endpoint(struct usb_endpoint_descriptor *endpoint, unsigned char *buffer, int size)
+{
+  struct usb_descriptor_header header;
+  unsigned char *begin;
+  int parsed = 0, len, numskipped;
+
+  usb_parse_descriptor(buffer, "bb", &header);
+
+  /* Everything should be fine being passed into here, but we sanity */
+  /*  check JIC */
+  if (header.bLength > size) {
+    if (usb_debug >= 1)
+      fprintf(stderr, "ran out of descriptors parsing\n");
+    return -1;
+  }
+                
+  if (header.bDescriptorType != USB_DT_ENDPOINT) {
+    if (usb_debug >= 2)
+      fprintf(stderr, "unexpected descriptor 0x%X, expecting endpoint descriptor, type 0x%X\n",
+         header.bDescriptorType, USB_DT_ENDPOINT);
+    return parsed;
+  }
+
+  if (header.bLength >= ENDPOINT_AUDIO_DESC_LENGTH)
+    usb_parse_descriptor(buffer, "bbbbwbbb", endpoint);
+  else if (header.bLength >= ENDPOINT_DESC_LENGTH)
+    usb_parse_descriptor(buffer, "bbbbwb", endpoint);
+
+  buffer += header.bLength;
+  size -= header.bLength;
+  parsed += header.bLength;
+
+  /* Skip over the rest of the Class Specific or Vendor Specific */
+  /*  descriptors */
+  begin = buffer;
+  numskipped = 0;
+  while (size >= DESC_HEADER_LENGTH) {
+    usb_parse_descriptor(buffer, "bb", &header);
+
+    if (header.bLength < 2) {
+      if (usb_debug >= 1)
+        fprintf(stderr, "invalid descriptor length of %d\n", header.bLength);
+      return -1;
+    }
+
+    /* If we find another "proper" descriptor then we're done  */
+    if ((header.bDescriptorType == USB_DT_ENDPOINT) ||
+        (header.bDescriptorType == USB_DT_INTERFACE) ||
+        (header.bDescriptorType == USB_DT_CONFIG) ||
+        (header.bDescriptorType == USB_DT_DEVICE))
+      break;
+
+    if (usb_debug >= 1)
+      fprintf(stderr, "skipping descriptor 0x%X\n", header.bDescriptorType);
+    numskipped++;
+
+    buffer += header.bLength;
+    size -= header.bLength;
+    parsed += header.bLength;
+  }
+
+  if (numskipped && usb_debug >= 2)
+    fprintf(stderr, "skipped %d class/vendor specific endpoint descriptors\n", numskipped);
+
+  /* Copy any unknown descriptors into a storage area for drivers */
+  /*  to later parse */
+  len = (int)(buffer - begin);
+  if (!len) {
+    endpoint->extra = NULL;
+    endpoint->extralen = 0;
+    return parsed;
+  }
+
+  endpoint->extra = malloc(len);
+  if (!endpoint->extra) {
+    if (usb_debug >= 1)
+      fprintf(stderr, "couldn't allocate memory for endpoint extra descriptors\n");
+    endpoint->extralen = 0;
+    return parsed;
+  }
+
+  memcpy(endpoint->extra, begin, len);
+  endpoint->extralen = len;
+
+  return parsed;
+}
+
+static int usb_parse_interface(struct usb_interface *interface,
+	unsigned char *buffer, int size)
+{
+  int i, len, numskipped, retval, parsed = 0;
+  struct usb_descriptor_header header;
+  struct usb_interface_descriptor *ifp;
+  unsigned char *begin;
+
+  interface->num_altsetting = 0;
+
+  while (size >= INTERFACE_DESC_LENGTH) {
+    interface->altsetting = realloc(interface->altsetting, sizeof(struct usb_interface_descriptor) * (interface->num_altsetting + 1));
+    if (!interface->altsetting) {
+      if (usb_debug >= 1)
+        fprintf(stderr, "couldn't malloc interface->altsetting\n");
+      return -1;
+    }
+
+    ifp = interface->altsetting + interface->num_altsetting;
+    interface->num_altsetting++;
+
+    usb_parse_descriptor(buffer, "bbbbbbbbb", ifp);
+
+    /* Skip over the interface */
+    buffer += ifp->bLength;
+    parsed += ifp->bLength;
+    size -= ifp->bLength;
+
+    begin = buffer;
+    numskipped = 0;
+
+    /* Skip over any interface, class or vendor descriptors */
+    while (size >= DESC_HEADER_LENGTH) {
+      usb_parse_descriptor(buffer, "bb", &header);
+
+      if (header.bLength < 2) {
+        if (usb_debug >= 1)
+          fprintf(stderr, "invalid descriptor length of %d\n", header.bLength);
+        return -1;
+      }
+
+      /* If we find another "proper" descriptor then we're done */
+      if ((header.bDescriptorType == USB_DT_INTERFACE) ||
+          (header.bDescriptorType == USB_DT_ENDPOINT) ||
+          (header.bDescriptorType == USB_DT_CONFIG) ||
+          (header.bDescriptorType == USB_DT_DEVICE))
+        break;
+
+      numskipped++;
+
+      buffer += header.bLength;
+      parsed += header.bLength;
+      size -= header.bLength;
+    }
+
+    if (numskipped && usb_debug >= 2)
+      fprintf(stderr, "skipped %d class/vendor specific interface descriptors\n", numskipped);
+
+    /* Copy any unknown descriptors into a storage area for */
+    /*  drivers to later parse */
+    len = (int)(buffer - begin);
+    if (!len) {
+      ifp->extra = NULL;
+      ifp->extralen = 0;
+    } else {
+      ifp->extra = malloc(len);
+      if (!ifp->extra) {
+        if (usb_debug >= 1)
+          fprintf(stderr, "couldn't allocate memory for interface extra descriptors\n");
+        ifp->extralen = 0;
+        return -1;
+      }
+      memcpy(ifp->extra, begin, len);
+      ifp->extralen = len;
+    }
+
+    /* Did we hit an unexpected descriptor? */
+    usb_parse_descriptor(buffer, "bb", &header);
+    if ((size >= DESC_HEADER_LENGTH) &&
+        ((header.bDescriptorType == USB_DT_CONFIG) ||
+        (header.bDescriptorType == USB_DT_DEVICE)))
+      return parsed;
+
+    if (ifp->bNumEndpoints > USB_MAXENDPOINTS) {
+      if (usb_debug >= 1)
+        fprintf(stderr, "too many endpoints\n");
+      return -1;
+    }
+
+    if (ifp->bNumEndpoints > 0) {
+      ifp->endpoint = (struct usb_endpoint_descriptor *)
+                       malloc(ifp->bNumEndpoints *
+                       sizeof(struct usb_endpoint_descriptor));
+      if (!ifp->endpoint) {
+        if (usb_debug >= 1)
+          fprintf(stderr, "couldn't allocate memory for ifp->endpoint\n");
+        return -1;      
+      }
+
+      memset(ifp->endpoint, 0, ifp->bNumEndpoints *
+             sizeof(struct usb_endpoint_descriptor));
+
+      for (i = 0; i < ifp->bNumEndpoints; i++) {
+        usb_parse_descriptor(buffer, "bb", &header);
+  
+        if (header.bLength > size) {
+          if (usb_debug >= 1)
+            fprintf(stderr, "ran out of descriptors parsing\n");
+          return -1;
+        }
+                
+        retval = usb_parse_endpoint(ifp->endpoint + i, buffer, size);
+        if (retval < 0)
+          return retval;
+
+        buffer += retval;
+        parsed += retval;
+        size -= retval;
+      }
+    } else
+      ifp->endpoint = NULL;
+
+    /* We check to see if it's an alternate to this one */
+    ifp = (struct usb_interface_descriptor *)buffer;
+    if (size < USB_DT_INTERFACE_SIZE ||
+        ifp->bDescriptorType != USB_DT_INTERFACE ||
+        !ifp->bAlternateSetting)
+      return parsed;
+  }
+
+  return parsed;
+}
+
+int usb_parse_configuration(struct usb_config_descriptor *config,
+	unsigned char *buffer)
+{
+  int i, retval, size;
+  struct usb_descriptor_header header;
+
+  usb_parse_descriptor(buffer, "bbwbbbbb", config);
+  size = config->wTotalLength;
+
+  if (config->bNumInterfaces > USB_MAXINTERFACES) {
+    if (usb_debug >= 1)
+      fprintf(stderr, "too many interfaces\n");
+    return -1;
+  }
+
+  config->interface = (struct usb_interface *)
+                       malloc(config->bNumInterfaces *
+                       sizeof(struct usb_interface));
+  if (!config->interface) {
+    if (usb_debug >= 1)
+      fprintf(stderr, "out of memory\n");
+    return -1;      
+  }
+
+  memset(config->interface, 0, config->bNumInterfaces * sizeof(struct usb_interface));
+
+  buffer += config->bLength;
+  size -= config->bLength;
+        
+  config->extra = NULL;
+  config->extralen = 0;
+
+  for (i = 0; i < config->bNumInterfaces; i++) {
+    int numskipped, len;
+    unsigned char *begin;
+
+    /* Skip over the rest of the Class Specific or Vendor */
+    /*  Specific descriptors */
+    begin = buffer;
+    numskipped = 0;
+    while (size >= DESC_HEADER_LENGTH) {
+      usb_parse_descriptor(buffer, "bb", &header);
+
+      if ((header.bLength > size) || (header.bLength < DESC_HEADER_LENGTH)) {
+        if (usb_debug >= 1)
+          fprintf(stderr, "invalid descriptor length of %d\n", header.bLength);
+        return -1;
+      }
+
+      /* If we find another "proper" descriptor then we're done */
+      if ((header.bDescriptorType == USB_DT_ENDPOINT) ||
+          (header.bDescriptorType == USB_DT_INTERFACE) ||
+          (header.bDescriptorType == USB_DT_CONFIG) ||
+          (header.bDescriptorType == USB_DT_DEVICE))
+        break;
+
+      if (usb_debug >= 2)
+        fprintf(stderr, "skipping descriptor 0x%X\n", header.bDescriptorType);
+      numskipped++;
+
+      buffer += header.bLength;
+      size -= header.bLength;
+    }
+
+    if (numskipped && usb_debug >= 2)
+      fprintf(stderr, "skipped %d class/vendor specific endpoint descriptors\n", numskipped);
+
+    /* Copy any unknown descriptors into a storage area for */
+    /*  drivers to later parse */
+    len = (int)(buffer - begin);
+    if (len) {
+      /* FIXME: We should realloc and append here */
+      if (!config->extralen) {
+        config->extra = malloc(len);
+        if (!config->extra) {
+          if (usb_debug >= 1)
+            fprintf(stderr, "couldn't allocate memory for config extra descriptors\n");
+          config->extralen = 0;
+          return -1;
+        }
+
+        memcpy(config->extra, begin, len);
+        config->extralen = len;
+      }
+    }
+
+    retval = usb_parse_interface(config->interface + i, buffer, size);
+    if (retval < 0)
+      return retval;
+
+    buffer += retval;
+    size -= retval;
+  }
+
+  return size;
+}
+
+void usb_destroy_configuration(struct usb_device *dev)
+{
+  int c, i, j, k;
+        
+  if (!dev->config)
+    return;
+
+  for (c = 0; c < dev->descriptor.bNumConfigurations; c++) {
+    struct usb_config_descriptor *cf = &dev->config[c];
+
+    if (!cf->interface)
+      continue;
+
+    for (i = 0; i < cf->bNumInterfaces; i++) {
+      struct usb_interface *ifp = &cf->interface[i];
+                                
+      if (!ifp->altsetting)
+        continue;
+
+      for (j = 0; j < ifp->num_altsetting; j++) {
+        struct usb_interface_descriptor *as = &ifp->altsetting[j];
+                                        
+        if (as->extra)
+          free(as->extra);
+
+        if (!as->endpoint)
+          continue;
+                                        
+        for (k = 0; k < as->bNumEndpoints; k++) {
+          if (as->endpoint[k].extra)
+            free(as->endpoint[k].extra);
+        }       
+        free(as->endpoint);
+      }
+
+      free(ifp->altsetting);
+    }
+
+    free(cf->interface);
+  }
+
+  free(dev->config);
+}
+
+void usb_fetch_and_parse_descriptors(usb_dev_handle *udev)
+{
+  struct usb_device *dev = udev->device;
+  int i;
+
+  if (dev->descriptor.bNumConfigurations > USB_MAXCONFIG) {
+    if (usb_debug >= 1)
+      fprintf(stderr, "Too many configurations (%d > %d)\n", dev->descriptor.bNumConfigurations, USB_MAXCONFIG);
+    return;
+  }
+
+  if (dev->descriptor.bNumConfigurations < 1) {
+    if (usb_debug >= 1)
+      fprintf(stderr, "Not enough configurations (%d < %d)\n", dev->descriptor.bNumConfigurations, 1);
+    return;
+  }
+
+  dev->config = (struct usb_config_descriptor *)malloc(dev->descriptor.bNumConfigurations * sizeof(struct usb_config_descriptor));
+  if (!dev->config) {
+    if (usb_debug >= 1)
+      fprintf(stderr, "Unable to allocate memory for config descriptor\n");
+    return;
+  }
+
+  memset(dev->config, 0, dev->descriptor.bNumConfigurations *
+	sizeof(struct usb_config_descriptor));
+
+  for (i = 0; i < dev->descriptor.bNumConfigurations; i++) {
+    unsigned char buffer[8], *bigbuffer;
+    struct usb_config_descriptor config;
+    int res;
+
+    /* Get the first 8 bytes so we can figure out what the total length is */
+    res = usb_get_descriptor(udev, USB_DT_CONFIG, i, buffer, 8);
+    if (res < 8) {
+      if (usb_debug >= 1) {
+        if (res < 0)
+          fprintf(stderr, "Unable to get descriptor (%d)\n", res);
+        else
+          fprintf(stderr, "Config descriptor too short (expected %d, got %d)\n", 8, res);
+      }
+
+      goto err;
+    }
+
+    usb_parse_descriptor(buffer, "bbw", &config);
+
+    bigbuffer = malloc(config.wTotalLength);
+    if (!bigbuffer) {
+      if (usb_debug >= 1)
+        fprintf(stderr, "Unable to allocate memory for descriptors\n");
+      goto err;
+    }
+
+    res = usb_get_descriptor(udev, USB_DT_CONFIG, i, bigbuffer, config.wTotalLength);
+    if (res < config.wTotalLength) {
+      if (usb_debug >= 1) {
+        if (res < 0)
+          fprintf(stderr, "Unable to get descriptor (%d)\n", res);
+        else
+          fprintf(stderr, "Config descriptor too short (expected %d, got %d)\n", config.wTotalLength, res);
+      }
+
+      free(bigbuffer);
+      goto err;
+    }
+
+    res = usb_parse_configuration(&dev->config[i], bigbuffer);
+    if (usb_debug >= 2) {
+      if (res > 0)
+        fprintf(stderr, "Descriptor data still left\n");
+      else if (res < 0)
+        fprintf(stderr, "Unable to parse descriptors\n");
+    }
+
+    free(bigbuffer);
+  }
+
+  return;
+
+err:
+  free(dev->config);
+
+  dev->config = NULL;
+}
+

libusb/error.c

@@ -0,0 +1,36 @@
+/*
+ * USB Error messages
+ *
+ * Copyright (c) 2000-2001 Johannes Erdfelt <johannes@erdfelt.com>
+ *
+ * This library is covered by the LGPL, read LICENSE for details.
+ */
+
+#include <errno.h>
+#include <string.h>
+
+#include "usb.h"
+#include "error.h"
+
+char usb_error_str[1024] = "";
+int usb_error_errno = 0;
+usb_error_type_t usb_error_type = USB_ERROR_TYPE_NONE;
+
+char *usb_strerror(void)
+{
+  switch (usb_error_type) {
+  case USB_ERROR_TYPE_NONE:
+    return "No error";
+  case USB_ERROR_TYPE_STRING:
+    return usb_error_str;
+  case USB_ERROR_TYPE_ERRNO:
+    if (usb_error_errno > -USB_ERROR_BEGIN)
+      return strerror(usb_error_errno);
+    else
+      /* Any error we don't know falls under here */
+      return "Unknown error";
+  }
+
+  return "Unknown error";
+}
+

libusb/error.h

@@ -0,0 +1,31 @@
+#ifndef _ERROR_H_
+#define _ERROR_H_
+
+typedef enum {
+  USB_ERROR_TYPE_NONE = 0,
+  USB_ERROR_TYPE_STRING,
+  USB_ERROR_TYPE_ERRNO,
+} usb_error_type_t;
+
+extern char usb_error_str[1024];
+extern int usb_error_errno;
+extern usb_error_type_t usb_error_type;
+
+#define USB_ERROR(x) \
+	do { \
+          usb_error_type = USB_ERROR_TYPE_ERRNO; \
+          usb_error_errno = x; \
+	  return x; \
+	} while (0)
+
+#define USB_ERROR_STR(x, format, args...) \
+	do { \
+	  usb_error_type = USB_ERROR_TYPE_STRING; \
+	  snprintf(usb_error_str, sizeof(usb_error_str) - 1, format, ## args); \
+          if (usb_debug >= 2) \
+            fprintf(stderr, "USB error: %s\n", usb_error_str); \
+	  return x; \
+	} while (0)
+
+#endif /* _ERROR_H_ */
+

libusb/linux.c

@@ -0,0 +1,733 @@
+/*
+ * Linux USB support
+ *
+ * Copyright (c) 2000-2003 Johannes Erdfelt <johannes@erdfelt.com>
+ *
+ * This library is covered by the LGPL, read LICENSE for details.
+ */
+
+#include <stdlib.h>	/* getenv, etc */
+#include <unistd.h>
+#include <string.h>
+#include <stdio.h>
+#include <fcntl.h>
+#include <errno.h>
+#include <sys/time.h>
+#include <dirent.h>
+
+#include "linux.h"
+#include "usbi.h"
+
+static char usb_path[PATH_MAX + 1] = "";
+
+static int device_open(struct usb_device *dev)
+{
+  char filename[PATH_MAX + 1];
+  int fd;
+
+  snprintf(filename, sizeof(filename) - 1, "%s/%s/%s",
+    usb_path, dev->bus->dirname, dev->filename);
+
+  fd = open(filename, O_RDWR);
+  if (fd < 0) {
+    fd = open(filename, O_RDONLY);
+    if (fd < 0)
+      USB_ERROR_STR(-errno, "failed to open %s: %s",
+	filename, strerror(errno));
+  }
+
+  return fd;
+}
+
+int usb_os_open(usb_dev_handle *dev)
+{
+  dev->fd = device_open(dev->device);
+
+  return 0;
+}
+
+int usb_os_close(usb_dev_handle *dev)
+{
+  if (dev->fd < 0)
+    return 0;
+
+  if (close(dev->fd) == -1)
+    /* Failing trying to close a file really isn't an error, so return 0 */
+    USB_ERROR_STR(0, "tried to close device fd %d: %s", dev->fd,
+	strerror(errno));
+
+  return 0;
+}
+
+int usb_set_configuration(usb_dev_handle *dev, int configuration)
+{
+  int ret;
+
+  ret = ioctl(dev->fd, IOCTL_USB_SETCONFIG, &configuration);
+  if (ret < 0)
+    USB_ERROR_STR(-errno, "could not set config %d: %s", configuration,
+	strerror(errno));
+
+  dev->config = configuration;
+
+  return 0;
+}
+
+int usb_claim_interface(usb_dev_handle *dev, int interface)
+{
+  int ret;
+
+  ret = ioctl(dev->fd, IOCTL_USB_CLAIMINTF, &interface);
+  if (ret < 0) {
+    if (errno == EBUSY && usb_debug > 0)
+      fprintf(stderr, "Check that you have permissions to write to %s/%s and, if you don't, that you set up hotplug (http://linux-hotplug.sourceforge.net/) correctly.\n", dev->bus->dirname, dev->device->filename);
+
+    USB_ERROR_STR(-errno, "could not claim interface %d: %s", interface,
+	strerror(errno));
+  }
+
+  dev->interface = interface;
+
+  return 0;
+}
+
+int usb_release_interface(usb_dev_handle *dev, int interface)
+{
+  int ret;
+
+  ret = ioctl(dev->fd, IOCTL_USB_RELEASEINTF, &interface);
+  if (ret < 0)
+    USB_ERROR_STR(-errno, "could not release intf %d: %s", interface,
+    	strerror(errno));
+
+  dev->interface = -1;
+
+  return 0;
+}
+
+int usb_set_altinterface(usb_dev_handle *dev, int alternate)
+{
+  int ret;
+  struct usb_setinterface setintf;
+
+  if (dev->interface < 0)
+    USB_ERROR(-EINVAL);
+
+  setintf.interface = dev->interface;
+  setintf.altsetting = alternate;
+
+  ret = ioctl(dev->fd, IOCTL_USB_SETINTF, &setintf);
+  if (ret < 0)
+    USB_ERROR_STR(-errno, "could not set alt intf %d/%d: %s",
+	dev->interface, alternate, strerror(errno));
+
+  dev->altsetting = alternate;
+
+  return 0;
+}
+
+/*
+ * Linux usbfs has a limit of one page size for synchronous bulk read/write.
+ * 4096 is the most portable maximum we can do for now.
+ * Linux usbfs has a limit of 16KB for the URB interface. We use this now
+ * to get better performance for USB 2.0 devices.
+ */
+#define MAX_READ_WRITE	(16 * 1024)
+
+int usb_control_msg(usb_dev_handle *dev, int requesttype, int request,
+	int value, int index, char *bytes, int size, int timeout)
+{
+  struct usb_ctrltransfer ctrl;
+  int ret;
+
+  ctrl.bRequestType = requesttype;
+  ctrl.bRequest = request;
+  ctrl.wValue = value;
+  ctrl.wIndex = index;
+  ctrl.wLength = size;
+
+  ctrl.data = bytes;
+  ctrl.timeout = timeout;
+
+  ret = ioctl(dev->fd, IOCTL_USB_CONTROL, &ctrl);
+  if (ret < 0)
+    USB_ERROR_STR(-errno, "error sending control message: %s", strerror(errno));
+
+  return ret;
+}
+
+#define URB_USERCONTEXT_COOKIE		((void *)0x1)
+
+/* Reading and writing are the same except for the endpoint */
+static int usb_urb_transfer(usb_dev_handle *dev, int ep, int urbtype,
+	char *bytes, int size, int timeout)
+{
+  struct usb_urb urb;
+  int bytesdone = 0, requested;
+  struct timeval tv, tv_ref, tv_now;
+  struct usb_urb *context;
+  int ret, waiting;
+
+  /*
+   * HACK: The use of urb.usercontext is a hack to get threaded applications
+   * sort of working again. Threaded support is still not recommended, but
+   * this should allow applications to work in the common cases. Basically,
+   * if we get the completion for an URB we're not waiting for, then we update
+   * the usercontext pointer to 1 for the other threads URB and it will see
+   * the change after it wakes up from the the timeout. Ugly, but it works.
+   */
+
+  /*
+   * Get actual time, and add the timeout value. The result is the absolute
+   * time where we have to quit waiting for an message.
+   */
+  gettimeofday(&tv_ref, NULL);
+  tv_ref.tv_sec = tv_ref.tv_sec + timeout / 1000;
+  tv_ref.tv_usec = tv_ref.tv_usec + (timeout % 1000) * 1000;
+
+  if (tv_ref.tv_usec > 1000000) {
+    tv_ref.tv_usec -= 1000000;
+    tv_ref.tv_sec++;
+  }
+
+  do {
+    fd_set writefds;
+
+    requested = size - bytesdone;
+    if (requested > MAX_READ_WRITE)
+      requested = MAX_READ_WRITE;
+
+    urb.type = urbtype;
+    urb.endpoint = ep;
+    urb.flags = 0;
+    urb.buffer = bytes + bytesdone;
+    urb.buffer_length = requested;
+    urb.signr = 0;
+    urb.actual_length = 0;
+    urb.number_of_packets = 0;	/* don't do isochronous yet */
+    urb.usercontext = NULL;
+
+    ret = ioctl(dev->fd, IOCTL_USB_SUBMITURB, &urb);
+    if (ret < 0) {
+      USB_ERROR_STR(-errno, "error submitting URB: %s", strerror(errno));
+      return ret;
+    }
+
+    FD_ZERO(&writefds);
+    FD_SET(dev->fd, &writefds);
+
+restart:
+    waiting = 1;
+    context = NULL;
+    while (!urb.usercontext && ((ret = ioctl(dev->fd, IOCTL_USB_REAPURBNDELAY, &context)) == -1) && waiting) {
+      tv.tv_sec = 0;
+      tv.tv_usec = 1000; // 1 msec
+      select(dev->fd + 1, NULL, &writefds, NULL, &tv); //sub second wait
+
+      if (timeout) {
+        /* compare with actual time, as the select timeout is not that precise */
+        gettimeofday(&tv_now, NULL);
+
+        if ((tv_now.tv_sec > tv_ref.tv_sec) ||
+            ((tv_now.tv_sec == tv_ref.tv_sec) && (tv_now.tv_usec >= tv_ref.tv_usec)))
+          waiting = 0;
+      }
+    }
+
+    if (context && context != &urb) {
+      context->usercontext = URB_USERCONTEXT_COOKIE;
+      /* We need to restart since we got a successful URB, but not ours */
+      goto restart;
+    }
+
+    /*
+     * If there was an error, that wasn't EAGAIN (no completion), then
+     * something happened during the reaping and we should return that
+     * error now
+     */
+    if (ret < 0 && !urb.usercontext && errno != EAGAIN)
+      USB_ERROR_STR(-errno, "error reaping URB: %s", strerror(errno));
+
+    bytesdone += urb.actual_length;
+  } while ((ret == 0 || urb.usercontext) && bytesdone < size && urb.actual_length == requested);
+
+  /* If the URB didn't complete in success or error, then let's unlink it */
+  if (ret < 0 && !urb.usercontext) {
+    int rc;
+
+    if (!waiting)
+      rc = -ETIMEDOUT;
+    else
+      rc = urb.status;
+
+    ret = ioctl(dev->fd, IOCTL_USB_DISCARDURB, &urb);
+    if (ret < 0 && errno != EINVAL && usb_debug >= 1)
+      fprintf(stderr, "error discarding URB: %s", strerror(errno));
+
+    /*
+     * When the URB is unlinked, it gets moved to the completed list and
+     * then we need to reap it or else the next time we call this function,
+     * we'll get the previous completion and exit early
+     */
+    ioctl(dev->fd, IOCTL_USB_REAPURB, &context);
+
+    return rc;
+  }
+
+  return bytesdone;
+}
+
+int usb_bulk_write(usb_dev_handle *dev, int ep, char *bytes, int size,
+	int timeout)
+{
+  /* Ensure the endpoint address is correct */
+  return usb_urb_transfer(dev, ep, USB_URB_TYPE_BULK, bytes, size,
+		timeout);
+}
+
+int usb_bulk_read(usb_dev_handle *dev, int ep, char *bytes, int size,
+	int timeout)
+{
+  /* Ensure the endpoint address is correct */
+  ep |= USB_ENDPOINT_IN;
+  return usb_urb_transfer(dev, ep, USB_URB_TYPE_BULK, bytes, size,
+		timeout);
+}
+
+/*
+ * FIXME: Packetize large buffers here. 2.4 HCDs (atleast, haven't checked
+ * 2.5 HCDs yet) don't handle multi-packet Interrupt transfers. So we need
+ * to lookup the endpoint packet size and packetize appropriately here.
+ */
+int usb_interrupt_write(usb_dev_handle *dev, int ep, char *bytes, int size,
+	int timeout)
+{
+  /* Ensure the endpoint address is correct */
+  return usb_urb_transfer(dev, ep, USB_URB_TYPE_INTERRUPT, bytes, size,
+		timeout);
+}
+
+int usb_interrupt_read(usb_dev_handle *dev, int ep, char *bytes, int size,
+	int timeout)
+{
+  /* Ensure the endpoint address is correct */
+  ep |= USB_ENDPOINT_IN;
+  return usb_urb_transfer(dev, ep, USB_URB_TYPE_INTERRUPT, bytes, size,
+		timeout);
+}
+
+int usb_os_find_busses(struct usb_bus **busses)
+{
+  struct usb_bus *fbus = NULL;
+  DIR *dir;
+  struct dirent *entry;
+
+  dir = opendir(usb_path);
+  if (!dir)
+    USB_ERROR_STR(-errno, "couldn't opendir(%s): %s", usb_path,
+	strerror(errno));
+
+  while ((entry = readdir(dir)) != NULL) {
+    struct usb_bus *bus;
+
+    /* Skip anything starting with a . */
+    if (entry->d_name[0] == '.')
+      continue;
+
+    if (!strchr("0123456789", entry->d_name[strlen(entry->d_name) - 1])) {
+      if (usb_debug >= 2)
+        fprintf(stderr, "usb_os_find_busses: Skipping non bus directory %s\n",
+		entry->d_name);
+      continue;
+    }
+
+    bus = malloc(sizeof(*bus));
+    if (!bus)
+      USB_ERROR(-ENOMEM);
+
+    memset((void *)bus, 0, sizeof(*bus));
+
+    strncpy(bus->dirname, entry->d_name, sizeof(bus->dirname) - 1);
+    bus->dirname[sizeof(bus->dirname) - 1] = 0;
+
+    LIST_ADD(fbus, bus);
+
+    if (usb_debug >= 2)
+       fprintf(stderr, "usb_os_find_busses: Found %s\n", bus->dirname);
+  }
+
+  closedir(dir);
+
+  *busses = fbus;
+
+  return 0;
+}
+
+int usb_os_find_devices(struct usb_bus *bus, struct usb_device **devices)
+{
+  struct usb_device *fdev = NULL;
+  DIR *dir;
+  struct dirent *entry;
+  char dirpath[PATH_MAX + 1];
+
+  snprintf(dirpath, PATH_MAX, "%s/%s", usb_path, bus->dirname);
+
+  dir = opendir(dirpath);
+  if (!dir)
+    USB_ERROR_STR(-errno, "couldn't opendir(%s): %s", dirpath,
+	strerror(errno));
+
+  while ((entry = readdir(dir)) != NULL) {
+    unsigned char device_desc[DEVICE_DESC_LENGTH];
+    char filename[PATH_MAX + 1];
+    struct usb_device *dev;
+    struct usb_connectinfo connectinfo;
+    int i, fd, ret;
+
+    /* Skip anything starting with a . */
+    if (entry->d_name[0] == '.')
+      continue;
+
+    dev = malloc(sizeof(*dev));
+    if (!dev)
+      USB_ERROR(-ENOMEM);
+
+    memset((void *)dev, 0, sizeof(*dev));
+
+    dev->bus = bus;
+
+    strncpy(dev->filename, entry->d_name, sizeof(dev->filename) - 1);
+    dev->filename[sizeof(dev->filename) - 1] = 0;
+
+    snprintf(filename, sizeof(filename) - 1, "%s/%s", dirpath, entry->d_name);
+    fd = open(filename, O_RDWR);
+    if (fd < 0) {
+      fd = open(filename, O_RDONLY);
+      if (fd < 0) {
+        if (usb_debug >= 2)
+          fprintf(stderr, "usb_os_find_devices: Couldn't open %s\n",
+                  filename);
+
+        free(dev);
+        continue;
+      }
+    }
+
+    /* Get the device number */
+    ret = ioctl(fd, IOCTL_USB_CONNECTINFO, &connectinfo);
+    if (ret < 0) {
+      if (usb_debug)
+        fprintf(stderr, "usb_os_find_devices: couldn't get connect info\n");
+    } else
+      dev->devnum = connectinfo.devnum;
+
+    ret = read(fd, (void *)device_desc, DEVICE_DESC_LENGTH);
+    if (ret < 0) {
+      if (usb_debug)
+        fprintf(stderr, "usb_os_find_devices: Couldn't read descriptor\n");
+
+      free(dev);
+
+      goto err;
+    }
+
+    /*
+     * Linux kernel converts the words in this descriptor to CPU endian, so
+     * we use the undocumented W character for usb_parse_descriptor() that
+     * doesn't convert endianess when parsing the descriptor
+     */
+    usb_parse_descriptor(device_desc, "bbWbbbbWWWbbbb", &dev->descriptor);
+
+    LIST_ADD(fdev, dev);
+
+    if (usb_debug >= 2)
+      fprintf(stderr, "usb_os_find_devices: Found %s on %s\n",
+		dev->filename, bus->dirname);
+
+    /* Now try to fetch the rest of the descriptors */
+    if (dev->descriptor.bNumConfigurations > USB_MAXCONFIG)
+      /* Silent since we'll try again later */
+      goto err;
+
+    if (dev->descriptor.bNumConfigurations < 1)
+      /* Silent since we'll try again later */
+      goto err;
+
+    dev->config = (struct usb_config_descriptor *)malloc(dev->descriptor.bNumConfigurations * sizeof(struct usb_config_descriptor));
+    if (!dev->config)
+      /* Silent since we'll try again later */
+      goto err;
+
+    memset(dev->config, 0, dev->descriptor.bNumConfigurations *
+          sizeof(struct usb_config_descriptor));
+
+    for (i = 0; i < dev->descriptor.bNumConfigurations; i++) {
+      unsigned char buffer[8], *bigbuffer;
+      struct usb_config_descriptor config;
+
+      /* Get the first 8 bytes so we can figure out what the total length is */
+      ret = read(fd, (void *)buffer, 8);
+      if (ret < 8) {
+        if (usb_debug >= 1) {
+          if (ret < 0)
+            fprintf(stderr, "Unable to get descriptor (%d)\n", ret);
+          else
+            fprintf(stderr, "Config descriptor too short (expected %d, got %d)\n", 8, ret);
+        }
+
+        goto err;
+      }
+
+      usb_parse_descriptor(buffer, "bbw", &config);
+
+      bigbuffer = malloc(config.wTotalLength);
+      if (!bigbuffer) {
+        if (usb_debug >= 1)
+          fprintf(stderr, "Unable to allocate memory for descriptors\n");
+        goto err;
+      }
+
+      /* Read the rest of the config descriptor */
+      memcpy(bigbuffer, buffer, 8);
+
+      ret = read(fd, (void *)(bigbuffer + 8), config.wTotalLength - 8);
+      if (ret < config.wTotalLength - 8) {
+        if (usb_debug >= 1) {
+          if (ret < 0)
+            fprintf(stderr, "Unable to get descriptor (%d)\n", ret);
+          else
+            fprintf(stderr, "Config descriptor too short (expected %d, got %d)\n", config.wTotalLength, ret);
+        }
+
+        free(bigbuffer);
+        goto err;
+      }
+
+      ret = usb_parse_configuration(&dev->config[i], bigbuffer);
+      if (usb_debug >= 2) {
+        if (ret > 0)
+          fprintf(stderr, "Descriptor data still left\n");
+        else if (ret < 0)
+          fprintf(stderr, "Unable to parse descriptors\n");
+      }
+
+      free(bigbuffer);
+    }
+
+err:
+    close(fd);
+  }
+
+  closedir(dir);
+
+  *devices = fdev;
+
+  return 0;
+}
+
+int usb_os_determine_children(struct usb_bus *bus)
+{
+  struct usb_device *dev, *devices[256];
+  struct usb_ioctl command;
+  int ret, i, i1;
+
+  /* Create a list of devices first */
+  memset(devices, 0, sizeof(devices));
+  for (dev = bus->devices; dev; dev = dev->next)
+    if (dev->devnum)
+      devices[dev->devnum] = dev;
+
+  /* Now fetch the children for each device */
+  for (dev = bus->devices; dev; dev = dev->next) {
+    struct usb_hub_portinfo portinfo;
+    int fd;
+
+    fd = device_open(dev);
+    if (fd < 0)
+      continue;
+
+    /* Query the hub driver for the children of this device */
+    if (dev->config && dev->config->interface && dev->config->interface->altsetting)
+      command.ifno = dev->config->interface->altsetting->bInterfaceNumber;
+    else
+      command.ifno = 0;
+    command.ioctl_code = IOCTL_USB_HUB_PORTINFO;
+    command.data = &portinfo;
+    ret = ioctl(fd, IOCTL_USB_IOCTL, &command);
+    if (ret < 0) {
+      /* errno == ENOSYS means the device probably wasn't a hub */
+      if (errno != ENOSYS && usb_debug > 1)
+        fprintf(stderr, "error obtaining child information: %s\n",
+		strerror(errno));
+
+      close(fd);
+      continue;
+    }
+
+    dev->num_children = 0;
+    for (i = 0; i < portinfo.numports; i++)
+      if (portinfo.port[i])
+        dev->num_children++;
+
+    /* Free any old children first */
+    free(dev->children);
+
+    dev->children = malloc(sizeof(struct usb_device *) * dev->num_children);
+    if (!dev->children) {
+      if (usb_debug > 1)
+        fprintf(stderr, "error allocating %zu bytes memory for dev->children\n",
+                sizeof(struct usb_device *) * dev->num_children);
+
+      dev->num_children = 0;
+      close(fd);
+      continue;
+    }
+
+    for (i = 0, i1 = 0; i < portinfo.numports; i++) {
+      if (!portinfo.port[i])
+        continue;
+
+      dev->children[i1++] = devices[portinfo.port[i]];
+
+      devices[portinfo.port[i]] = NULL;
+    }
+
+    close(fd);
+  }
+
+  /*
+   * There should be one device left in the devices list and that should be
+   * the root device
+   */
+  for (i = 0; i < sizeof(devices) / sizeof(devices[0]); i++) {
+    if (devices[i])
+      bus->root_dev = devices[i];
+  }
+
+  return 0;
+}
+
+static int check_usb_vfs(const char *dirname)
+{
+  DIR *dir;
+  struct dirent *entry;
+  int found = 0;
+
+  dir = opendir(dirname);
+  if (!dir)
+    return 0;
+
+  while ((entry = readdir(dir)) != NULL) {
+    /* Skip anything starting with a . */
+    if (entry->d_name[0] == '.')
+      continue;
+
+    /* We assume if we find any files that it must be the right place */
+    found = 1;
+    break;
+  }
+
+  closedir(dir);
+
+  return found;
+}
+
+void usb_os_init(void)
+{
+  /* Find the path to the virtual filesystem */
+  if (getenv("USB_DEVFS_PATH")) {
+    if (check_usb_vfs(getenv("USB_DEVFS_PATH"))) {
+      strncpy(usb_path, getenv("USB_DEVFS_PATH"), sizeof(usb_path) - 1);
+      usb_path[sizeof(usb_path) - 1] = 0;
+    } else if (usb_debug)
+      fprintf(stderr, "usb_os_init: couldn't find USB VFS in USB_DEVFS_PATH\n");
+  }
+
+  if (!usb_path[0]) {
+    if (check_usb_vfs("/dev/bus/usb")) {
+      strncpy(usb_path, "/dev/bus/usb", sizeof(usb_path) - 1);
+      usb_path[sizeof(usb_path) - 1] = 0;
+    } else if (check_usb_vfs("/proc/bus/usb")) {
+      strncpy(usb_path, "/proc/bus/usb", sizeof(usb_path) - 1);
+      usb_path[sizeof(usb_path) - 1] = 0;
+    } else
+      usb_path[0] = 0;	/* No path, no USB support */
+  }
+
+  if (usb_debug) {
+    if (usb_path[0])
+      fprintf(stderr, "usb_os_init: Found USB VFS at %s\n", usb_path);
+    else
+      fprintf(stderr, "usb_os_init: No USB VFS found, is it mounted?\n");
+  }
+}
+
+int usb_resetep(usb_dev_handle *dev, unsigned int ep)
+{
+  int ret;
+
+  ret = ioctl(dev->fd, IOCTL_USB_RESETEP, &ep);
+  if (ret)
+    USB_ERROR_STR(-errno, "could not reset ep %d: %s", ep,
+    	strerror(errno));
+
+  return 0;
+}
+
+int usb_clear_halt(usb_dev_handle *dev, unsigned int ep)
+{
+  int ret;
+
+  ret = ioctl(dev->fd, IOCTL_USB_CLEAR_HALT, &ep);
+  if (ret)
+    USB_ERROR_STR(-errno, "could not clear/halt ep %d: %s", ep,
+    	strerror(errno));
+
+  return 0;
+}
+
+int usb_reset(usb_dev_handle *dev)
+{
+  int ret;
+
+  ret = ioctl(dev->fd, IOCTL_USB_RESET, NULL);
+  if (ret)
+     USB_ERROR_STR(-errno, "could not reset: %s", strerror(errno));
+
+  return 0;
+}
+
+int usb_get_driver_np(usb_dev_handle *dev, int interface, char *name,
+	unsigned int namelen)
+{
+  struct usb_getdriver getdrv;
+  int ret;
+
+  getdrv.interface = interface;
+  ret = ioctl(dev->fd, IOCTL_USB_GETDRIVER, &getdrv);
+  if (ret)
+    USB_ERROR_STR(-errno, "could not get bound driver: %s", strerror(errno));
+
+  strncpy(name, getdrv.driver, namelen - 1);
+  name[namelen - 1] = 0;
+
+  return 0;
+}
+
+int usb_detach_kernel_driver_np(usb_dev_handle *dev, int interface)
+{
+  struct usb_ioctl command;
+  int ret;
+
+  command.ifno = interface;
+  command.ioctl_code = IOCTL_USB_DISCONNECT;
+  command.data = NULL;
+
+  ret = ioctl(dev->fd, IOCTL_USB_IOCTL, &command);
+  if (ret)
+    USB_ERROR_STR(-errno, "could not detach kernel driver from interface %d: %s",
+        interface, strerror(errno));
+
+  return 0;
+}
+

libusb/linux.h

@@ -0,0 +1,119 @@
+#ifndef __LINUX_H__
+#define __LINUX_H__
+
+#include <unistd.h>
+#include <sys/stat.h>
+#include <sys/ioctl.h>
+
+struct usb_ctrltransfer {
+	/* keep in sync with usbdevice_fs.h:usbdevfs_ctrltransfer */
+	u_int8_t  bRequestType;
+	u_int8_t  bRequest;
+	u_int16_t wValue;
+	u_int16_t wIndex;
+	u_int16_t wLength;
+
+	u_int32_t timeout;	/* in milliseconds */
+
+	/* pointer to data */
+	void *data;
+};
+
+struct usb_bulktransfer {
+	/* keep in sync with usbdevice_fs.h:usbdevfs_bulktransfer */
+	unsigned int ep;
+	unsigned int len;
+	unsigned int timeout;	/* in milliseconds */
+
+	/* pointer to data */
+	void *data;
+};
+
+struct usb_setinterface {
+	/* keep in sync with usbdevice_fs.h:usbdevfs_setinterface */
+	unsigned int interface;
+	unsigned int altsetting;
+};
+
+#define USB_MAXDRIVERNAME 255
+
+struct usb_getdriver {
+	unsigned int interface;
+	char driver[USB_MAXDRIVERNAME + 1];
+};
+
+#define USB_URB_DISABLE_SPD	1
+#define USB_URB_ISO_ASAP	2
+#define USB_URB_QUEUE_BULK	0x10
+
+#define USB_URB_TYPE_ISO	0
+#define USB_URB_TYPE_INTERRUPT	1
+#define USB_URB_TYPE_CONTROL	2
+#define USB_URB_TYPE_BULK	3
+
+struct usb_iso_packet_desc {
+	unsigned int length;
+	unsigned int actual_length;
+	unsigned int status;
+};
+
+struct usb_urb {
+	unsigned char type;
+	unsigned char endpoint;
+	int status;
+	unsigned int flags;
+	void *buffer;
+	int buffer_length;
+	int actual_length;
+	int start_frame;
+	int number_of_packets;
+	int error_count;
+	unsigned int signr;  /* signal to be sent on error, -1 if none should be sent */
+	void *usercontext;
+	struct usb_iso_packet_desc iso_frame_desc[0];
+};
+
+struct usb_connectinfo {
+	unsigned int devnum;
+	unsigned char slow;
+};
+
+struct usb_ioctl {
+	int ifno;	/* interface 0..N ; negative numbers reserved */
+	int ioctl_code;	/* MUST encode size + direction of data so the
+			 * macros in <asm/ioctl.h> give correct values */
+	void *data;	/* param buffer (in, or out) */
+};
+
+struct usb_hub_portinfo {
+	unsigned char numports;
+	unsigned char port[127];	/* port to device num mapping */
+};
+
+#define IOCTL_USB_CONTROL	_IOWR('U', 0, struct usb_ctrltransfer)
+#define IOCTL_USB_BULK		_IOWR('U', 2, struct usb_bulktransfer)
+#define IOCTL_USB_RESETEP	_IOR('U', 3, unsigned int)
+#define IOCTL_USB_SETINTF	_IOR('U', 4, struct usb_setinterface)
+#define IOCTL_USB_SETCONFIG	_IOR('U', 5, unsigned int)
+#define IOCTL_USB_GETDRIVER	_IOW('U', 8, struct usb_getdriver)
+#define IOCTL_USB_SUBMITURB	_IOR('U', 10, struct usb_urb)
+#define IOCTL_USB_DISCARDURB	_IO('U', 11)
+#define IOCTL_USB_REAPURB	_IOW('U', 12, void *)
+#define IOCTL_USB_REAPURBNDELAY	_IOW('U', 13, void *)
+#define IOCTL_USB_CLAIMINTF	_IOR('U', 15, unsigned int)
+#define IOCTL_USB_RELEASEINTF	_IOR('U', 16, unsigned int)
+#define IOCTL_USB_CONNECTINFO	_IOW('U', 17, struct usb_connectinfo)
+#define IOCTL_USB_IOCTL         _IOWR('U', 18, struct usb_ioctl)
+#define IOCTL_USB_HUB_PORTINFO	_IOR('U', 19, struct usb_hub_portinfo)
+#define IOCTL_USB_RESET		_IO('U', 20)
+#define IOCTL_USB_CLEAR_HALT	_IOR('U', 21, unsigned int)
+#define IOCTL_USB_DISCONNECT	_IO('U', 22)
+#define IOCTL_USB_CONNECT	_IO('U', 23)
+
+/*
+ * IOCTL_USB_HUB_PORTINFO, IOCTL_USB_DISCONNECT and IOCTL_USB_CONNECT
+ * all work via IOCTL_USB_IOCTL
+ */
+
+#endif
+

libusb/usb.c

@@ -0,0 +1,307 @@
+/*
+ * Main API entry point
+ *
+ * Copyright (c) 2000-2003 Johannes Erdfelt <johannes@erdfelt.com>
+ *
+ * This library is covered by the LGPL, read LICENSE for details.
+ */
+
+#include <stdlib.h>	/* getenv */
+#include <stdio.h>	/* stderr */
+#include <string.h>	/* strcmp */
+#include <errno.h>
+
+#include "usbi.h"
+
+int usb_debug = 0;
+struct usb_bus *usb_busses = NULL;
+
+int usb_find_busses(void)
+{
+  struct usb_bus *busses, *bus;
+  int ret, changes = 0;
+
+  ret = usb_os_find_busses(&busses);
+  if (ret < 0)
+    return ret;
+
+  /*
+   * Now walk through all of the busses we know about and compare against
+   * this new list. Any duplicates will be removed from the new list.
+   * If we don't find it in the new list, the bus was removed. Any
+   * busses still in the new list, are new to us.
+   */
+  bus = usb_busses;
+  while (bus) {
+    int found = 0;
+    struct usb_bus *nbus, *tbus = bus->next;
+
+    nbus = busses;
+    while (nbus) {
+      struct usb_bus *tnbus = nbus->next;
+
+      if (!strcmp(bus->dirname, nbus->dirname)) {
+        /* Remove it from the new busses list */
+        LIST_DEL(busses, nbus);
+
+        usb_free_bus(nbus);
+        found = 1;
+        break;
+      }
+
+      nbus = tnbus;
+    }
+
+    if (!found) {
+      /* The bus was removed from the system */
+      LIST_DEL(usb_busses, bus);
+      usb_free_bus(bus);
+      changes++;
+    }
+
+    bus = tbus;
+  }
+
+  /*
+   * Anything on the *busses list is new. So add them to usb_busses and
+   * process them like the new bus it is.
+   */
+  bus = busses;
+  while (bus) {
+    struct usb_bus *tbus = bus->next;
+
+    /*
+     * Remove it from the temporary list first and add it to the real
+     * usb_busses list.
+     */
+    LIST_DEL(busses, bus);
+
+    LIST_ADD(usb_busses, bus);
+
+    changes++;
+
+    bus = tbus;
+  }
+
+  return changes;
+}
+
+int usb_find_devices(void)
+{
+  struct usb_bus *bus;
+  int ret, changes = 0;
+
+  for (bus = usb_busses; bus; bus = bus->next) {
+    struct usb_device *devices, *dev;
+
+    /* Find all of the devices and put them into a temporary list */
+    ret = usb_os_find_devices(bus, &devices);
+    if (ret < 0)
+      return ret;
+
+    /*
+     * Now walk through all of the devices we know about and compare
+     * against this new list. Any duplicates will be removed from the new
+     * list. If we don't find it in the new list, the device was removed.
+     * Any devices still in the new list, are new to us.
+     */
+    dev = bus->devices;
+    while (dev) {
+      int found = 0;
+      struct usb_device *ndev, *tdev = dev->next;
+
+      ndev = devices;
+      while (ndev) {
+        struct usb_device *tndev = ndev->next;
+
+        if (!strcmp(dev->filename, ndev->filename)) {
+          /* Remove it from the new devices list */
+          LIST_DEL(devices, ndev);
+
+          usb_free_dev(ndev);
+          found = 1;
+          break;
+        }
+
+        ndev = tndev;
+      }
+
+      if (!found) {
+        /* The device was removed from the system */
+        LIST_DEL(bus->devices, dev);
+        usb_free_dev(dev);
+        changes++;
+      }
+
+      dev = tdev;
+    }
+
+    /*
+     * Anything on the *devices list is new. So add them to bus->devices and
+     * process them like the new device it is.
+     */
+    dev = devices;
+    while (dev) {
+      struct usb_device *tdev = dev->next;
+
+      /*
+       * Remove it from the temporary list first and add it to the real
+       * bus->devices list.
+       */
+      LIST_DEL(devices, dev);
+
+      LIST_ADD(bus->devices, dev);
+
+      /*
+       * Some ports fetch the descriptors on scanning (like Linux) so we don't
+       * need to fetch them again.
+       */
+      if (!dev->config) {
+        usb_dev_handle *udev;
+
+        udev = usb_open(dev);
+        if (udev) {
+          usb_fetch_and_parse_descriptors(udev);
+
+          usb_close(udev);
+        }
+      }
+
+      changes++;
+
+      dev = tdev;
+    }
+
+    usb_os_determine_children(bus);
+  }
+
+  return changes;
+}
+
+void usb_set_debug(int level)
+{
+  if (usb_debug || level)
+    fprintf(stderr, "usb_set_debug: Setting debugging level to %d (%s)\n",
+	level, level ? "on" : "off");
+
+  usb_debug = level;
+}
+
+void usb_init(void)
+{
+  if (getenv("USB_DEBUG"))
+    usb_set_debug(atoi(getenv("USB_DEBUG")));
+
+  usb_os_init();
+}
+
+usb_dev_handle *usb_open(struct usb_device *dev)
+{
+  usb_dev_handle *udev;
+
+  udev = malloc(sizeof(*udev));
+  if (!udev)
+    return NULL;
+
+  udev->fd = -1;
+  udev->device = dev;
+  udev->bus = dev->bus;
+  udev->config = udev->interface = udev->altsetting = -1;
+
+  if (usb_os_open(udev) < 0) {
+    free(udev);
+    return NULL;
+  }
+
+  return udev;
+}
+
+int usb_get_string(usb_dev_handle *dev, int index, int langid, char *buf,
+	size_t buflen)
+{
+  /*
+   * We can't use usb_get_descriptor() because it's lacking the index
+   * parameter. This will be fixed in libusb 1.0
+   */
+  return usb_control_msg(dev, USB_ENDPOINT_IN, USB_REQ_GET_DESCRIPTOR,
+			(USB_DT_STRING << 8) + index, langid, buf, buflen, 1000);
+}
+
+int usb_get_string_simple(usb_dev_handle *dev, int index, char *buf, size_t buflen)
+{
+  char tbuf[255];	/* Some devices choke on size > 255 */
+  int ret, langid, si, di;
+
+  /*
+   * Asking for the zero'th index is special - it returns a string
+   * descriptor that contains all the language IDs supported by the
+   * device. Typically there aren't many - often only one. The
+   * language IDs are 16 bit numbers, and they start at the third byte
+   * in the descriptor. See USB 2.0 specification, section 9.6.7, for
+   * more information on this. */
+  ret = usb_get_string(dev, 0, 0, tbuf, sizeof(tbuf));
+  if (ret < 0)
+    return ret;
+
+  if (ret < 4)
+    return -EIO;
+
+  langid = tbuf[2] | (tbuf[3] << 8);
+
+  ret = usb_get_string(dev, index, langid, tbuf, sizeof(tbuf));
+  if (ret < 0)
+    return ret;
+
+  if (tbuf[1] != USB_DT_STRING)
+    return -EIO;
+
+  if (tbuf[0] > ret)
+    return -EFBIG;
+
+  for (di = 0, si = 2; si < tbuf[0]; si += 2) {
+    if (di >= (buflen - 1))
+      break;
+
+    if (tbuf[si + 1])	/* high byte */
+      buf[di++] = '?';
+    else
+      buf[di++] = tbuf[si];
+  }
+
+  buf[di] = 0;
+
+  return di;
+}
+
+int usb_close(usb_dev_handle *dev)
+{
+  int ret;
+
+  ret = usb_os_close(dev);
+  free(dev);
+
+  return ret;
+}
+
+struct usb_device *usb_device(usb_dev_handle *dev)
+{
+  return dev->device;
+}
+
+void usb_free_dev(struct usb_device *dev)
+{
+  usb_destroy_configuration(dev);
+  free(dev->children);
+  free(dev);
+}
+
+struct usb_bus *usb_get_busses(void)
+{
+  return usb_busses;
+}
+
+void usb_free_bus(struct usb_bus *bus)
+{
+  free(bus);
+}
+

libusb/usb.h

@@ -0,0 +1,337 @@
+/*
+ * Prototypes, structure definitions and macros.
+ *
+ * Copyright (c) 2000-2003 Johannes Erdfelt <johannes@erdfelt.com>
+ *
+ * This library is covered by the LGPL, read LICENSE for details.
+ *
+ * This file (and only this file) may alternatively be licensed under the
+ * BSD license as well, read LICENSE for details.
+ */
+#ifndef __USB_H__
+#define __USB_H__
+
+#include <unistd.h>
+#include <stdlib.h>
+#include <limits.h>
+
+#include <dirent.h>
+
+/*
+ * USB spec information
+ *
+ * This is all stuff grabbed from various USB specs and is pretty much
+ * not subject to change
+ */
+
+/*
+ * Device and/or Interface Class codes
+ */
+#define USB_CLASS_PER_INTERFACE		0	/* for DeviceClass */
+#define USB_CLASS_AUDIO			1
+#define USB_CLASS_COMM			2
+#define USB_CLASS_HID			3
+#define USB_CLASS_PRINTER		7
+#define USB_CLASS_PTP			6
+#define USB_CLASS_MASS_STORAGE		8
+#define USB_CLASS_HUB			9
+#define USB_CLASS_DATA			10
+#define USB_CLASS_VENDOR_SPEC		0xff
+
+/*
+ * Descriptor types
+ */
+#define USB_DT_DEVICE			0x01
+#define USB_DT_CONFIG			0x02
+#define USB_DT_STRING			0x03
+#define USB_DT_INTERFACE		0x04
+#define USB_DT_ENDPOINT			0x05
+
+#define USB_DT_HID			0x21
+#define USB_DT_REPORT			0x22
+#define USB_DT_PHYSICAL			0x23
+#define USB_DT_HUB			0x29
+
+/*
+ * Descriptor sizes per descriptor type
+ */
+#define USB_DT_DEVICE_SIZE		18
+#define USB_DT_CONFIG_SIZE		9
+#define USB_DT_INTERFACE_SIZE		9
+#define USB_DT_ENDPOINT_SIZE		7
+#define USB_DT_ENDPOINT_AUDIO_SIZE	9	/* Audio extension */
+#define USB_DT_HUB_NONVAR_SIZE		7
+
+/* All standard descriptors have these 2 fields in common */
+struct usb_descriptor_header {
+	u_int8_t  bLength;
+	u_int8_t  bDescriptorType;
+};
+
+/* String descriptor */
+struct usb_string_descriptor {
+	u_int8_t  bLength;
+	u_int8_t  bDescriptorType;
+	u_int16_t wData[1];
+};
+
+/* HID descriptor */
+struct usb_hid_descriptor {
+	u_int8_t  bLength;
+	u_int8_t  bDescriptorType;
+	u_int16_t bcdHID;
+	u_int8_t  bCountryCode;
+	u_int8_t  bNumDescriptors;
+	/* u_int8_t  bReportDescriptorType; */
+	/* u_int16_t wDescriptorLength; */
+	/* ... */
+};
+
+/* Endpoint descriptor */
+#define USB_MAXENDPOINTS	32
+struct usb_endpoint_descriptor {
+	u_int8_t  bLength;
+	u_int8_t  bDescriptorType;
+	u_int8_t  bEndpointAddress;
+	u_int8_t  bmAttributes;
+	u_int16_t wMaxPacketSize;
+	u_int8_t  bInterval;
+	u_int8_t  bRefresh;
+	u_int8_t  bSynchAddress;
+
+	unsigned char *extra;	/* Extra descriptors */
+	int extralen;
+};
+
+#define USB_ENDPOINT_ADDRESS_MASK	0x0f    /* in bEndpointAddress */
+#define USB_ENDPOINT_DIR_MASK		0x80
+
+#define USB_ENDPOINT_TYPE_MASK		0x03    /* in bmAttributes */
+#define USB_ENDPOINT_TYPE_CONTROL	0
+#define USB_ENDPOINT_TYPE_ISOCHRONOUS	1
+#define USB_ENDPOINT_TYPE_BULK		2
+#define USB_ENDPOINT_TYPE_INTERRUPT	3
+
+/* Interface descriptor */
+#define USB_MAXINTERFACES	32
+struct usb_interface_descriptor {
+	u_int8_t  bLength;
+	u_int8_t  bDescriptorType;
+	u_int8_t  bInterfaceNumber;
+	u_int8_t  bAlternateSetting;
+	u_int8_t  bNumEndpoints;
+	u_int8_t  bInterfaceClass;
+	u_int8_t  bInterfaceSubClass;
+	u_int8_t  bInterfaceProtocol;
+	u_int8_t  iInterface;
+
+	struct usb_endpoint_descriptor *endpoint;
+
+	unsigned char *extra;	/* Extra descriptors */
+	int extralen;
+};
+
+#define USB_MAXALTSETTING	128	/* Hard limit */
+struct usb_interface {
+	struct usb_interface_descriptor *altsetting;
+
+	int num_altsetting;
+};
+
+/* Configuration descriptor information.. */
+#define USB_MAXCONFIG		8
+struct usb_config_descriptor {
+	u_int8_t  bLength;
+	u_int8_t  bDescriptorType;
+	u_int16_t wTotalLength;
+	u_int8_t  bNumInterfaces;
+	u_int8_t  bConfigurationValue;
+	u_int8_t  iConfiguration;
+	u_int8_t  bmAttributes;
+	u_int8_t  MaxPower;
+
+	struct usb_interface *interface;
+
+	unsigned char *extra;	/* Extra descriptors */
+	int extralen;
+};
+
+/* Device descriptor */
+struct usb_device_descriptor {
+	u_int8_t  bLength;
+	u_int8_t  bDescriptorType;
+	u_int16_t bcdUSB;
+	u_int8_t  bDeviceClass;
+	u_int8_t  bDeviceSubClass;
+	u_int8_t  bDeviceProtocol;
+	u_int8_t  bMaxPacketSize0;
+	u_int16_t idVendor;
+	u_int16_t idProduct;
+	u_int16_t bcdDevice;
+	u_int8_t  iManufacturer;
+	u_int8_t  iProduct;
+	u_int8_t  iSerialNumber;
+	u_int8_t  bNumConfigurations;
+};
+
+struct usb_ctrl_setup {
+	u_int8_t  bRequestType;
+	u_int8_t  bRequest;
+	u_int16_t wValue;
+	u_int16_t wIndex;
+	u_int16_t wLength;
+};
+
+/*
+ * Standard requests
+ */
+#define USB_REQ_GET_STATUS		0x00
+#define USB_REQ_CLEAR_FEATURE		0x01
+/* 0x02 is reserved */
+#define USB_REQ_SET_FEATURE		0x03
+/* 0x04 is reserved */
+#define USB_REQ_SET_ADDRESS		0x05
+#define USB_REQ_GET_DESCRIPTOR		0x06
+#define USB_REQ_SET_DESCRIPTOR		0x07
+#define USB_REQ_GET_CONFIGURATION	0x08
+#define USB_REQ_SET_CONFIGURATION	0x09
+#define USB_REQ_GET_INTERFACE		0x0A
+#define USB_REQ_SET_INTERFACE		0x0B
+#define USB_REQ_SYNCH_FRAME		0x0C
+
+#define USB_TYPE_STANDARD		(0x00 << 5)
+#define USB_TYPE_CLASS			(0x01 << 5)
+#define USB_TYPE_VENDOR			(0x02 << 5)
+#define USB_TYPE_RESERVED		(0x03 << 5)
+
+#define USB_RECIP_DEVICE		0x00
+#define USB_RECIP_INTERFACE		0x01
+#define USB_RECIP_ENDPOINT		0x02
+#define USB_RECIP_OTHER			0x03
+
+/*
+ * Various libusb API related stuff
+ */
+
+#define USB_ENDPOINT_IN			0x80
+#define USB_ENDPOINT_OUT		0x00
+
+/* Error codes */
+#define USB_ERROR_BEGIN			500000
+
+/*
+ * This is supposed to look weird. This file is generated from autoconf
+ * and I didn't want to make this too complicated.
+ */
+#if 0
+#define USB_LE16_TO_CPU(x) do { x = ((x & 0xff) << 8) | ((x & 0xff00) >> 8); } while(0)
+#else
+#define USB_LE16_TO_CPU(x)
+#endif
+
+/* Data types */
+struct usb_device;
+struct usb_bus;
+
+/*
+ * To maintain compatibility with applications already built with libusb,
+ * we must only add entries to the end of this structure. NEVER delete or
+ * move members and only change types if you really know what you're doing.
+ */
+struct usb_device {
+  struct usb_device *next, *prev;
+
+  char filename[PATH_MAX + 1];
+
+  struct usb_bus *bus;
+
+  struct usb_device_descriptor descriptor;
+  struct usb_config_descriptor *config;
+
+  void *dev;		/* Darwin support */
+
+  u_int8_t devnum;
+
+  unsigned char num_children;
+  struct usb_device **children;
+};
+
+struct usb_bus {
+  struct usb_bus *next, *prev;
+
+  char dirname[PATH_MAX + 1];
+
+  struct usb_device *devices;
+  u_int32_t location;
+
+  struct usb_device *root_dev;
+};
+
+struct usb_dev_handle;
+typedef struct usb_dev_handle usb_dev_handle;
+
+/* Variables */
+extern struct usb_bus *usb_busses;
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Function prototypes */
+
+/* usb.c */
+usb_dev_handle *usb_open(struct usb_device *dev);
+int usb_close(usb_dev_handle *dev);
+int usb_get_string(usb_dev_handle *dev, int index, int langid, char *buf,
+	size_t buflen);
+int usb_get_string_simple(usb_dev_handle *dev, int index, char *buf,
+	size_t buflen);
+
+/* descriptors.c */
+int usb_get_descriptor_by_endpoint(usb_dev_handle *udev, int ep,
+	unsigned char type, unsigned char index, void *buf, int size);
+int usb_get_descriptor(usb_dev_handle *udev, unsigned char type,
+	unsigned char index, void *buf, int size);
+
+/* <arch>.c */
+int usb_bulk_write(usb_dev_handle *dev, int ep, char *bytes, int size,
+	int timeout);
+int usb_bulk_read(usb_dev_handle *dev, int ep, char *bytes, int size,
+	int timeout);
+int usb_interrupt_write(usb_dev_handle *dev, int ep, char *bytes, int size,
+        int timeout);
+int usb_interrupt_read(usb_dev_handle *dev, int ep, char *bytes, int size,
+        int timeout);
+int usb_control_msg(usb_dev_handle *dev, int requesttype, int request,
+	int value, int index, char *bytes, int size, int timeout);
+int usb_set_configuration(usb_dev_handle *dev, int configuration);
+int usb_claim_interface(usb_dev_handle *dev, int interface);
+int usb_release_interface(usb_dev_handle *dev, int interface);
+int usb_set_altinterface(usb_dev_handle *dev, int alternate);
+int usb_resetep(usb_dev_handle *dev, unsigned int ep);
+int usb_clear_halt(usb_dev_handle *dev, unsigned int ep);
+int usb_reset(usb_dev_handle *dev);
+
+#if 1
+#define LIBUSB_HAS_GET_DRIVER_NP 1
+int usb_get_driver_np(usb_dev_handle *dev, int interface, char *name,
+	unsigned int namelen);
+#define LIBUSB_HAS_DETACH_KERNEL_DRIVER_NP 1
+int usb_detach_kernel_driver_np(usb_dev_handle *dev, int interface);
+#endif
+
+char *usb_strerror(void);
+
+void usb_init(void);
+void usb_set_debug(int level);
+int usb_find_busses(void);
+int usb_find_devices(void);
+struct usb_device *usb_device(usb_dev_handle *dev);
+struct usb_bus *usb_get_busses(void);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* __USB_H__ */
+

libusb/usbi.h

@@ -0,0 +1,74 @@
+#ifndef _USBI_H_
+#define _USBI_H_
+
+#include "usb.h"
+
+#include "error.h"
+
+extern int usb_debug;
+
+/* Some quick and generic macros for the simple kind of lists we use */
+#define LIST_ADD(begin, ent) \
+	do { \
+	  if (begin) { \
+	    ent->next = begin; \
+	    ent->next->prev = ent; \
+	  } else \
+	    ent->next = NULL; \
+	  ent->prev = NULL; \
+	  begin = ent; \
+	} while(0)
+
+#define LIST_DEL(begin, ent) \
+	do { \
+	  if (ent->prev) \
+	    ent->prev->next = ent->next; \
+	  else \
+	    begin = ent->next; \
+	  if (ent->next) \
+	    ent->next->prev = ent->prev; \
+	  ent->prev = NULL; \
+	  ent->next = NULL; \
+	} while (0)
+
+#define DESC_HEADER_LENGTH		2
+#define DEVICE_DESC_LENGTH		18
+#define CONFIG_DESC_LENGTH		9
+#define INTERFACE_DESC_LENGTH		9
+#define ENDPOINT_DESC_LENGTH		7
+#define ENDPOINT_AUDIO_DESC_LENGTH	9
+
+struct usb_dev_handle {
+  int fd;
+
+  struct usb_bus *bus;
+  struct usb_device *device;
+
+  int config;
+  int interface;
+  int altsetting;
+
+  /* Added by RMT so implementations can store other per-open-device data */
+  void *impl_info;
+};
+
+/* descriptors.c */
+int usb_parse_descriptor(unsigned char *source, char *description, void *dest);
+int usb_parse_configuration(struct usb_config_descriptor *config,
+	unsigned char *buffer);
+void usb_fetch_and_parse_descriptors(usb_dev_handle *udev);
+void usb_destroy_configuration(struct usb_device *dev);
+
+/* OS specific routines */
+int usb_os_find_busses(struct usb_bus **busses);
+int usb_os_find_devices(struct usb_bus *bus, struct usb_device **devices);
+int usb_os_determine_children(struct usb_bus *bus);
+void usb_os_init(void);
+int usb_os_open(usb_dev_handle *dev);
+int usb_os_close(usb_dev_handle *dev);
+
+void usb_free_dev(struct usb_device *dev);
+void usb_free_bus(struct usb_bus *bus);
+
+#endif /* _USBI_H_ */
+

libusb/usbpp.h

@@ -0,0 +1,855 @@
+// -*- C++;indent-tabs-mode: t; tab-width: 4; c-basic-offset: 4; -*-
+#ifndef __USBPP_HEADER__
+#define __USBPP_HEADER__
+
+#include <string>
+#include <list>
+
+#include <usb.h>
+
+/*
+ * The following usb.h function is not wrapped yet:
+ *  char *usb_strerror(void);
+ */
+
+
+/**
+ * \brief Classes to access Universal Serial Bus devices
+ *
+ * The USB Namespace provides a number of classes to work
+ * with Universal Serial Bus (USB) devices attached to the
+ * system.
+ *
+ * \author Brad Hards
+ */
+namespace USB {
+
+	class Device;
+
+	/**
+	 * \brief Class representing a device endpoint
+	 *
+	 * This class represents a device endpoint. You need this class to
+	 * perform bulk reads and writes.
+	 *
+	 */
+	class Endpoint {
+		/**
+		 * Busses is a friend because it fills in the descriptor type
+		 * information on initialisation and rescan.
+		 */
+		friend class Busses;
+	public:
+		Endpoint() {};
+
+#ifdef USE_UNTESTED_LIBUSBPP_METHODS
+		/**
+		 * \brief Bulk write
+		 * 
+		 * This method performs a bulk transfer to the endpoint.
+		 *
+		 * \param message is the message to be sent.
+		 * \param timeout is the USB transaction timeout in milliseconds
+		 *
+		 * \returns the number of bytes sent, or a negative value on
+		 * failure
+		 */
+		int bulkWrite(QByteArray message, int timeout = 100);
+		
+		/**
+		 * \brief Bulk read
+		 * 
+		 * This method performs a bulk transfer from the endpoint.
+		 *
+		 * \param length is the maximum data transfer required. 
+		 * \param message is the message that was received.
+		 * \param timeout is the USB transaction timeout in milliseconds
+		 *
+		 * \returns the number of bytes received, or a negative value on
+		 * failure
+		 */
+		int bulkRead(int length, unsigned char *message, int timeout = 100);
+
+		/**
+		 * \brief Reset endpoint
+		 *
+		 * This method resets the endpoint.
+		 */
+		int reset(void);
+
+		/**
+		 * \brief Clear halt
+		 *
+		 * This method clears a halt (stall) on the endpoint.
+		 */
+		int clearHalt(void);
+
+#endif /* USE_UNTESTED_LIBUSBPP_METHODS */
+
+		/**
+		 * \brief Endpoint descriptor information output
+		 *
+		 * This method dumps out the various characteristics
+		 * of the endpoint to standard output. 
+		 *
+		 * It is mostly useful for debugging.
+		 */
+		void dumpDescriptor(void);
+
+	private:
+		void setDescriptor(struct usb_endpoint_descriptor);
+		void setParent(Device *parent);
+		u_int8_t  m_Length;
+		u_int8_t  m_DescriptorType;
+		u_int8_t  m_EndpointAddress;
+		u_int8_t  m_Attributes;
+		u_int16_t m_MaxPacketSize;
+		u_int8_t  m_Interval;
+		u_int8_t  m_Refresh;
+		u_int8_t  m_SynchAddress;
+		Device    *m_parent;
+	};
+
+	class AltSetting : public std::list<Endpoint *> {
+		/**
+		 * Busses is a friend because it fills in the descriptor type
+		 * information on initialisation and rescan.
+		 */
+		friend class Busses;
+	public:
+		AltSetting() {};
+		u_int8_t numEndpoints(void);
+
+		/**
+		 * \brief AltSetting descriptor information output
+		 *
+		 * This method dumps out the various characteristics
+		 * of the alternate setting to standard output. 
+		 *
+		 * It is mostly useful for debugging.
+		 */
+		void dumpDescriptor(void);
+
+		Endpoint *firstEndpoint(void);
+		Endpoint *nextEndpoint(void);
+		Endpoint *lastEndpoint(void);
+
+	private:
+		std::list<Endpoint *>::const_iterator iter;
+
+		void setDescriptor(struct usb_interface_descriptor);
+		/* we don't use a normal usb_interface_descriptor */
+		/* because that would bring in the endpoint list */
+		u_int8_t m_Length;
+		u_int8_t m_DescriptorType;
+		u_int8_t m_InterfaceNumber;
+		u_int8_t m_AlternateSetting;
+		u_int8_t m_NumEndpoints;
+		u_int8_t m_InterfaceClass;
+		u_int8_t m_InterfaceSubClass;
+		u_int8_t m_InterfaceProtocol;
+		u_int8_t m_Interface;
+	};
+
+	/**
+	 * \brief Class representing an interface of a Device
+	 *
+	 * The Interface class represents a USB interface
+	 * for a device attached to a Universal Serial Bus.
+	 *
+	 * Interfaces are the main element of the USB class
+	 * structure.
+	 *
+	 * \author Brad Hards
+	 */
+	class Interface : public std::list<AltSetting *> {
+		/**
+		 * Busses is a friend because it fills in the descriptor type
+		 * information on initialisation and rescan.
+		 */
+		friend class Busses;
+	public:
+		Interface() {};
+
+#ifdef LIBUSB_HAS_GET_DRIVER_NP
+		/**
+		 * \brief get the current driver for an interface
+		 * 
+		 * \param driver a string containing the name of the current
+		 * driver for the interface. You can typically pass in an empty
+		 * string for this. 
+		 *
+		 * \return length of string, or 0 on error.
+		 */
+		int driverName(std::string &driver);
+#endif
+
+#ifdef USE_UNTESTED_LIBUSBPP_METHODS
+		/**
+		 * \brief Claim this interface
+		 *
+		 * This method claims the interface. You have to claim the
+		 * interface before performing any operations on the interface (or
+		 * on endpoints that are part of the interface).
+		 *
+		 * \return 0 on success or negative number on error.
+		 */
+		int claim(void);
+
+		/**
+		 * \brief Release this interface
+		 *
+		 * This method releases the interface. You should release the
+		 * interface after all operations on it (and any lower level
+		 * endpoints) are completed.
+		 *
+		 * \return 0 on success or negative number on error.
+		 */
+		int release(void);
+
+		/**
+		 * \brief Set interface alternate setting
+		 *
+		 * This method sets the interface to a particular AltSetting.
+		 *
+		 * \param altSettingNumber the AltSetting that the interface
+		 * should be changed to.
+		 *
+		 * \return 0 on success, or a negative number in case of error.
+		 */
+		int setAltSetting(int altSettingNumber);
+#endif /* USE_UNTESTED_LIBUSBPP_METHODS */
+
+		/**
+		 * \brief Number of Alternative Settings that this interface has
+		 *
+		 * This is a simple accessor method that specifies the number
+		 * alternative settings that this device interface has.
+		 */
+		u_int8_t numAltSettings(void);
+
+		/**
+		 * \brief First AltSetting for the Interface
+		 *
+		 * This method returns a pointer to the first AltSetting
+		 * for the Interface. 
+		 *
+		 * See nextAltSetting() for an example of how it might be
+		 * used.
+		 *
+		 * \see nextAltSetting(), lastAltSetting(), numAltSettings()
+		 */
+		AltSetting *firstAltSetting(void);
+
+		/**
+		 * \brief Next AltSetting for the Interface
+		 *
+		 * This method returns a pointer to the next AltSetting
+		 * for the Interface. 
+		 *
+		 * If you want to iterate through each AltSetting on 
+		 * a device, you can use something like the following:
+		 * \code
+		 * USB::Configuration *this_Configuration;
+		 * this_Configuration = device->firstConfiguration();
+		 * for (i=0; i < device->numConfigurations(); i++) {
+		 *	 this_Configuration->dumpDescriptor();
+		 *   USB::Interface *this_Interface;
+		 *   this_Interface = this_Configuration->firstInterface();
+		 *   for (j=0; j < this_Configuration->numInterfaces(); j++) {
+		 *     USB::AltSetting *this_AltSetting;
+		 *     this_AltSetting = this_Interface->firstAltSetting();
+		 *     for (k=0; k < this_Interface->numAltSettings(); k++) {
+		 *       // do something with this_AltSetting
+		 *       this_AltSetting = this_Interface->nextAltSetting();
+		 *     }
+		 *   this_Interface = this_Configuration->nextInterface();
+		 *   }
+		 *   this_Configuration = device->nextConfiguration();
+		 * }
+		 * \endcode
+		 *
+		 * \see firstAltSetting(), lastAltSetting(), numAltSettings()
+		 */
+		AltSetting *nextAltSetting(void);
+
+		/**
+		 * \brief Last AltSetting for the Interface
+		 *
+		 * This method returns a pointer to the last AltSetting
+		 * for the Interface. 
+		 *
+		 * \see firstAltSetting(), nextAltSetting(), numAltSettings()
+		 */
+
+		AltSetting *lastAltSetting(void);
+
+	private:
+		std::list<AltSetting *>::const_iterator iter;
+
+		void setNumAltSettings(u_int8_t);
+		void setParent(Device *parent);
+		u_int8_t m_numAltSettings;
+		Device    *m_parent;
+
+		/* index representing the interface, in this configuration */
+		int m_interfaceNumber;
+		void setInterfaceNumber(int interfaceNumber);
+	};
+
+	/**
+	 * \brief Class representing a configuration of a Device
+	 *
+	 * The Configuration class represents a single configuration
+	 * of a device attached to a Universal Serial Bus.
+	 *
+	 * \author Brad Hards 
+	 */
+	class Configuration : public std::list<Interface *> {
+		/**
+		 * Busses is a friend because it fills in the descriptor type
+		 * information on initialisation and rescan.
+		 */
+		friend class Busses;
+	public:
+		Configuration() {};
+
+		/**
+		 * \brief Configuration descriptor information output
+		 *
+		 * This method dumps out the various characteristics
+		 * of the configuration to standard output. 
+		 *
+		 * It is mostly useful for debugging.
+		 */
+		void dumpDescriptor(void);
+
+		/**
+		 * \brief Number of Interfaces that this device has
+		 *
+		 * This is a simple accessor method that specifies the number
+		 * Interfaces that this device configuration has.
+		 */
+		u_int8_t numInterfaces(void);
+
+		/**
+		 * \brief First Interface for the Configuration
+		 *
+		 * This method returns a pointer to the first Interface
+		 * for the Configuration. 
+		 *
+		 * See nextInterface() for an example of how it might be
+		 * used.
+		 *
+		 * \see nextInterface(), lastInterface(), numInterfaces()
+		 */
+		Interface *firstInterface(void);
+
+		/**
+		 * \brief Next Interface for the Configuration
+		 *
+		 * This method returns a pointer to the next Interface
+		 * for the Configuration. 
+		 *
+		 * If you want to iterate through each Interface on 
+		 * a device, you can use something like the following:
+		 * \code
+		 * USB::Configuration *this_Configuration;
+		 * this_Configuration = device->firstConfiguration();
+		 * for (i=0; i < device->numConfigurations(); i++) {
+		 *	 this_Interface = this_Configuration->firstInterface();
+		 *	 for (j=0; j < this_Configuration->numInterfaces(); j++) {
+		 *     // do something with this_Interface
+		 *     this_Interface = this_Configuration->nextInterface();
+		 *   }
+		 *   this_Configuration->nextConfiguration();
+		 * }
+		 * \endcode
+		 *
+		 * \see firstInterface(), lastInterface(), numInterfaces()
+		 */
+		Interface *nextInterface(void);
+
+		/**
+		 * \brief Last Interface for the Configuration
+		 *
+		 * This method returns a pointer to the last Interface
+		 * for the Configuration. 
+		 *
+		 * \see firstInterface(), nextInterface(), numInterfaces()
+		 */
+		Interface *lastInterface(void);
+
+	private:
+		std::list<Interface *>::const_iterator iter;
+
+		void setDescriptor(struct usb_config_descriptor);
+		/* we don't use a normal usb_config_descriptor */
+		/* because that would bring in the interface list */
+		u_int8_t  m_Length;
+		u_int8_t  m_DescriptorType;
+		u_int16_t m_TotalLength;
+		u_int8_t  m_NumInterfaces;
+		u_int8_t  m_ConfigurationValue;
+		u_int8_t  m_Configuration;
+		u_int8_t  m_Attributes;
+		u_int8_t  m_MaxPower; 
+	};
+
+	/**
+	 * \brief Class representing a Device on the Bus
+	 *
+	 * The Device class represents a single device
+	 * attached to a Universal Serial Bus.
+	 *
+	 * \author Brad Hards 
+	 */
+	class Device : public std::list<Configuration *> {
+		/**
+		 * Busses is a friend because it fills in the descriptor type
+		 * information on initialisation and rescan.
+		 */
+		friend class Busses;
+		/** 
+		 * Interface is a friend because it needs the handle() function to
+		 * perform claim(), release().
+		 */
+		friend class Interface;
+		/** 
+		 * Endpoint is a friend because it needs the handle() function to
+		 * perform reads, writes, and other transactions.
+		 */
+		friend class Endpoint;
+
+	public:
+		Device() {};
+		~Device();
+
+		/**
+		 * \brief OS representation of filename for this device
+		 *
+		 * libusb++ provides a uniform way of accessing USB
+		 * devices irrespective of the underlying Operation System
+		 * representation. If you want to map the libusb++ representation
+		 * to the Operating System representation, you can do this
+		 * with filename().
+		 *
+		 * On Linux, the filename is usually something like 002, which
+		 * represents the second device (usually the first real device,
+		 * after the root hub pseudo-device) on the bus.
+		 *
+		 * \see Bus::directoryName()
+		 */
+		std::string fileName(void);
+
+		/** 
+		 * \brief The vendor ID number, as provided by the device.
+		 *
+		 * This method returns a number containing the vendor
+		 * (manufacturer) identification number. These are allocated
+		 * by the USB Implementers Forum, and you can construct a
+		 * lookup based on the number to get the manufacturer's name,
+		 * even if the device does not contain a vendor string.
+		 *
+		 * \see Vendor()
+		 */ 
+		u_int16_t idVendor(void);
+
+		/** 
+		 * \brief The product ID number, as provided by the device.
+		 *
+		 * This method returns a number containing the product
+		 * identification number. These are allocated
+		 * by the manufacturer, and should be different on each device.
+		 *
+		 * \see Product()
+		 */ 
+		u_int16_t idProduct(void);
+
+		/**
+		 * \brief The product's revision ID, as provided by the device.
+		 *
+		 * This method returns a number containing the product's revision.
+		 * This revision level is nominally binary coded decimal, but
+		 * hexadecimal revision levels are not uncommon. The binary coded
+		 * decimal version nominally has a major version in the high byte,
+		 * and a minor version in the low byte. 
+		 */
+		u_int16_t idRevision(void);
+
+		/**
+		 * \brief The device's USB class, as provided by the device.
+		 *
+		 * This method returns a number containing the device's class.
+		 * These are defined by the USB Implementer's Forum.
+		 *
+		 * A code of Zero is special (and common) - it means that the
+		 * class is found in the Interface descriptor, rather than in the
+		 * Device descriptor.
+		 * 
+		 * A code of 0xFF is also special (and far too common) - it means
+		 * that the manufacturer didn't conform to one of the defined 
+		 * class specifications, and chose to implement a vendor specified
+		 * protocol.
+		 *
+		 */
+		u_int8_t devClass(void);
+
+		/**
+		 * \brief The device's USB subclass, as provided by the device.
+		 *
+		 * This method returns a number containing the device's subclass.
+		 * These subclasses are defined by the USB Implementer's Forum,
+		 * and only have meaning in the context of a specified class. 
+		 */
+		u_int8_t devSubClass(void);
+
+		/**
+		 * \brief The device's USB protocol, as provided by the device.
+		 *
+		 * This method returns a number containing the device's protocol.
+		 * These protocols are defined by the USB Implementer's Forum, and
+		 * only have meaning in the context of a specified class and
+		 * subclass. 
+		 */
+		u_int8_t devProtocol(void);
+
+    
+		/**
+		 * \brief The vendor name string, as provided by the device.
+		 *
+		 * This method returns a string containing the name of the 
+		 * device's vendor (manufacturer), as encoded into the device.
+		 *
+		 * Note that not all devices contain a vendor name, and also
+		 * that under some operating systems you may not be able to
+		 * read the vendor name without elevated privledges (typically
+		 * root privledges).
+		 *
+		 * \see idVendor()
+		 **/
+		std::string Vendor(void);
+
+		/**
+		 * \brief The product name string, as provided by the device.
+		 *
+		 * This method returns a string containing the name of the 
+		 * device's product name, as encoded into the device.
+		 *
+		 * Note that not all devices contain a product name, and also
+		 * that under some operating systems you may not be able to
+		 * read the vendor name without elevated privledges (typically
+		 * root privledges).
+		 * 
+		 * \see idProduct()
+		 **/
+		std::string Product(void);
+
+		/**
+		 * \brief The serial number string, as provided by the device.
+		 *
+		 * This method returns a string containing a serial number for
+		 * the device, as encoded into the device.
+		 *
+		 * Note that few devices contain a serial number string, and also
+		 * that under some operating systems you may not be able to
+		 * read the serial number without elevated privledges (typically
+		 * root privledges). The USB specification requires that serial
+		 * numbers are unique if they are provided, but adherence to this
+		 * requirement by manufacturers is not universal.
+		 **/
+		std::string SerialNumber(void);
+
+		/**
+		 * \brief Number of Configurations that this device has
+		 *
+		 * This is a simple accessor method that specifies the number
+		 * configurations that this device has.
+		 */
+		u_int8_t numConfigurations(void);
+
+		/**
+		 * \brief fetch an arbitrary string from the device
+		 * 
+		 * \param string the string from the device. You can typically
+		 * pass in an empty string for this.
+		 * \param index the index of the string required
+		 * \param lang the language ID to use. Defaults to using the
+		 * first language ID.
+		 *
+		 * \return length of string, or 0 on error.
+		 */
+		int string(std::string &buf, int index, u_int16_t lang=0);
+
+		/**
+		 * \brief First Configuration for the Device
+		 *
+		 * This method returns a pointer to the first Configuration
+		 * for the Device. 
+		 *
+		 * See nextConfiguration() for an example of how it might be
+		 * used.
+		 */
+		Configuration *firstConfiguration(void);
+
+		/**
+		 * \brief Next Configuration for the Device
+		 *
+		 * This method returns a pointer to the next Configuration
+		 * for the Device. 
+		 *
+		 * If you want to iterate through each Configuration on
+		 * a device, you can use something like the following:
+		 * \code
+		 * USB::Configuration *this_Configuration;
+		 * this_Configuration = device->firstConfiguration();
+		 * for (i=0; i < device->numConfigurations(); i++) {
+		 *   // do something with this_Configuration
+		 *   this_Configuration->nextConfiguration();
+		 * }
+		 * \endcode
+		 */
+		Configuration *nextConfiguration(void);
+
+		/**
+		 * \brief Last Configuration for the Device
+		 *
+		 * This method returns a pointer to the last Configuration
+		 * for the Device. 
+		 *
+		 */
+		Configuration *lastConfiguration(void);
+
+		/**
+		 * \brief USB control transfer
+		 *
+		 * This method performs a standard control transfer to the default
+		 * endpoint. See the USB specification for more details on this.
+		 * 
+		 * \param requestType corresponds to the bmRequestType field
+		 * in the transfer
+		 * \param request corresponds to the bRequest field in the
+		 * transfer
+		 * \param value corresponds to the wValue field in the transfer
+		 * \param index corresponds to the wIndex field in the transfer
+		 * \param length corresponds to the wLength field in the transfer
+		 * \param payload corresponds to the data phase of a control
+		 * transfer
+		 * \param timeout is the timeout period for the control transfer,
+		 * in milliseconds
+		 *
+		 * \return number of bytes sent or received, or a negative number
+		 * in case of error.
+		 */
+		int controlTransfer(u_int8_t requestType, u_int8_t request,
+				    u_int16_t value, u_int16_t index, u_int16_t length,
+				    unsigned char *payload,
+				    int timeout = 100); 
+
+#ifdef USE_UNTESTED_LIBUSBPP_METHODS
+		/**
+		 * \brief USB device reset
+		 *
+		 * This method performs a device reset - see USB Specification
+		 * 9.1 for how this changes the device state to the Default state.
+		 *
+		 * \return 0 on success, or a negative number in case of error.
+		 */
+		int reset(void);
+
+		/**
+		 * \brief Set device configuration
+		 *
+		 * This method sets the device to a particular Configuration.
+		 *
+		 * \param configurationNumber the configuration that the device
+		 * should be changed to.
+		 *
+		 * \return 0 on success, or a negative number in case of error.
+		 */
+		int setConfiguration(int configurationNumber);
+#endif /* USE_UNTESTED_LIBUSBPP_METHODS */
+    
+	private:
+		std::list<Configuration *>::const_iterator iter;
+
+		struct usb_dev_handle *handle();
+		void setFileName(std::string);
+		void setDescriptor(struct usb_device_descriptor);
+		void setVendor(std::string);
+		void setProduct(std::string);
+		void setSerialNumber(std::string);
+		void setDevHandle(struct usb_dev_handle *);
+		std::string m_fileName;
+		std::string m_Vendor;
+		std::string m_Product;
+		std::string m_SerialNumber;
+		struct usb_device *m_dev;
+		struct usb_dev_handle *m_handle;
+		struct usb_device_descriptor m_descriptor;
+	};
+
+	/**
+	 * \brief Class representing a single bus on the machine
+	 *
+	 * This class is essentially a list of Device class instances
+	 */
+	class Bus : public std::list<Device *> {
+		/**
+		 * Busses is a friend because it fills in the directory name
+		 * information on initialisation and rescan.
+		 */
+		friend class Busses;
+	public:
+		Bus() {};
+		/**
+		 * \brief OS representation of directory name for this Bus
+		 *
+		 * libusb++ provides a uniform way of accessing USB
+		 * busses irrespective of the underlying Operation System
+		 * representation. If you want to map the libusb++ representation
+		 * to the Operating System representation, you can do this
+		 * with directory name().
+		 *
+		 * On Linux, the directoryname is usually something like 003, which
+		 * represents the third bus on the host.
+		 *
+		 * \see Directory::filename()
+		 */
+		std::string directoryName(void);
+	private:
+		std::list<Device *>::const_iterator iter;
+
+		void setDirectoryName(std::string);
+		std::string m_directoryName;
+	};
+
+	/**
+	 * \brief A vendor/product ID pair
+	 *
+	 * DeviceID provides a list of (vendor, product) identification
+	 * pairs. It is intended for use in a list of device numbers to
+	 * search for, but there is no reason why it couldn't be used for a
+	 * general purpose (vendor,product) tuple if you had some reason for
+	 * this.
+	 *
+	 * The description for Busses::match() provides an example of how
+	 * this class might be used.
+	 *
+	 * \see DeviceIDList, Busses::match()
+	 */
+	class DeviceID {
+	public:
+		DeviceID() {};
+		/** 
+		 * \brief Standard constructor
+		 *
+		 * This constructor takes (vendor, product) tuple, which are
+		 * stored away.
+		 *
+		 * \param vendor the 16 bit vendor number for the device
+		 * \param product the 16 bit product number for the device
+		 */
+		DeviceID(u_int16_t vendor, u_int16_t product);
+
+		/**
+		 * \brief vendor number for the device
+		 *
+		 * This method returns the 16 bit vendor number.
+		 */
+		u_int16_t vendor(void);
+
+		/**
+		 * \brief product number for the device
+		 *
+		 * This method returns the 16 bit product number.
+		 */
+		u_int16_t product(void);
+
+	private:
+		u_int16_t m_vendor;
+		u_int16_t m_product;
+	};
+
+	/**
+	 * \brief A list of vendor/product pairs
+	 *
+	 * DeviceIDList provides a list of DeviceID classes, which is
+	 * essentially a list of (vendor, product) identification pairs.
+	 *
+	 * \see DeviceID
+	 */
+	typedef std::list<DeviceID> DeviceIDList;
+
+	/**
+	 * \brief Class representing all the busses on the machine
+	 *
+	 * This class is essentially a list of Bus class instances
+	 */
+	class Busses : public std::list<Bus *> {
+	public:
+		Busses();
+
+		/** 
+		 * \brief Update method
+		 *
+		 * This method can be called to rescan the various devices
+		 * attached to the various busses. You should use it to
+		 * update if things change. Unfortunately there is no 
+		 * way to automatically detect this change in a portable way, 
+		 * so worst case is that you need to call this using some
+		 * kind of timer in the background.
+		 */
+		void rescan(void);
+
+		/**
+		 * \brief find all devices with matching device class designator
+		 *
+		 * This method searches every device on every bus, and returns a
+		 * list of pointers to the devices that have a matching device
+		 * class code
+		 */
+		std::list<Device *> match(u_int8_t Class);
+
+		/**
+		 * \brief find all devices with matching device IDs
+		 *
+		 * This method searches every device on every bus, and returns a
+		 * list of pointers to the devices that have a matching device
+		 * ID. That is, if the (vendor, product) tuple of a device matches
+		 * one of the tuples on the list, then the device will be added to
+		 * the list of matches.  
+		 *
+		 * An example of usage is shown below:
+		 * \code
+		 * USB::Busses buslist;
+		 * USB::Device *device;
+		 * std::list<USB::Device> miceFound;
+		 * USB::DeviceIDList mouseList;
+		 *
+		 * mouseList.append(USB::DeviceID(VENDOR_LOGITECH, 0xC00E)); // Wheel Mouse Optical
+		 * mouseList.append(USB::DeviceID(VENDOR_LOGITECH, 0xC012)); // MouseMan Dual Optical
+		 * mouseList.append(USB::DeviceID(VENDOR_LOGITECH, 0xC506)); // MX700 Optical Mouse
+		 *
+		 * miceFound = buslist.match(mouseList);
+		 *
+		 * for ( device = miceFound.first(); device; device = miceFound.next() ) {
+		 *     // do something with each mouse that matched
+		 * }
+		 * FIXME: This is incorrect now
+		 * \endcode
+		 */
+		std::list<Device *> match(DeviceIDList);
+
+	private:
+		std::list<Bus *>::const_iterator iter;
+	};
+  
+	class Error {
+	public:
+	private:
+	};
+
+}
+#endif /* __USBPP_HEADER__ */
+

logotool/Makefile

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

logotool/README

@@ -0,0 +1,17 @@
+Compressing/Uncompressing images
+================================
+
+To compress your image type:
+
+  $ gimp -> create an image and save as raw rgb (24 bits)
+  $ logotool -w 300 -h 200 -c MyImage.rgb
+
+This command will create MyImage.rgb.logo
+
+You can check if the image is fine typing:
+
+  $ logotool -u MyImage.rgb.logo
+
+To see the image you'll need mplayer and type this:
+
+  $ `logotool -u MyImage.rgb.logo`

logotool/compress.c

@@ -0,0 +1,145 @@
+/*
+ *  logotool - tool to modify logo images with simple compression
+ *  Copyright (C) 2007
+ *       pancake <pancake@youterm.com>
+ *       esteve <esteve@eslack.org>
+ *
+ *  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 <unistd.h>
+#include <string.h>
+#include <getopt.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+
+extern int rgba;
+
+int isbe()
+{
+	int a=1; char *b=(char *)&a;
+	return (int)b[0];
+}
+
+void ememcpy(char *dst, char *src)
+{
+	char buffer[4];
+	memcpy(buffer, src, 4);
+	dst[0] = buffer[3]; dst[1] = buffer[2];
+	dst[2] = buffer[1]; dst[3] = buffer[0];
+}
+
+int compress_image(char *srcf, char *dstf, int w, int h)
+{
+	char buf[256];
+	char tmp[256];
+	int fdout;
+	FILE *fd;
+	int i,ret;
+
+	fd = fopen(srcf, "rb");
+	if (fd == NULL) {
+		printf("Cannot open file '%s' \n", srcf);
+		return 1;
+	}
+
+	fdout  = open( dstf, O_TRUNC | O_CREAT | O_WRONLY , 0660 );
+	if (fdout == -1) {
+		printf("Cannot open file '%s' for writing\n", dstf);
+		return 1;
+	}
+
+	if (isbe()) {
+		char oop[4];
+		ememcpy((char *)&oop, (char *)&w);
+		write(fdout, &oop, 4);
+		ememcpy((char *)&oop, (char *)&h);
+		write(fdout, &oop, 4);
+	} else {
+		write(fdout, &w, 4);
+		write(fdout, &h, 4);
+	}
+
+	fseek(fd, 0, SEEK_END);
+	if (!rgba && ftell(fd)%3) {
+		fprintf(stderr, "Oops..looks like RGBA..forcing -a\n");
+		rgba = 1;
+	}
+	fseek(fd, 0, SEEK_SET);
+
+#define MAX 3*80
+	if (rgba) {
+		for(;;) {
+			unsigned char c;
+			ret = fread(&buf, 1, MAX, fd);
+			if (ret <= 0) break;
+			c = ret/4;
+			write(fdout,&c, 1);
+			for(i=0;i<ret;i+=4) {
+				tmp[0]  = buf[i+0]&0xf8;
+				tmp[0] |= buf[i+1]&0x07;
+				tmp[1]  = buf[i+1]&0xe0;
+				tmp[1] |= buf[i+2]&0x1f;
+				write(fdout, tmp, 2);
+			}
+		}
+	} else {
+		for(;;) {
+			unsigned char c;
+			ret = fread(buf, 1, MAX, fd);
+			if (ret <= 0) break;
+			c = ret/3;
+			write(fdout,&c, 1);
+			for(i=0;i<ret;i+=3) {
+				tmp[0]  = buf[i+0]&0xf8;
+				tmp[0] |= buf[i+1]&0x07;
+				tmp[1]  = buf[i+1]&0xe0;
+				tmp[1] |= buf[i+2]&0x1f;
+				write(fdout, tmp, 2);
+			}
+		}
+	}
+	fclose(fd);
+	close(fdout);
+	printf("eval PATH=$PWD:$PATH logotool -u %s\n", dstf);
+	return 1;
+}
+#if 0
+// TODO: compression stuff
+		/* is a repeated block? */
+		c = buf[0];
+		for(i=1;i<MAX&&buf[i]==c&&buf[i+1]==c;i+=2);
+printf("memcpy %d -> %d (ret %d)\n",i,ret-i, ret);
+for(i=0;i<ret-i;i++)
+printf(" %02x ", (unsigned char)buf[i]);
+printf("\n");
+		if (i>5) {
+//		if (i==MAX) {
+			if (0x80>ret) printf("PRON\n");
+			c = 0x80 | ret; //(int)((2*ret/3)>>1);
+			write(fdout,&c, 1);
+			tmp[0]  = buf[i+0]&0xf8;
+			tmp[0] |= buf[i+1]&0x07;
+			tmp[1]  = buf[i+1]&0xe0;
+			tmp[1] |= buf[i+1]&0x1f;
+			write(fdout, tmp, 2);
+			// restore state
+			memcpy(buf,buf+i,ret-i);
+			ret -= i;
+		}
+		
+#endif

logotool/logotool.c

@@ -0,0 +1,130 @@
+/*
+ *  logotool - tool to modify logo images with simple compression
+ *  Copyright (C) 2007
+ *       pancake <pancake@youterm.com>
+ *       esteve <esteve@eslack.org>
+ *
+ *  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 <unistd.h>
+#include <string.h>
+#include <getopt.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+
+#define VERSION "0.1"
+
+int uncompress_image(char *srcf, char *dstf);
+int compress_image(char *srcf, char *dstf, int w, int h);
+int rgb2yuv(char *from, char *to, int width, int height);
+int rgba = 0;
+
+static int show_usage()
+{
+	printf("Usage: logotool [-flags]\n");
+	printf("  -u [img]   uncompress image to img.rgb\n");
+	printf("  -c [img]   compres a 24 bit rgb raw image to a 16(565) one\n");
+	printf("  -m [img]   show image using mplayer (dumps to <img>.yuv)\n");
+	printf("  -v [img]   view uncompressed image using the 'display'\n");
+	printf("             command from ImageMagick (in monochrome)\n");
+	printf("  -w         specify width (required for -v and -c)\n");
+	printf("  -a         force RGBA instead of RGB when compressing (use with -c)\n");
+	printf("  -h         specify height (required for -v and -c)\n");
+	printf("  -V         version number\n");
+	printf("\n");
+	printf("Example:\n");
+	printf(" $ `logotool -u logo-file`   # uncompress and display a logo\n");
+	return 1;
+}
+
+int main ( int argc , char** argv )
+{	
+	int c;
+	int w=0,h=0;
+	char *mimg = NULL;
+	char *cimg = NULL;
+	char *uimg = NULL;
+	char *view = NULL;
+
+	while((c = getopt(argc, argv, "w:h:Vv:u:c:m:a")) != -1) {
+		switch(c) {
+		case 'V': printf("%s\n", VERSION); return 0;
+		case 'u': uimg = optarg; break;
+		case 'c': cimg = optarg; break;
+		case 'm': mimg = optarg; break;
+		case 'a': rgba = 1; break;
+		case 'w': w = atoi(optarg); break;
+		case 'h': h = atoi(optarg); break;
+		case 'v': view = optarg; break;
+		}
+	}
+
+	if (mimg) {
+		char *buf;
+		if (w==0||h==0) {
+			printf("You must specify width and height with '-w' and '-h'.\n");
+			return 1;
+		}
+
+		buf = (char *)malloc(strlen(mimg)+128);
+		sprintf(buf, "%s.rgb", mimg);
+
+		if ( rgb2yuv(mimg, buf, w,h ) ) {
+			sprintf(buf, "echo pause | mplayer %s.rgb -slave -demuxer rawvideo -rawvideo fps=1:w=%d:h=%d", mimg, w,h);
+			system(buf);
+		} else {
+			printf("Oops\n");
+		}
+		free(buf);
+	} else
+	if (view) {
+		char *buf;
+		
+		if (w==0||h==0) {
+			printf("You must specify width and height with '-w' and '-h'.\n");
+			return 1;
+		}
+		buf = (char *)malloc(strlen(view)+128);
+		sprintf(buf, "display -size %dx%d -depth 16 %s", w,h,view);
+		printf("%s\n", buf);
+		system(buf);
+		free(buf);
+	} else
+	if (uimg) {
+		char *dst = (char*)malloc(strlen(uimg)+5);
+		strcpy(dst, uimg);
+		strcat(dst, ".gray");
+		uncompress_image(uimg, dst);
+		free(dst);
+	} else
+	if (cimg) {
+		char *dst;
+		if (w==0||h==0) {
+			printf("You must specify width and height with '-w' and '-h'.\n");
+			return 1;
+		}
+		dst = (char*)malloc(strlen(cimg)+6);
+		strcpy(dst, cimg);
+		strcat(dst, ".logo");
+		compress_image(cimg, dst, w, h);
+		free(dst);
+	} else
+		show_usage();
+
+	return 0;
+}

logotool/rgb2yuv.c

@@ -0,0 +1,111 @@
+/*
+ *  logotool - tool to modify logo images with simple compression
+ *  Copyright (C) 2007
+ *       esteve <esteve@eslack.org>
+ *
+ *  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 <unistd.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+
+
+void RGBtoYUV(unsigned short in565, unsigned char *yuv)
+{
+	/* 2 bytes, 565 
+	 * RRRRR GGGGGG BBBBB
+	 */
+	
+	int i;
+	i = (in565>>8)&0xFF;
+	in565 = (in565<<8)&0xFF00;
+	in565 |= i;
+
+	int rgb[3];
+		
+	rgb[0] = (in565>>11)&0x1F;
+	rgb[1] = (in565>>5)&0x3F;
+	rgb[2] = (in565)&0x1F;
+	
+	rgb[0] = (rgb[0]<<3) | 0x7;
+	rgb[1] = (rgb[1]<<2) | 0x3;
+	rgb[2] = (rgb[2]<<3) | 0x7;
+
+	/*yuv[0] = 0.299*rgb[0] + 0.587*rgb[1] + 0.114*rgb[2];
+	yuv[1] = (rgb[2]-yuv[0])*0.565 + 128;
+	yuv[2] = (rgb[0]-yuv[0])*0.713 + 128;*/
+
+	yuv[0] = (0.257 * rgb[0]) + (0.504 * rgb[1]) + (0.098 * rgb[2]) + 16;
+	yuv[1] = 128 - (0.148 * rgb[0]) - (0.291 * rgb[1]) + (0.439 * rgb[2]);
+	yuv[2] = 128 + (0.439 * rgb[0]) - (0.368 * rgb[1]) - (0.071 * rgb[2]);
+}
+// mplayer caca.yuv -demuxer rawvideo  -rawvideo fps=1:w=416:h=70  //:i420
+
+
+int rgb2yuv(char *from, char *to, int width, int height)
+{	
+	int fd=open (from, O_RDONLY );
+	int fout= open ( to, O_CREAT| O_WRONLY , 0660 );
+	int fsize;
+	unsigned char* src;
+	unsigned char* dstY;
+	unsigned char* dstU;
+	unsigned char* dstV;
+	unsigned char YUV[3];
+	unsigned short inP;	
+	int i,j;
+
+	if (fd == -1) {
+		printf("cannot open %s\n", from);
+		return 0;
+	}
+	if (fout == -1) {
+		printf("cannot open %s\n", to);
+		return 0;
+	}
+	fsize = lseek ( fd, 0,SEEK_END);
+	fsize = lseek ( fd, 0,SEEK_CUR);
+	lseek ( fd,0, SEEK_SET);
+		
+	src=malloc ( fsize );
+	dstY=malloc ( (fsize/2) );
+	dstU=malloc ( (fsize/2) );
+	dstV=malloc ( (fsize/2) );
+
+	
+	for ( i = 0 ; i < fsize; i+=2 ) {
+		read ( fd, &inP, 2 );
+		RGBtoYUV ( inP, YUV );
+		dstY[i>>1]=YUV[0];
+		dstU[i>>1]=YUV[1];
+		dstV[i>>1]=YUV[2];
+	}
+
+	for ( i = 0 ; i < (fsize/2); i++ )
+		write ( fout,&dstY[i], 1);
+
+	for ( i = 0 ; i < height ; i+=2 )
+		for ( j = 0; j < width ; j +=2 )
+			write ( fout,&dstU[j+(i*width)], 1);
+
+	for ( i = 0 ; i < height ; i+=2 )
+		for ( j = 0; j < width ; j +=2 )
+			write ( fout,&dstV[j+(i*width)], 1);
+	return 1;
+}	

logotool/uncompress.c

@@ -0,0 +1,123 @@
+/*
+ *  logotool - tool to modify logo images with simple compression
+ *  Copyright (C) 2007
+ *       pancake <pancake@youterm.com>
+ *       esteve <esteve@eslack.org>
+ *
+ *  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 <unistd.h>
+#include <string.h>
+#include <getopt.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+
+int uncompress_image(char *srcf, char *dstf)
+{
+	int fd;
+	int fout;
+	int width,height;
+	int fsize;
+	char* src;
+	char* dst;
+	char* src2;
+	char* eof;
+	char *deof;
+	char* dst2 = NULL;
+	unsigned char byte;
+
+	fd    = open( srcf, O_RDONLY );
+
+	if (fd == -1) {
+		printf("Cannot open file '%s'\n", srcf);
+		return 1;
+	}
+
+	fout  = open( dstf, O_CREAT | O_WRONLY , 0660 );
+
+	if (fout == -1) {
+		printf("Cannot open file '%s' for writing\n", dstf);
+		return 1;
+	}
+
+	fprintf(stderr, "Input file: %s\n", srcf);
+	fprintf(stderr, "Output file: %s\n", dstf);
+	fsize = lseek ( fd, 0,SEEK_END);
+	fsize = lseek ( fd, 0,SEEK_CUR);
+	lseek ( fd,0, SEEK_SET);
+
+	fsize -= 8;
+
+	read ( fd, &width, 4 );
+	read ( fd, &height, 4 );
+
+	fprintf(stderr, "Width: %d\nHeight: %d\n",width, height);
+	fprintf(stderr, "Input Size: %d\n",fsize);
+	src = malloc ( fsize );
+	dst = malloc ( width*height*2 );
+	deof = dst+width*height*2;
+	if (src == (void *)-1 || dst == (void *)-1 ) {
+		printf("Cannot malloc\n");
+		return 1;
+	}
+
+	memset(dst,'\0', width*height*2);
+
+	read(fd, src, fsize);
+	eof = src+fsize;
+
+	for(dst2 = dst, src2 = src; src2<eof;) {
+		//byte = src2[0] & 0xff;
+		//src2 = src2 + 1;
+		byte=(*src2++)&0xff;
+		// [1xxxyyyy] [char] [char]
+		// copies xxxyyyy times two chars
+		if (byte > 0x7f) {
+			int i,j = byte&0x7f;
+			for(i=0; i++<j; dst2+=2) 
+				memcpy(dst2, src2, 2);
+			src2+=2;
+		} else {	
+			if ( byte != 0x00 ) {
+				byte<<=1;
+			//	fprintf(stderr, "COPYING: %d %d\n", byte, (eof-src2));
+				if ((dst2+byte >= deof || (src2+byte >= eof))) {
+					fprintf(stderr, "Break\n");
+					break;
+				} 
+				memcpy(dst2, src2, byte);
+				src2+=byte; dst2+=byte;
+			}
+		}
+	}
+	fprintf(stderr, "Output Size: %lld\n",(long long int)(dst2-dst));
+
+	if ((dst2-dst)!=(width*height*2))
+		fprintf(stderr, "failed?\n");
+
+	write ( fout, dst,  width*height*2);
+
+	close(fout);
+	close(fd);
+
+	//printf("./logotool -w %d -h %d -v %s || \n", width, height, dstf);
+	//printf("logotool -w %d -h %d -v %s\n", width, height, dstf);
+	printf("eval PATH=$PWD:$PATH logotool -w %d -h %d -m %s\n", width, height, dstf);
+
+	return 0;
+}

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,11 +1,19 @@
-VERSION=0.1
+include ../config.mk
-OBJ=main.o fiasco.o hexdump.o dump.o flash.o
-OBJ+=hash.o fpid.o query.o pieces.o utils.o
-BIN=0xFFFF
-CFLAGS+=-DVERSION=\"${VERSION}\" -Wall -g
 
-main: ${OBJ}
+CPPFLAGS += -DVERSION=\"$(VERSION)\" -D_GNU_SOURCE -I.
-	${CC} ${LDFLAGS} -o ${BIN} ${OBJ} -lusb
+CFLAGS += -W -Wall -O2 -pedantic -std=c99
+LIBS += -lm -lusb
+
+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
+
+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

@@ -0,0 +1,166 @@
+/*
+ *  0xFFFF - Open Free Fiasco Firmware Flasher
+ *  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
+ *  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 <getopt.h>
+#include <unistd.h>
+
+#include "global.h"
+#include "console.h"
+
+static void cmd_exit(char *line) {
+	exit(0);
+	(void)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");
+	printf("linfo             shows info of the local system\n");
+	printf("shell             opens a shell (/bin/sh)\n");
+	printf("badblocks [dev]   checks bad blocks on mtd (/dev/mtd1)\n");
+	printf("dump [dir]        dumps the contents of /dev/mtd to dir\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");
+	printf("exit              exits the shell\n");
+	fflush(stdout);
+	(void)line;
+}
+
+static void cmd_info(char *line) {
+	/* TODO */
+	(void)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",
+		(char *)&dev, (unsigned int*)&from, (unsigned int *)&length,
+		(char *)&out, (int*)&ignbb, (int *)&ignoob);
+
+	/* TODO */
+}
+
+static void cmd_dump(char *line) {
+
+	if ( ! line[0] ) {
+		printf("Usage: dump [path]\n");
+		return;
+	}
+
+	while ( line[0] == ' ' )
+		++line;
+
+	/* TODO */
+}
+
+static void cmd_badblocks(char *line) {
+
+	if ( ! line[0] ) {
+		printf("Usage: badblocks [path]\n");
+		return;
+	}
+
+	while ( line[0] == ' ' )
+		++line;
+
+	/* TODO */
+}
+
+static void cmd_connect(char *line) {
+	/* TODO */
+	(void)line;
+}
+
+static void cmd_reboot(char *line) {
+	/* TODO */
+	(void)line;
+}
+
+static void cmd_shell(char *line) {
+	system("/bin/sh");
+	(void)line;
+}
+
+static struct cmd_t {
+	char *name;
+	void (*callback)(char *);
+} console_commands[] = {
+	{ .name = "exit",      .callback = &cmd_exit },
+	{ .name = "q",         .callback = &cmd_exit },
+	{ .name = "connect",   .callback = &cmd_connect },
+	{ .name = "reboot",    .callback = &cmd_reboot },
+	{ .name = "badblocks", .callback = &cmd_badblocks},
+	{ .name = "help",      .callback = &cmd_help },
+	{ .name = "?",         .callback = &cmd_help },
+	{ .name = "info",      .callback = &cmd_info },
+	{ .name = "dump",      .callback = &cmd_dump },
+	{ .name = "nanddump",  .callback = &cmd_nanddump },
+	{ .name = "shell",     .callback = &cmd_shell }
+};
+
+static int console_command(char *line) {
+
+	size_t i;
+	char command[11];
+
+	command[0] = '\0';
+	sscanf(line, "%10s", command);
+	line = line + strlen(command);
+
+	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(void) {
+
+	char line[1024];
+
+	do {
+		write(1, "0xFFFF> ", 8);
+		line[0] = '\0';
+		fgets(line, 1024, stdin);
+
+		if ( feof(stdin) ) {
+			write(1, "\n", 1);
+			break;
+		}
+
+		if ( line[0] )
+			line[strlen(line)-1] = '\0';
+		line[1023] = '\0';
+	} while ( console_command(line) );
+
+	return 0;
+
+}

src/console.h

@@ -0,0 +1,25 @@
+/*
+ *  0xFFFF - Open Free Fiasco Firmware Flasher
+ *  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
+ *  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 CONSOLE_H
+#define CONSOLE_H
+
+int console_prompt(void);
+
+#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/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,145 +0,0 @@
-/*
- * Copyright (C) 2007
- *       pancake <pancake@youterm.com>
- *
- * 0xFFFF is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; either version 2 of the License, or
- * (at your option) any later version.
- *
- * 0xFFFF 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 0xFFFF; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
- *
- */
-
-#include "main.h"
-#include <usb.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-
-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("%s: extracting...", file);
-	fflush(stdout);
-	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);
-		if (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;
-}
-
-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);
-
-	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 reverse_extract_pieces(char *dir)
-{
-	char reply;
-	chdir(dir);
-
-	rf_extract("/dev/mtd0", is_n800()?0x200:0, 0x003600, "xloader.bin");
-	rf_extract("/dev/mtd0", 0x004000, 0x01ffff,  "secondary.bin");
-	rf_extract("/dev/mtd2", 0x000800, 0x200000,  "zImage");
-	rf_extract("/dev/mtd3", 0x000000, 0x1D00000, "initfs.jffs2");
-	printf("\nWARNING: the rootfs extraction on n800 is known to be buggy! feedback is welcome.\n\n");
-	printf("Extract rootfs? (Y/n): "); fflush(stdout);
-	read(0, &reply, 1);
-	if (reply=='y'||reply=='Y')
-		rf_extract("/dev/mtd4", 0x000000, 0xffffff, "rootfs.jffs2");
-	else	printf("*** Ignoring rootfs\n");
-	rf_strip("xloader.bin");
-	rf_strip("secondary.bin");
-	rf_strip("zImage");
-	rf_strip("initfs.jffs2");
-	printf("Identifying extracted files...\n");
-	printf("%s: xloader\n", fpid_file("xloader.bin"));
-	printf("%s: secondary.bin\n", fpid_file("secondary.bin"));
-	printf("%s: zImage\n", fpid_file("zImage"));
-	printf("%s: initfs.jffs2\n", fpid_file("initfs.jffs2"));
-
-	return 1;
-}

src/fiasco.c

@@ -1,136 +1,572 @@
 /*
- * Copyright (C) 2007
+    0xFFFF - Open Free Fiasco Firmware Flasher
- *       pancake <pancake@youterm.com>
+    Copyright (C) 2007-2011  pancake <pancake@youterm.com>
- *
+    Copyright (C) 2011-2012  Pali Rohár <pali.rohar@gmail.com>
- * 0xFFFF is free software; you can redistribute it and/or modify
+
- * it under the terms of the GNU General Public License as published by
+    This program is free software: you can redistribute it and/or modify
- * the Free Software Foundation; either version 2 of the License, or
+    it under the terms of the GNU General Public License as published by
- * (at your option) any later version.
+    the Free Software Foundation, either version 3 of the License, or
- *
+    (at your option) any later version.
- * 0xFFFF is distributed in the hope that it will be useful,
+
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
+    This program is distributed in the hope that it will be useful,
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
- * GNU General Public License for more details.
+    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 0xFFFF; if not, write to the Free Software
+    You should have received a copy of the GNU General Public License
- * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+    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 <unistd.h>
+#include <string.h>
+
 #include <sys/types.h>
 #include <sys/stat.h>
+#include <arpa/inet.h>
 #include <fcntl.h>
+#include <unistd.h>
 
-#warning The FIASCO format is not yet fully implemented.
+#include "global.h"
+
+#include "device.h"
+#include "image.h"
+#include "fiasco.h"
+
+#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;
 
-off_t piece_header_to_size(unsigned char *header)
-{
-	off_t sz = 0;
-	sz += header[0x15+3];
-	sz += header[0x15+2] << 8;
-	sz += header[0x15+1] << 16;
-	sz += header[0x15+0] << 24;
-	return sz;
 }
 
-int piece_header_is_valid(unsigned char *header)
+struct fiasco * fiasco_alloc_from_file(const char * file) {
-{
+
-	if (header[0]=='T' && header[1]=='\x02')
+	uint8_t byte;
-		return 1;
+	uint32_t length;
-	return 0;
+	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;
+	}
+
+	fiasco->orig_filename = strdup(file);
+
+	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 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;
+		}
+
+		count8 = buf[1];
+		if ( count8 > 0 )
+			--count8;
+
+		READ_OR_RETURN(fiasco, &hash, 2);
+		hash = ntohs(hash);
+
+		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;
+		}
+
+		/* 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;
+
 }
 
-#define piece_header_to_name(x) x+0x9;
+void fiasco_free(struct fiasco * fiasco) {
 
-/*
+	struct image_list * list = fiasco->first;
- * Teh Fiasco firmware parser lives here!
- */
-int fiasco_read_image(char *file)
-{
-	int fd;
-	unsigned char header[5];
-	unsigned char version[55];
-	char *version2;
 
-	fd = open(file, O_RDONLY);
+	while ( list ) {
+		struct image_list * next = list->next;
+		image_list_del(list);
+		list = next;
+	}
 
-	printf("WARNING: Fiasco firmware is not yet fully supported. Don't relay on it ATM.\n");
+	if ( fiasco->fd >= 0 )
+		close(fiasco->fd);
 
-	if (fd == -1) {
+	free(fiasco->orig_filename);
-		printf("Cannot open fiasco image.\n");
+
+	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;
-	}
 
-	// b4 00 00 00 00 36
+	printf("Generating Fiasco image %s...\n", file);
-	if (read(fd, header, 5) != 5) {
-		printf("Error reading fiasco header\n");
-		goto __fiasco_read_image_end;
-	}
 
-	if (header[0] != 0xb4) {
+	if ( ! fiasco->first )
-		printf("Invalid fiasco signature.\n");
+		FIASCO_WRITE_ERROR(file, fd, "Nothing to write");
-		goto __fiasco_read_image_end;
-	}
-	// skip 6 bytes
-	read(fd, version, 6);
 
-	// print version header
+	if ( fiasco->name && strlen(fiasco->name)+1 > UINT8_MAX )
-	if (read(fd, version, 55) != 55) {
+		FIASCO_WRITE_ERROR(file, fd, "Fiasco name string is too long");
-		printf("Error reading fiasco version.\n");
-		goto __fiasco_read_image_end;
-	}
 
-	printf("# Fiasco header information:\n");
+	if ( fiasco->swver && strlen(fiasco->swver)+1 > UINT8_MAX )
-	printf("# ==========================\n");
+		FIASCO_WRITE_ERROR(file, fd, "SW version string is too long");
-	printf("# firmware type:    %s\n", version);
-	version2 = version+strlen((char *)version)+3;
-	if (*version2=='.')
-		printf("firmware version: (null) (old firmware? no version string found?)\n");
-	else printf("firmware version: %s\n", version2);
 
-	// pieces:
+	if ( ! simulate ) {
-	// after the version2 string starts the header-body loop love
+		fd = open(file, O_RDWR|O_CREAT|O_TRUNC, 0644);
-	lseek(fd, 0xf + strlen(version2) + strlen(version), SEEK_SET);
+		if ( fd < 0 ) {
-	do {
+			ERROR_INFO("Cannot create file");
-		char piece_header[30];
+			return -1;
-		char description[256];
-		unsigned char desc_len;
-		char *name;
-		off_t size;
-		off_t tmp = lseek(fd, 0, SEEK_CUR);
-
-		size = read(fd, piece_header, 30);
-		if (size != 30) {
-			fprintf(stderr, "Unexpected end of file\n");
-			break;
 		}
-		dump_bytes(piece_header,30);
+	}
-		if (!piece_header_is_valid(piece_header)) {
+
-			fprintf(stderr, "Oops. Invalid piece header.\n");
+	printf("Writing Fiasco header...\n");
-			break;
+
+	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);
 		}
-		size = piece_header_to_size(piece_header);
-		name = piece_header_to_name(piece_header);
-		printf("# %s is %lld bytes\n", name, size);
 
-		read(fd, description, 255);
+		/* append device & hwrevs subsection */
-		printf("#   version: %s\n", description);
+		for ( i = 0; i < device_count; ++i ) {
-		/* lseek foreach subimage */
+			WRITE_OR_FAIL(file, fd, "2", 1); /* 2 - device & hwrevs */
-		lseek(fd, tmp, SEEK_SET);
+			WRITE_OR_FAIL(file, fd, &device_hwrevs_bufs[i][0], 1);
-		lseek(fd, strlen(description) + 0x20, SEEK_CUR);
+			WRITE_OR_FAIL(file, fd, device_hwrevs_bufs[i]+1, ((uint8_t *)(device_hwrevs_bufs[i]))[0]);
-		printf("rsc '%s' %lld '%s.bin' 0 %lld\n", file, lseek(fd,0,SEEK_CUR), name, size);
+		}
-		lseek(fd, size, SEEK_CUR);
+		free(device_hwrevs_bufs);
-	} while(1);
 
-	//printf("Image '%s', size %d bytes.\n", image, size);
+		/* 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");
+
+	}
 
-__fiasco_read_image_end:
 	close(fd);
+	printf("\nDone\n\n");
 	return 0;
+
+}
+
+int fiasco_unpack(struct fiasco * fiasco, const char * dir) {
+
+	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];
+
+	if ( dir ) {
+
+		memset(cwd, 0, sizeof(cwd));
+
+		if ( ! getcwd(cwd, sizeof(cwd)) ) {
+			ERROR_INFO("Cannot store current directory");
+			return -1;
+		}
+
+		if ( chdir(dir) < 0 ) {
+			ERROR_INFO("Cannot change current directory to %s", dir);
+			return -1;
+		}
+
+	}
+
+	fiasco_print_info(fiasco);
+
+	image_list = fiasco->first;
+
+	while ( image_list ) {
+
+		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));
+
+			close(fd);
+
+		}
+
+		image_list = image_list->next;
+
+	}
+
+	if ( dir ) {
+		if ( chdir(cwd) < 0 ) {
+			ERROR_INFO("Cannot change current directory back to %s", cwd);
+			return -1;
+		}
+	}
+
+	printf("\nDone\n\n");
+	return 0;
+
+}
+
+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);
+
 }

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,167 +0,0 @@
-/*
- * Copyright (C) 2007
- *       pancake <pancake@youterm.com>
- *
- * 0xFFFF is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; either version 2 of the License, or
- * (at your option) any later version.
- *
- * 0xFFFF 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 0xFFFF; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
- *
- */
-
-#include "main.h"
-#include "hash.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 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) {
-		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);
-		progressbar(off, size);
-		if (bread<0) perror(" -ee- ");
-		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,75 +0,0 @@
-/*
- * Copyright (C) 2007
- *       pancake <pancake@youterm.com>
- *
- * 0xFFFF is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; either version 2 of the License, or
- * (at your option) any later version.
- *
- * 0xFFFF 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 0xFFFF; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
- *
- */
-
-#include "main.h"
-#include <stdio.h>
-#include <string.h>
-
-char *fpid_file(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 0
-	if (!memcmp(b+0x34, "2NDAPE", 6))
-		return PIECE_2ND;
-	else
-#endif
-	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
-	if (!memcmp(b+0x00, "\x85\x19\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.c

@@ -1,62 +0,0 @@
-/*
- * Copyright (C) 2007
- *       pancake <pancake@youterm.com>
- *
- * 0xFFFF is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; either version 2 of the License, or
- * (at your option) any later version.
- *
- * 0xFFFF 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 0xFFFF; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
- *
- */
-
-#include <stdio.h>
-#include "hash.h"
-
-usho do_hash(usho *b, int len)
-{
-	usho result = 0;
-	for(len>>=1;len--;b=b+1)
-		result^=b[0];
-	return result;
-}
-
-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/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,67 +0,0 @@
-/*
- * Copyright (C) 2006-2007
- *       pancake <pancake@youterm.com>
- *
- * radare is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; either version 2 of the License, or
- * (at your option) any later version.
- *
- * radare 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 radare; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
- *
- */
-
-#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,60 +0,0 @@
-#ifndef _INCLUDE_MAIN_H_
-#define _INCLUDE_MAIN_H_
-
-#define _FILE_OFFSET_BITS 64
-#define _GNU_SOURCE
-
-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);
-int get_status();
-int get_peripheral_host_mode(int foo);
-int boot_board(char *cmdline);
-int boot_board(char *cmdline);
-int reboot_board();
-char *fpid_file(char *filename);
-int set_rd_mode(unsigned short mode);
-int set_usb_host_mode(unsigned short mode);
-int query_hw_revision();
-int query_rdmode_device();
-int query_root_device();
-int query_nolo_version();
-int add_piece(char *piece);
-
-#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;
-};
-
-extern int pcs_n;
-extern struct piece_t pcs[10];
-
-enum {
-	PIECE_XLOADER = 0,
-	PIECE_SECONDARY,
-	PIECE_KERNEL,
-	PIECE_INITFS,
-	PIECE_ROOTFS,
-	PIECE_OMAPNAND,
-	PIECE_LAST
-};
-
-extern char *pieces[];
-extern char *modes[];
-extern char *root_devices[];
-
-#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/mtd/ftl-user.h

@@ -0,0 +1,76 @@
+/*
+ * $Id: ftl.h,v 1.7 2005/11/07 11:14:54 gleixner Exp $
+ *
+ * Derived from (and probably identical to):
+ * ftl.h 1.7 1999/10/25 20:23:17
+ *
+ * The contents of this file are subject to the Mozilla Public License
+ * Version 1.1 (the "License"); you may not use this file except in
+ * compliance with the License. You may obtain a copy of the License
+ * at http://www.mozilla.org/MPL/
+ *
+ * Software distributed under the License is distributed on an "AS IS"
+ * basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
+ * the License for the specific language governing rights and
+ * limitations under the License.
+ *
+ * The initial developer of the original code is David A. Hinds
+ * <dahinds@users.sourceforge.net>.  Portions created by David A. Hinds
+ * are Copyright (C) 1999 David A. Hinds.  All Rights Reserved.
+ *
+ * Alternatively, the contents of this file may be used under the
+ * terms of the GNU General Public License version 2 (the "GPL"), in
+ * which case the provisions of the GPL are applicable instead of the
+ * above.  If you wish to allow the use of your version of this file
+ * only under the terms of the GPL and not to allow others to use
+ * your version of this file under the MPL, indicate your decision by
+ * deleting the provisions above and replace them with the notice and
+ * other provisions required by the GPL.  If you do not delete the
+ * provisions above, a recipient may use your version of this file
+ * under either the MPL or the GPL.
+ */
+
+#ifndef __MTD_FTL_USER_H__
+#define __MTD_FTL_USER_H__
+
+typedef struct erase_unit_header_t {
+    u_int8_t	LinkTargetTuple[5];
+    u_int8_t	DataOrgTuple[10];
+    u_int8_t	NumTransferUnits;
+    u_int32_t	EraseCount;
+    u_int16_t	LogicalEUN;
+    u_int8_t	BlockSize;
+    u_int8_t	EraseUnitSize;
+    u_int16_t	FirstPhysicalEUN;
+    u_int16_t	NumEraseUnits;
+    u_int32_t	FormattedSize;
+    u_int32_t	FirstVMAddress;
+    u_int16_t	NumVMPages;
+    u_int8_t	Flags;
+    u_int8_t	Code;
+    u_int32_t	SerialNumber;
+    u_int32_t	AltEUHOffset;
+    u_int32_t	BAMOffset;
+    u_int8_t	Reserved[12];
+    u_int8_t	EndTuple[2];
+} erase_unit_header_t;
+
+/* Flags in erase_unit_header_t */
+#define HIDDEN_AREA		0x01
+#define REVERSE_POLARITY	0x02
+#define DOUBLE_BAI		0x04
+
+/* Definitions for block allocation information */
+
+#define BLOCK_FREE(b)		((b) == 0xffffffff)
+#define BLOCK_DELETED(b)	(((b) == 0) || ((b) == 0xfffffffe))
+
+#define BLOCK_TYPE(b)		((b) & 0x7f)
+#define BLOCK_ADDRESS(b)	((b) & ~0x7f)
+#define BLOCK_NUMBER(b)		((b) >> 9)
+#define BLOCK_CONTROL		0x30
+#define BLOCK_DATA		0x40
+#define BLOCK_REPLACEMENT	0x60
+#define BLOCK_BAD		0x70
+
+#endif /* __MTD_FTL_USER_H__ */

src/mtd/inftl-user.h

@@ -0,0 +1,91 @@
+/*
+ * $Id: inftl-user.h,v 1.2 2005/11/07 11:14:56 gleixner Exp $
+ *
+ * Parts of INFTL headers shared with userspace
+ *
+ */
+
+#ifndef __MTD_INFTL_USER_H__
+#define __MTD_INFTL_USER_H__
+
+#define	OSAK_VERSION	0x5120
+#define	PERCENTUSED	98
+
+#define	SECTORSIZE	512
+
+/* Block Control Information */
+
+struct inftl_bci {
+	uint8_t ECCsig[6];
+	uint8_t Status;
+	uint8_t Status1;
+} __attribute__((packed));
+
+struct inftl_unithead1 {
+	uint16_t virtualUnitNo;
+	uint16_t prevUnitNo;
+	uint8_t ANAC;
+	uint8_t NACs;
+	uint8_t parityPerField;
+	uint8_t discarded;
+} __attribute__((packed));
+
+struct inftl_unithead2 {
+	uint8_t parityPerField;
+	uint8_t ANAC;
+	uint16_t prevUnitNo;
+	uint16_t virtualUnitNo;
+	uint8_t NACs;
+	uint8_t discarded;
+} __attribute__((packed));
+
+struct inftl_unittail {
+	uint8_t Reserved[4];
+	uint16_t EraseMark;
+	uint16_t EraseMark1;
+} __attribute__((packed));
+
+union inftl_uci {
+	struct inftl_unithead1 a;
+	struct inftl_unithead2 b;
+	struct inftl_unittail c;
+};
+
+struct inftl_oob {
+	struct inftl_bci b;
+	union inftl_uci u;
+};
+
+
+/* INFTL Media Header */
+
+struct INFTLPartition {
+	__u32 virtualUnits;
+	__u32 firstUnit;
+	__u32 lastUnit;
+	__u32 flags;
+	__u32 spareUnits;
+	__u32 Reserved0;
+	__u32 Reserved1;
+} __attribute__((packed));
+
+struct INFTLMediaHeader {
+	char bootRecordID[8];
+	__u32 NoOfBootImageBlocks;
+	__u32 NoOfBinaryPartitions;
+	__u32 NoOfBDTLPartitions;
+	__u32 BlockMultiplierBits;
+	__u32 FormatFlags;
+	__u32 OsakVersion;
+	__u32 PercentUsed;
+	struct INFTLPartition Partitions[4];
+} __attribute__((packed));
+
+/* Partition flag types */
+#define	INFTL_BINARY	0x20000000
+#define	INFTL_BDTL	0x40000000
+#define	INFTL_LAST	0x80000000
+
+#endif /* __MTD_INFTL_USER_H__ */
+
+

src/mtd/jffs2-user.h

@@ -0,0 +1,82 @@
+/*
+ * $Id: jffs2-user.h,v 1.1 2004/05/05 11:57:54 dwmw2 Exp $
+ *
+ * JFFS2 definitions for use in user space only
+ */
+
+#ifndef __JFFS2_USER_H__
+#define __JFFS2_USER_H__
+
+/* This file is blessed for inclusion by userspace */
+#include <linux/jffs2.h>
+#include <endian.h>
+#include <byteswap.h>
+
+#undef cpu_to_je16
+#undef cpu_to_je32
+#undef cpu_to_jemode
+#undef je16_to_cpu
+#undef je32_to_cpu
+#undef jemode_to_cpu
+
+extern int target_endian;
+
+#define t16(x) ({ uint16_t __b = (x); (target_endian==__BYTE_ORDER)?__b:bswap_16(__b); })
+#define t32(x) ({ uint32_t __b = (x); (target_endian==__BYTE_ORDER)?__b:bswap_32(__b); })
+
+#define cpu_to_je16(x) ((jint16_t){t16(x)})
+#define cpu_to_je32(x) ((jint32_t){t32(x)})
+#define cpu_to_jemode(x) ((jmode_t){t32(x)})
+
+#define je16_to_cpu(x) (t16((x).v16))
+#define je32_to_cpu(x) (t32((x).v32))
+#define jemode_to_cpu(x) (t32((x).m))
+
+#define le16_to_cpu(x)	(__BYTE_ORDER==__LITTLE_ENDIAN ? (x) : bswap_16(x))
+#define le32_to_cpu(x)	(__BYTE_ORDER==__LITTLE_ENDIAN ? (x) : bswap_32(x))
+#define cpu_to_le16(x)	(__BYTE_ORDER==__LITTLE_ENDIAN ? (x) : bswap_16(x))
+#define cpu_to_le32(x)	(__BYTE_ORDER==__LITTLE_ENDIAN ? (x) : bswap_32(x))
+
+/* XATTR/POSIX-ACL related definition */
+/* Namespaces copied from xattr.h and posix_acl_xattr.h */
+#define XATTR_USER_PREFIX		"user."
+#define XATTR_USER_PREFIX_LEN		(sizeof (XATTR_USER_PREFIX) - 1)
+#define XATTR_SECURITY_PREFIX		"security."
+#define XATTR_SECURITY_PREFIX_LEN	(sizeof (XATTR_SECURITY_PREFIX) - 1)
+#define POSIX_ACL_XATTR_ACCESS		"system.posix_acl_access"
+#define POSIX_ACL_XATTR_ACCESS_LEN	(sizeof (POSIX_ACL_XATTR_ACCESS) - 1)
+#define POSIX_ACL_XATTR_DEFAULT		"system.posix_acl_default"
+#define POSIX_ACL_XATTR_DEFAULT_LEN	(sizeof (POSIX_ACL_XATTR_DEFAULT) - 1)
+#define XATTR_TRUSTED_PREFIX		"trusted."
+#define XATTR_TRUSTED_PREFIX_LEN	(sizeof (XATTR_TRUSTED_PREFIX) - 1)
+
+struct jffs2_acl_entry {
+	jint16_t	e_tag;
+	jint16_t	e_perm;
+	jint32_t	e_id;
+};
+
+struct jffs2_acl_entry_short {
+	jint16_t	e_tag;
+	jint16_t	e_perm;
+};
+
+struct jffs2_acl_header {
+	jint32_t	a_version;
+};
+
+/* copied from include/linux/posix_acl_xattr.h */
+#define POSIX_ACL_XATTR_VERSION 0x0002
+
+struct posix_acl_xattr_entry {
+	uint16_t		e_tag;
+	uint16_t		e_perm;
+	uint32_t		e_id;
+};
+
+struct posix_acl_xattr_header {
+	uint32_t			a_version;
+	struct posix_acl_xattr_entry	a_entries[0];
+};
+
+#endif /* __JFFS2_USER_H__ */

src/mtd/mtd-abi.h

@@ -0,0 +1,158 @@
+/*
+ * $Id: mtd-abi.h,v 1.13 2005/11/07 11:14:56 gleixner Exp $
+ *
+ * Portions of MTD ABI definition which are shared by kernel and user space
+ */
+
+#ifndef __MTD_ABI_H__
+#define __MTD_ABI_H__
+
+#ifndef __KERNEL__ /* Urgh. The whole point of splitting this out into
+		    separate files was to avoid #ifdef __KERNEL__ */
+#define __user
+#endif
+
+struct erase_info_user {
+	uint32_t start;
+	uint32_t length;
+};
+
+struct mtd_oob_buf {
+	uint32_t start;
+	uint32_t length;
+	unsigned char __user *ptr;
+};
+
+#define MTD_ABSENT		0
+#define MTD_NORFLASH		3
+#define MTD_NANDFLASH		4
+#define MTD_DATAFLASH		6
+#define MTD_GENERIC_TYPE	7
+
+#define MTD_WRITEABLE		0x400	/* Device is writeable */
+#define MTD_BIT_WRITEABLE	0x800	/* Single bits can be flipped */
+#define MTD_NO_ERASE		0x1000	/* No erase necessary */
+
+// Some common devices / combinations of capabilities
+#define MTD_CAP_ROM		0
+#define MTD_CAP_RAM		(MTD_WRITEABLE | MTD_BIT_WRITEABLE | MTD_NO_ERASE)
+#define MTD_CAP_NORFLASH	(MTD_WRITEABLE | MTD_BIT_WRITEABLE)
+#define MTD_CAP_NANDFLASH	(MTD_WRITEABLE)
+
+
+// Types of automatic ECC/Checksum available
+#define MTD_ECC_NONE		0 	// No automatic ECC available
+#define MTD_ECC_RS_DiskOnChip	1	// Automatic ECC on DiskOnChip
+#define MTD_ECC_SW		2	// SW ECC for Toshiba & Samsung devices
+
+/* ECC byte placement */
+#define MTD_NANDECC_OFF		0	// Switch off ECC (Not recommended)
+#define MTD_NANDECC_PLACE	1	// Use the given placement in the structure (YAFFS1 legacy mode)
+#define MTD_NANDECC_AUTOPLACE	2	// Use the default placement scheme
+#define MTD_NANDECC_PLACEONLY	3	// Use the given placement in the structure (Do not store ecc result on read)
+#define MTD_NANDECC_AUTOPL_USR 	4	// Use the given autoplacement scheme rather than using the default
+
+/* OTP mode selection */
+#define MTD_OTP_OFF		0
+#define MTD_OTP_FACTORY		1
+#define MTD_OTP_USER		2
+
+struct mtd_info_user {
+	uint8_t type;
+	uint32_t flags;
+	uint32_t size;	 // Total size of the MTD
+	uint32_t erasesize;
+	uint32_t writesize;
+	uint32_t oobsize;   // Amount of OOB data per block (e.g. 16)
+	uint32_t ecctype;
+	uint32_t eccsize;
+};
+
+struct region_info_user {
+	uint32_t offset;		/* At which this region starts,
+					 * from the beginning of the MTD */
+	uint32_t erasesize;		/* For this region */
+	uint32_t numblocks;		/* Number of blocks in this region */
+	uint32_t regionindex;
+};
+
+struct otp_info {
+	uint32_t start;
+	uint32_t length;
+	uint32_t locked;
+};
+
+#define MEMGETINFO		_IOR('M', 1, struct mtd_info_user)
+#define MEMERASE		_IOW('M', 2, struct erase_info_user)
+#define MEMWRITEOOB		_IOWR('M', 3, struct mtd_oob_buf)
+#define MEMREADOOB		_IOWR('M', 4, struct mtd_oob_buf)
+#define MEMLOCK			_IOW('M', 5, struct erase_info_user)
+#define MEMUNLOCK		_IOW('M', 6, struct erase_info_user)
+#define MEMGETREGIONCOUNT	_IOR('M', 7, int)
+#define MEMGETREGIONINFO	_IOWR('M', 8, struct region_info_user)
+#define MEMSETOOBSEL		_IOW('M', 9, struct nand_oobinfo)
+#define MEMGETOOBSEL		_IOR('M', 10, struct nand_oobinfo)
+#define MEMGETBADBLOCK		_IOW('M', 11, loff_t)
+#define MEMSETBADBLOCK		_IOW('M', 12, loff_t)
+#define OTPSELECT		_IOR('M', 13, int)
+#define OTPGETREGIONCOUNT	_IOW('M', 14, int)
+#define OTPGETREGIONINFO	_IOW('M', 15, struct otp_info)
+#define OTPLOCK			_IOR('M', 16, struct otp_info)
+#define ECCGETLAYOUT		_IOR('M', 17, struct nand_ecclayout)
+#define ECCGETSTATS		_IOR('M', 18, struct mtd_ecc_stats)
+#define MTDFILEMODE		_IO('M', 19)
+
+/*
+ * Obsolete legacy interface. Keep it in order not to break userspace
+ * interfaces
+ */
+struct nand_oobinfo {
+	uint32_t useecc;
+	uint32_t eccbytes;
+	uint32_t oobfree[8][2];
+	uint32_t eccpos[32];
+};
+
+struct nand_oobfree {
+	uint32_t offset;
+	uint32_t length;
+};
+
+#define MTD_MAX_OOBFREE_ENTRIES	8
+/*
+ * ECC layout control structure. Exported to userspace for
+ * diagnosis and to allow creation of raw images
+ */
+struct nand_ecclayout {
+	uint32_t eccbytes;
+	uint32_t eccpos[64];
+	uint32_t oobavail;
+	struct nand_oobfree oobfree[MTD_MAX_OOBFREE_ENTRIES];
+};
+
+/**
+ * struct mtd_ecc_stats - error correction status
+ *
+ * @corrected:	number of corrected bits
+ * @failed:	number of uncorrectable errors
+ * @badblocks:	number of bad blocks in this partition
+ * @bbtblocks:	number of blocks reserved for bad block tables
+ */
+struct mtd_ecc_stats {
+	uint32_t corrected;
+	uint32_t failed;
+	uint32_t badblocks;
+	uint32_t bbtblocks;
+};
+
+/*
+ * Read/write file modes for access to MTD
+ */
+enum mtd_file_modes {
+	MTD_MODE_NORMAL = MTD_OTP_OFF,
+	MTD_MODE_OTP_FACTORY = MTD_OTP_FACTORY,
+	MTD_MODE_OTP_USER = MTD_OTP_USER,
+	MTD_MODE_RAW,
+};
+
+#endif /* __MTD_ABI_H__ */

src/mtd/mtd-user.h

@@ -0,0 +1,21 @@
+/*
+ * $Id: mtd-user.h,v 1.2 2004/05/05 14:44:57 dwmw2 Exp $
+ *
+ * MTD ABI header for use by user space only.
+ */
+
+#ifndef __MTD_USER_H__
+#define __MTD_USER_H__
+
+#include <stdint.h>
+
+/* This file is blessed for inclusion by userspace */
+#include <mtd/mtd-abi.h>
+
+typedef struct mtd_info_user mtd_info_t;
+typedef struct erase_info_user erase_info_t;
+typedef struct region_info_user region_info_t;
+typedef struct nand_oobinfo nand_oobinfo_t;
+typedef struct nand_ecclayout nand_ecclayout_t;
+
+#endif /* __MTD_USER_H__ */

src/mtd/nftl-user.h

@@ -0,0 +1,76 @@
+/*
+ * $Id: nftl-user.h,v 1.2 2005/11/07 11:14:56 gleixner Exp $
+ *
+ * Parts of NFTL headers shared with userspace
+ *
+ */
+
+#ifndef __MTD_NFTL_USER_H__
+#define __MTD_NFTL_USER_H__
+
+/* Block Control Information */
+
+struct nftl_bci {
+	unsigned char ECCSig[6];
+	uint8_t Status;
+	uint8_t Status1;
+}__attribute__((packed));
+
+/* Unit Control Information */
+
+struct nftl_uci0 {
+	uint16_t VirtUnitNum;
+	uint16_t ReplUnitNum;
+	uint16_t SpareVirtUnitNum;
+	uint16_t SpareReplUnitNum;
+} __attribute__((packed));
+
+struct nftl_uci1 {
+	uint32_t WearInfo;
+	uint16_t EraseMark;
+	uint16_t EraseMark1;
+} __attribute__((packed));
+
+struct nftl_uci2 {
+        uint16_t FoldMark;
+        uint16_t FoldMark1;
+	uint32_t unused;
+} __attribute__((packed));
+
+union nftl_uci {
+	struct nftl_uci0 a;
+	struct nftl_uci1 b;
+	struct nftl_uci2 c;
+};
+
+struct nftl_oob {
+	struct nftl_bci b;
+	union nftl_uci u;
+};
+
+/* NFTL Media Header */
+
+struct NFTLMediaHeader {
+	char DataOrgID[6];
+	uint16_t NumEraseUnits;
+	uint16_t FirstPhysicalEUN;
+	uint32_t FormattedSize;
+	unsigned char UnitSizeFactor;
+} __attribute__((packed));
+
+#define MAX_ERASE_ZONES (8192 - 512)
+
+#define ERASE_MARK 0x3c69
+#define SECTOR_FREE 0xff
+#define SECTOR_USED 0x55
+#define SECTOR_IGNORE 0x11
+#define SECTOR_DELETED 0x00
+
+#define FOLD_MARK_IN_PROGRESS 0x5555
+
+#define ZONE_GOOD 0xff
+#define ZONE_BAD_ORIGINAL 0
+#define ZONE_BAD_MARKED 7
+
+
+#endif /* __MTD_NFTL_USER_H__ */

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,78 +0,0 @@
-/*
- * Copyright (C) 2007
- *       pancake <pancake@youterm.com>
- *
- * 0xFFFF is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; either version 2 of the License, or
- * (at your option) any later version.
- *
- * 0xFFFF 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 0xFFFF; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
- *
- */
-
-#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

@@ -0,0 +1,25 @@
+/*
+ *  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/>.
+ */
+
+#ifndef QMODE_H
+#define QMODE_H
+
+int queue_mode(void);
+
+#endif

src/query.c

@@ -1,193 +0,0 @@
-/*
- * Copyright (C) 2007
- *       pancake <pancake@youterm.com>
- *
- * 0xFFFF is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; either version 2 of the License, or
- * (at your option) any later version.
- *
- * 0xFFFF 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 0xFFFF; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
- *
- */
-
-#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, 192, 1, 0, 0, (char *)&ret, 4, 2000) == -1) {
-		fprintf(stderr, "Cannot get device status.\n");
-		exit(1);
-	}
-
-	return ret;
-}
-
-int get_peripheral_host_mode(int foo)
-{
-	//unsigned short mode = 0;
-
-	// XXX BROKEN
-#if 0
-	if (usb_control_msg(dev, 64, 16, 2, 0, 2, 0, 0, 2000)) {
-		fprintf(stderr, "Cannot query device.\n");
-		return -1;
-	}
-
-	printf("Device is in \"%s\" mode (%hd)\n", (mode)?"host":"peripheral", mode);
-#endif
-
-	return 0;
-}
-/*
- * boot the omap mobo
- */
-
-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;
-}
-
-/*
- * reboot 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;
-}
-
-// mode = 1 || 0
-int set_usb_host_mode(unsigned short mode)
-{
-	if (usb_control_msg(dev, CMD_WRITE, 16, mode, 2, 0, 0, 2000) == -1) {
-		fprintf(stderr, "Cannot change the usb-host mode.\n");
-		return -1;
-	}
-
-	printf("USB host mode is %s.\n", mode?"enabled":"disabled");
-
-	return 0;
-}
-
-/*
- * query root device
- */
-int query_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 query_rdmode_device()
-{
-	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 query_root_device()
-{
-	unsigned char opcode;
-
-	if (usb_control_msg(dev, 192, 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;
-}
-
-int query_nolo_version()
-{
-	unsigned int version; // ensure uint is at least 32 bits
-
-	//if (usb_control_msg(dev, 192, 3, 0, 1, (char *)&version, 4 , 2000) < 0) {
-	if (usb_control_msg(dev, 192, 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;
-}

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,57 +0,0 @@
-/*
- * Copyright (C) 2007
- *       pancake <pancake@youterm.com>
- *
- * 0xFFFF is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; either version 2 of the License, or
- * (at your option) any later version.
- *
- * 0xFFFF 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 0xFFFF; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
- *
- */
-
-#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);
-}