Divided Mind

Software from the dark past - Sony Network Walkman NW-E507 drivers for Linux

2010-03-13T19:01:00.003+01:00

Remember how I used to hack Sony Network Walkman NW-E507? Well, back then, I succeeded and it did work, but soon after that the device got stolen so I never polished it up to release quality. But even though it isn't release quality and I'm not even sure the code I got is the working one (although commit history does suggest so), I decided to publish it anyway. Perhaps it will be useful to someone.

Inventing schemes is not really cool

2009-11-17T17:38:00.002+01:00

Android Developers Blog: Integrating Application with Intents — a nice writeup about really, seriously underappreciated Android feature, Intents. Somehow it's reminiscient of the revolutionary Magic Ink proposal, albeit on a push, not pull basis.

Having said that, I can't shake the feeling that making up URI schemes is not cool. Especially when they're made up to go with an Intent action which is actually redundant with the scheme. URI should point to a location, not embody action; actions should go in the action field (hey, action–action, ya see? almost like it was designed for that!).

OpenSuSE 11.2, ath5k and channel 13

2009-11-17T01:28:00.009+01:00

Kernel 2.6.28 adds brand new WiFi regulatory domain handling; so if you upgrade from OpenSuSE 11.1 to 11.2 (and so from 2.6.27 to 2.6.31) you get this shiny new (FCC) sheriff's badge right there too. This is all fine and cool, only the userspace part is utterly broken in SuSE, so you're limited to world regulatory domain.

Ah, well, downloading Lineville's regulatory.bin fixes it. (Only it's a bit hard if you have NO FREAKING NETWORK because you use channel 13 on your AP and your OS decides that it's no channel 13 for you.) Or does it? Wait, it only gets better.

Now, apparently, your network card feels a citizen of the world. It doesn't matter you're an EU citizen in the EU and that the computer has been bought in the EU. EEPROM says world regdom, the kernel must obey. So you end up patching the driver to report correct regdom to kernel (because it obviously won't just let you override it, you malicious, evil bastard, you). I sure hope you have that kernel source around! And development tools. And stuff. Although I'd advise against those -s in the patch, they seem to break it further, dunno why.

Apparently you can use ath_info to patch up your EEPROM to report correct regdom, so you don't have to patch up ath.ko every time a kernel upgrade comes down the line. Fortunately the 11.1 repo's version still works. (It's regdom 0x37 for EU.) Just that... the card refuses to write it. So you're stuck with patching. Or just shut up and don't use channel 13. Which might explain exactly why it's usually less crowded. (Which, incidentally, is exactly why you'd want to use it.)

Oh, wait, you can enable EEPROM writing on AR5110. You just need to pull the GPIO EEPROM write enable pin. Of course, there's no datasheet anywhere in sight. You're lucky your humble editor took the risk and brute-forced all 10 pins (ok, not all, but he was ready to) and found the magic combination. It's # ath_info -g 1:0 -w <base-address> regdomain 0x37. lspci -v will tell you the address.

Broken SPAA on Radeons with analog panels

2009-11-17T00:54:00.002+01:00

If you have a Radeon with analog LCD panel and after upgrading something (possibly the radeon driver) SPAA suddenly no longer works for you in Qt4, try the following:

$ echo Xft.rgba: rgb >> ~/.Xresources $ xrdb -merge ~/.Xresources

I'm too pissed off by this and debugging it for two days to offer any explanation (just to note, radeon's Option "SubPixelOrder" doesn't work; if you feel like digging, see qfontengine_ft.cpp, libXrender's and libXrandr's source). Also, YMMV. If it works you're on your own to make sure it gets loaded properly.

Hunky Punk — crawl dungeon on the bus

2009-10-28T06:32:00.007+01:00

Interactive fiction interpreter for Android released! Look at the code or just grab the package at Market.

HTC Dream's notification LED color.

2009-07-08T13:14:00.002+02:00

Android documentation says:

public int ledARGB

The color of the led. The hardware will do its best approximation.

Best approximation my ass. I wanted #fb2a0c, I got pink. To get the orange color, I needed #080800, for which orange is most certainly not what I'd call best approximation. It seems that Dreams' drivers just feed the raw RGB values to the hardware without bothering to do any processing on them.

To make it easier to find out which color to feed your device to get the real best approximation of color you want, I made this quick and dirty android LED tester. Just slide the sliders until you're satisfied, note the values and get on with it.

As a note, you might want to only serve the fake colors to devices you tested them on, in case other devices handle this properly and your app would turn out to blink the LED in real #080800, which is to say, almost black. I do this with if (Build.DEVICE.equals("dream")) color = 0xff080800; else color = 0xfffb2a0c; obviously if you test on more devices and they're all equally quirky, you need to add more checks.

Making Android application icons

2009-07-07T19:12:00.004+02:00

Making application icons which would fit in style of the original icons on Android isn't at all easy. I've found it's easiest to model icon in 3D and render it. In the best interest of aesthetically-sensitive android users worldwide, I'm making available this android application icon template you can use to make your new beautiful icon.

It's got the camera, lights and whatnot setup just the proper way. It's still a little bit off the original icons—the shadow could be softer, for instance—but works good enough for me after some time struggling with blender's clunky interface. If you can fix it, great—the drop has guest upload enabled, so feel free to share your improved version.

Extracting 9-patches from apk files

2009-07-02T12:32:00.002+02:00

As you may or may not know, 9.png files in compiled android packages have the nine patch metadata info rolled from the image OOB into the PNG file. Following quick and dirty ruby script extracts it back.


#!/usr/bin/env ruby

# Rafał Rzepecki 
# public domain
#
# deserializes metadata of 9-patch png file
# optionally writes out png with 9-patch info embedded (needs imagemagick for that)
#
# quick and dirty hack, no error handling, almost no test, YMMV
#
# for format specs see android/platform/frameworks/base/libs/utils/ResourceTypes.cpp
# (in android platform source)

if ARGV.length == 0
    print "Usage: #{__FILE__} <serialized nine-patch png file> [optional output png with inline 9-patch info]\n"
    exit 1
end

filename = ARGV[0]
png = File.open(filename) { |f|f.read }
index = png.index 'npTc'
data = png[(index+4)..-1]
wasDeserialized, numXDivs, numYDivs, numColors = data[0...4].unpack('C4')
paddings = data[12...(12+16)].unpack('N4') #left right top bottom
data.slice!(0...32)
xDivs = data.unpack("N#{numXDivs}")
data.slice!(0...(4*numXDivs))
yDivs = data.unpack("N#{numYDivs}")
data.slice!(0...(4*numYDivs))
colors = data.unpack("N#{numColors}")

print "was deserialized: #{wasDeserialized}
paddings: #{paddings.join(', ')}
xdivs: #{xDivs.join(', ')}
ydivs: #{yDivs.join(', ')}
colors: #{colors.map{|c| "#%08x"%c}.join(', ')}
"

if ARGV.length == 1
    exit 0
end

# quick and dirty
`identify #{filename}` =~ /PNG (\d+)x(\d+)/
w, h = $1.to_i, $2.to_i
`convert #{filename} -bordercolor white -compose Copy -border 1x1 -stroke black \
-draw 'line #{xDivs[0] + 1},0 #{xDivs[1] + 1},0' \
-draw 'line 0,#{yDivs[0] + 1} 0,#{yDivs[1] + 1}' \
-draw 'line #{paddings[0] + 1},#{h + 1} #{w - paddings[1]},#{h+1}' \
-draw 'line #{w+1},#{paddings[2] + 1} #{w+1},#{h - paddings[3]}' \
#{ARGV[1]}`

SIM contact list query doesn't support filtering

2009-06-28T00:01:00.003+02:00

content://sim/adn doesn't respect the where clause when querying it. Just so that someone doesn't spend as much time wondering why the freaking thing wouldn't work as I did.

You have to filter it another way. I did by creating a custom CursorAdapter to filter it, but your mileage may vary. It might be better to make a cursor wrapper, or something. Or is there something like that in the library already, and I just missed it?

Launching applications in Android

2009-06-23T22:36:00.002+02:00

To launch an application programmatically in Android given an ApplicationInfo, do:

ApplicationInfo ai;
PackageManager pm = getPackageManager();
try {
    Intent i = pm.getLaunchIntentForPackage(ai.packageName);
    startActivity(i);
} catch (Exception e) {
    Toast t = Toast.makeText(this, "Couldn't launch the application.", Toast.LENGTH_SHORT);
    t.show();
}

Apparently this was harder pre-1.5, where you had to look for the proper activity yourself.

Blogger's data:blog.feedLinks

2009-06-23T01:12:00.003+02:00

As you might have noticed, I got sick of the crufty, old, temporary-turned-permanent template here and been playing with making a new one from scratch. So you might expect this place to look even worse and more half-baked for some time to come.

And while I was trying to get the RSS links in the header, I came across the data:blog.feedLinks thingy. I've been extremely puzzled as to why couldn't I <b:loop> it... turns out it's not a list, but a piece of HTML code. Just smack the <data:blog.feedLinks/> in your <head> and be done with it.

To end this rant, I'd really appreciate if blogger had anything resembling a proper reference instead of this freaking I-m-so-stupid-I-can't-use-a-reference-and-need-mom-to-answer-me-questions freaking FAQd up 'online help'.

EDIT: BTW, no, no comments for you. We'll see if it's to stay. Mostly depends on how fed up I'd be with the blogger API, I guess.

JFS external journal devices on LVM

2009-06-11T06:42:00.003+02:00

JFS allows using external journal devices, but has trouble finding them when they are located on LVM (as of jfsutils-1.1.13). It turns out it doesn't search proper dev directories when searching for device by UUID.

It does search /dev/evms though. Simple workaround is to ln -s mapper /dev/evms.

Power management in Android's kernel

2009-05-13T16:06:00.001+02:00

Google was going to be an interesting case of a large company hiring people both from the embedded world and also the existing Linux development community and then producing an embedded device that was intended to compete with the very best existing platforms. I had high hopes that this combination of factors would result in the Linux community as a whole having a better idea what the constraints and requirements for high-quality power management in the embedded world were, rather than us ending up with another pile of vendor code sitting on an FTP site somewhere in Taiwan that implements its power management by passing tokenised dead mice through a wormhole.

To a certain extent, my hopes were fulfilled. We got a git server in California.

mjg59

Restrained Life Viewer for Linux

2009-03-11T13:59:00.004+01:00

Current (1.15.2_LL-1.21.6) binary distribution of Restrained Life Viewer for Linux is broken. The binary is compiled with an extra flag which is not in the settings file, which makes the client crash when trying to wear a blindfold.

Luckily this is easily fixed. The patch below makes you able to enjoy being blindfolded also in Linux.

--- RLV-1.15.2_LL-1.21.6/app_settings/settings.xml      2008-10-25 22:03:09.000000000 +0200
+++ /home/divide/games/SecondLife-i686-1.21.6.99587/app_settings/settings.xml   2009-03-11 13:58:29.000000000 +0100
@@ -12,6 +12,17 @@
       <key>Value</key>
       <integer>1</integer>
     </map>
+    <key>RestrainedLifeNoSetEnv</key>
+    <map>
+      <key>Comment</key>
+      <string>Toggles the RestrainedLife atmospheric effects restraint, needed for eg. blindfolds. (False means blindfolds work.) Needs a restart of the viewer.</string>
+      <key>Persist</key>
+      <integer>0</integer>
+      <key>Type</key>
+      <string>Boolean</string>
+      <key>Value</key>
+      <integer>0</integer>
+    </map>
     <key>RestrainedLifeDebug</key>
     <map>
       <key>Comment</key>

The sound of silence

2009-03-09T15:32:00.005+01:00

From "The Power of Now" by Eckhart Tolle:

Every sound is born out of silence, dies back into silence, and during its life span is surrounded by silence. Silence enables the sound to be. It is an intrinsic but unmanifested part of every sound, every musical note, every song, every word.

It somehow made me think of John Cage:

Probably the most beautiful short I've ever seen

2009-02-23T23:18:00.002+01:00

Signs
by mg02

(Via ^eirena.)

Snapshotting and cropping widget

2009-02-23T07:19:00.006+01:00

I wrote simple Qt widget that is able to take an image of its own contents, and then crop it. (I use it with a video player widget to allow the user to take a snapshot of the video stream.) You can find it at the repo. It's not perfect, but it's what I need. Feel free to extend it, the mob access is open.

As an example (no code at all, all designer point-and-click), consider the following window:

Now if you click the "Snap" button (which is connected to the CropWidget's snap(bool) slot), the controls are no longer interactive (and are, in fact, just images of controls). You can use your mouse instead to draw a crop rect:

And then, by clicking "Crop" (connected to crop(), simple), get it... you guessed it ;)

Synaesthesia resurrection

2009-02-21T18:24:00.003+01:00

Synaesthesia may well be the most beautiful and meaningful music visualization I've ever seen.

Unfortunately the project seems abandoned—it's twelve years old and last release was in 2005. As such it's a little bit hard to use nowadays; well, you can pipe sound in just fine, but what really lacks is the ability to record a video of the visualization.

This is especially important for me because I'm using a Polish Twitter-like thingy which makes it much more straightforward to embed videos than sound; every time I find myself wanting to share a song I'm listening to I have to find a video on YouTube, and when there is none, I feel compelled to share a synaesthesia video.

So I took the matter into my own hands and hacked together raw video output for synaesthesia. You can find the code at the repo; feel free to tinker in it, you may even commit anonymously (just use the mob account and branch).

I can now do
mpg123 -s song.mp3 | ./synaesthesia --width 640 --height 360 --output-raw 25 pipe 44100 | nice -n10 mencoder - -demuxer rawvideo -rawvideo w=640:h=360:format=rgb32:fps=25 -oac copy -audiofile song.mp3 -ovc lavc -o song.avi
and get a video like this one:

The only thing that needs doing is making it possible to visualize asynchronically. Currently it still generates the video in real-time while playing and this sometimes causes dropped frames (visible in the video as some hickups, especially at the beginning).

My share of shower insights: power to the artists!

2008-08-15T09:57:00.003+02:00

KDE4 has made revolutionary changes in UI architecture, there is no doubt about that. But I can't shake the feeling that, while you can certainly see big advantages this brings to applications, all those KDE4 pillars aren't leveraged nearly as much as could be, in principle, possible.

Take Plasma, for example. The decoupling of logic and presentation into engines and plasmoids is perhaps the most powerful single idea implemented there. But what I see as the greatest opportunity it creates is left untaken: the decoupling makes it possible, in principle, for the artists to design plasmoids entirely by themselves.

Indeed, the simplest Plasma applets do nothing that couldn't be trivially designed graphically: see my own RSIBreak plasmoid (a simplistic prototype yet, sorry) for example. Yet, we still have the situation that the presentation logic is written in a programming language; even if it isn't C++ but something more human-friendly, such as Ruby or Python (having said that, I have yet to see a single useful plasmoid written in one of those) it still leaves out many if not most of the people that could design them on the mercy of developers, who often have more interesting things to do than code trivial UI handling code.

Even the more complicated applets, see the clock for example (you can't talk about Plasma without mentioning the clocks, can you?), could be done entirely in a language designers already know (even if not directly)—SVG. SVG is expressive enough to do every operation that is currently done in C++ code of analog clock plasmoid. But how to program graphically what operations map to which inputs? Why, telling by showing, of course:

The problem with current architecture is that we cannot easily modify SVG tree programatically, so we end up with having to use two languages to describe the interface: SVG for the static parts and C++/whatever for the dynamic behaviour and coupling with the engine. But, IMHO, most plasmoids' presentation could be described just by a smart mapping from engine data to SVG properties.

So, what do we need? What is teh masterplan? Well, first we have to have a framework in place—that's the easy part. First of all, we need a widget that is able to draw an SVG tree that we can modify. Then we need to devise language to describe mapping of inputs to SVG transformation—I'm pretty sure that existing SVG infrastructure for animation is well adaptable to that task. After that, it's just a matter of wrapping the mutable SVG widget with another one that draws the graphic transformed according to the transformation given input data.

The harder part would be making the "tell by showing" interface for the artists—but even without that, this approach has a whole host of benefits. Making a new plasmoid (using an existing data engine) would be just a matter of drawing it and coupling it to the inputs using a description—not programming—language.

This would enable theme designers to alter widgets' look completely—they would no longer be constrained by whatever design the programmer had in mind while writing the code; so that, for example, one theme could show, say, CPU temperature as a bar, while another could use VU-like meters, all that without changing a single line of code—without any additional code at all, in fact!

I'll confess that I'm largely inspired in this idea by Bret Victor whose paper Magic Ink: Information Software and the Graphical Interface I have once read and which sits in my head since and transpires to my consciousness from time to time. You should really read it in its entirety—it's full of innovative, revolutionary ideas and I feel that, with KDE4, for the first time in the history of computer user interfaces, implementing those ideas is finally feasible.

Skipping to merge install phase in Paludis

2008-05-20T08:29:00.003+02:00

Don't you hate it when building a lengthy package succeeds, installs all right into the image, only to fail for some trivial reason (like out of disk space) when merging into the filesystem? In portage you could just use the ebuild(1) command to short-circuit it right to merge. It's not that easy with Paludis, unfortunately.

But worry not, undocumented environment variables to the rescue! The SKIP_FUNCTIONS environment variable allows you to force paludis not to execute some phases of the install action. The magic combo is SKIP_FUNCTIONS="init killold setup saveenv unpack compile install". It fails on loadenv just before postrm for some reason (probably because we barred it from saveenv, but there seems to be no way to skip one saveenv and not another), but by that point the package is already merged.

But really, they ought to make it easier to do such tricks (or at least document the freakin' variable). I can only imagine how hard it must be to debug ebuilds with paludis... Or maybe there is something I don't know about?

Really nice system administration console

2008-02-25T13:39:00.004+01:00

When you're like me, you don't like your CPU cycles waste — and if you're using Gentoo, you like to be constantly merging something in the background. The problem is that the CPU and IO load really can be a major PITA, rendering the machine essentially unusable to do any real work when compilation is running.

Luckily, Linux kernel offer a great deal of flexibility when it comes to scheduling and prioritizing processes. And using that, I hereby present you The Really Nice SysAdmin Console:

alias suscreen="sudo screen -drU || sudo nice -n19 ionice -c3 chrt -b 0 su - -c 'screen -U'"

What this code does, is to:

try to attach to an existing root screen (won't work for more than one, sorry),
in case that fails (ie. no screen running) it sets up a root login screen, scheduled on
- lowest nice priority,
- idle io priority class,
- BATCH scheduler class.

Maybe chrt -b 0 and nice -n19 are a bit redundant, but you're never too sure. The bottom line is — you can have your compilation running in that screen and it doesn't go in the way with whatever you do; when need be, it just yields any CPU and IO to higher-class (ie. your) processes. So you can have your cake and eat it too.

Hardware hacking or how I learned to love the DRM

2008-01-07T03:21:00.000+01:00

My friend, roommate and/or wife (pick two) has a Sony Network Walkman NW-E507. Quite nice piece of hardware in and of itself—gotta love the shiny bright OLED (or whatever) display.

It has only one forthcoming, and a huge one at that. Designed from grounds-up with DRM in mind, it seems that the only way to upload music is to use Sony SonicStage software; it converts files to ATRAC3 (supposedly the only format the device can play), encrypts them and only after such preparation (and adding to a proprietary-binary-formatted directory files) they could be played back. Quite amazingly odd, if you ask me—especially given it's a USB Storage device.

What's worse, the software is only available for Windows and doesn't seem to work in wine at all. (appdb.winehq says someone succeeded in running it, but I have no patience trying different wines and crazy config files + dlls mix and match. Sorry.) This is quite a major headache, as recently I've convinced her to switch to Ubuntu (and now we're running a 100% windows-free household) and now she's effectively unable to use the player (well, only as a really cool looking portable radio).

After some googling, there seemed there is no way to drive it with linux. But then again, it seems to semiofficially support playing MP3 files—but they have to be encrypted, too. Looking deeper, I've found mlsony—an open-source plugin for winamp allowing to upload and download mp3s to the Walkman. It is written in rather clean C++, so it wouldn't be hard to port.

Now, what's cool is that it seems they have succeeded in reverse-engineering the encryption format; alas, the plugin needs a key, and to get the device key, you have to run another proprietary Sony program.

As it wouldn't work in wine either, I've had a choice: either going through hell of installing (or downloading a VM, anyways) and running windows just to get those fricking 16 bytes, or reverse engineering the app. Obviously the latter seemed more fun, so that's just what I've done.

After some fun with freeIDA, assembly and WINAPI (thank you ReactOS for a clean reference and clean header files!) I've finally revealed that getting the key is a piece of cake. Everything that needs to be done is to send special SCSI commands to the device; first to authorize you, and then to read the key.

You can even do that from command line. Just make sure you have sg3-utils and xxdinstalled and just do
echo 00 12 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 | xxd -r -p | sg_raw -s 20 /dev/sg2 a3 00 00 00 00 00 00 bc 00 14 30 00; sg_raw -r 18 -o sonydid /dev/sg2 a4 00 00 00 00 00 00 bc 00 12 3f 00; cat sonydid | tail -c16 > key

There, you have your device key in the key file! Just be sure to substitute your walkman device for /dev/sg2.

(Keep in mind that I have not tested the key yet; I have disassembled the validation procedure of the Sony software, and the string I've obtained seems all right. If you need to know, the magic value is 03 01 01 00 00 00.)

Tray icons in DWM

2007-09-19T09:55:00.000+02:00

DWM is a pretty neat window manager—it's very flexible and can be customized exactly to suit one's needs: I've tried several dynamic tiling managers, and so far only DWM doesn't get in my way and actually is more comfortable than traditional WMs.

Configurability of DWM may sound strange to some: there is none. All customization is done through editing the source code. This may seem daunting, but it really isn't: there isn't much code (below 2000 SLOC) and it's all so clear, that even someone without a background on X11 can get to hacking and learn something in the process. Plus, many immediately configurable settings are gathered in a single header file.

Given this, even though DWM may be mean-and-lean, it's easy to extend it with any feature one would dream of. For me, it was system tray support (you know, those little 22×22 applets docked near your clock). As I'm a KDE user, I'm very much used to little conveniences such as klipper. (Yes, that's right, I'm using DWM with KDE, just by setting KDEWM environment variable.) And vanilla DWM can't handle those properly—every tray icon gets its own ordinary window, which, as you can see, isn't terribly convenient:

To fix that, we first need to see how tray icons are handled in X11. It turns out there is no single standard of doing that. Well, there is the FreeDesktop one, but it's overly complicated and (fortunately) not really used (yet), except maybe for Gnome. KDE3 and third-party apps use a simpler method: they set certain window property, which get spotted by the WM (or other program) which then position and/or swallow the window accordingly.

Two atoms seem to be used for that: WM_WINDOW_ROLE set to Tray Icon and _KDE_NET_WM_SYSTEM_TRAY_WINDOW_FOR pointing to the parent window. Some programs use both.

So all we need to do is spot appropriate properties and check if they're right; if either the role is tray icon, or the KDE-specific property is set at all, we can put the tray window to the right side of the screen. Here, much better:

Cross-compiling Qt4/Win on Linux

2007-09-11T15:27:00.001+02:00

I've recently been playing rediscovering Qt with Qt4. Qt is a great cross-platform programming environment for GUI apps—the best I've used, at least. Anyway, as I put my app together, I thought that I should release it as a windows binary as well—both to use (and test!) this Qt cross-platform compatibility and because I expect the majority of the tool users would be windows users. Alas, I don't have a working windows os (I do have installed some 120-day evaluation version of win2003 somewhere, but even if it works, which I doubt, given some hardware changes since I've last launched it, I think the evaluation period is over anyway), let alone windows development environment.

So, I immediately thought about cross-compiling. Cross-compiling is compiling for another target platform than the host platform (where we run compilation). Generally, mingw32-gcc works marvels for linux-to-win32 cross-compilation and I've been using it some time ago for GTK apps. That was easier, because GTK/win is available in compiled form, so I just needed to cross-compile my own apps. For Qt4/win, no mingw32 binaries are readily available. So I had to take a go at compiling it myself.

After some googling, I've found that although some people tried to achieve that, none of them succeeded. This turned me down a little bit, but I'm not a person which would run away from a challenge.

The main problem with this cross-compilation is Qt4 build system. Although it seems to support cross-compilation, it really can only do it out-of-the-box between different Unix platforms. Since mingw32 is not strictly a Unix platform and different codepaths need to be compiled, this approach fails. So what we need to do is trick the buildsystem into thinking that win32 codepaths apply to unix.

Without further ado, I present you with step-by-step instructions on how to cross-compile Qt4/win. First, though, you need to obtain cross-compiling environment. On gentoo it's simple. Run the following as root:
emerge crossdev crossdev -t mingw32

Well, simple as it may be, compilation was broken on my box on one step. It seems that it didn't find the right compiler to compile win32api. What was needed is
gcc-config mingw32-4.2.0 source /etc/profile

After that I've re-issued the crossdev -t mingw32 command and everything worked.

Now for the compilation of Qt4/win. You need to have Qt4/X11 already installed on your system, as we'll use Qt utilities already available on the system. Make sure you don't the following as root, because the build system for some reason insists on installing DLLs in /usr/bin (doesn't break if it can't, so no harm).

Get Qt4/win sources. I've used 4.3.1 edition.
Unpack them. Enter the directory.
Trick the buildsystem into using win32 feature files:
cd mkspecs/features ln -s win32 unix cd ../..
Download the patch. Apply it.
patch -p1 < qt4win-cross-mingw.patch
Make sure qmake doesn't use compilation paths meant for unix
find src -name '*.pro' -o -name '*.pri' | xargs sed -i -e 's/$^\|[^_/]$unix/\1linux/g;'
Make qmake use compilation paths meant for Windows.
find src -name '*.pro' -o -name '*.pri' | xargs sed -i -e 's/$^\|[^_/]$win32$[^-]\|$$/\1unix\2/g;'
Trick configure into using system utilities. for f in moc rcc uic qmake; do ln -s `which $f` bin; done
Make sure we don't build them:
echo qmake: > qmake/Makefile.unix for f in `ls src/tools`; do echo TEMPLATE = subdirs > src/tools/$f/$f.pro; done
We need some files from the Qt/X11 source, specifically configure script and config.tests directory. I've got them from my qt-copy (from KDE repo); you can use that or download Qt/X11 sources. Put them in the main source directory.
Configure. These options are carefully chosen not to break compilation (except -prefix and -prefix-install; the latter doesn't seem to work anyway).
./configure -prefix $PWD -xplatform win32-g++ -no-largefile -exceptions -no-accessibility -no-qt3support -make libs -prefix-install $PWD -no-reduce-exports
Make a missing makefile.
qmake -spec $PWD/mkspecs/win32-g++ src/winmain/winmain.pro -o src/winmain/Makefile
Build.
make
Done!

If you have Wine, you can even test it. Just make sure the dlls are where Wine can find them: cp /usr/mingw32/usr/bin/mingwm10.dll lib/*.dll /home/divide/.wine/c/windows/system/. To compile the demos, do
cd demos qmake -spec ../mkspecs/win32-g++ demos.pro make wine demos/affine/affine.exe

The only problem I've found with using Qt4 in wine is that the latter doesn't implement some font handling functions and it sometimes breaks font rendering where text is laid out dynamically—esp. QGraphicsView and QTextEdit seem to be the worst offenders.