Hacking A Parallel Port Flash Memory Programmer

July 14, 2012 by Mike Szczys 12 Comments

[Pulko Mandy] doesn’t use his flash ROM programmer very often, but he does use it. When he tried to get support for a new chip and the manufacturer suggested he just buy a newer version he decided to hack the programmer and it’s software instead.

This device connects to the parallel port and was intended for use with MS-DOS systems (no wonder there’s no longer support from the company). The board uses logic chips to add read and write function. So the first step was to analyze how they connect together and come up with a set of commands. While at it he also made some changes to the board to bring the voltage more in spec and ensure the logic levels on the parallel port met the correct voltages.

His plan was to use the board with a Linux system so the parallel port interface can stay. He used what he learned from the hardware inspection to write his own interface in C++. It works with a chip he was able to use under the MS-DOS software, but he hasn’t gotten it to work with the chip that sparked this adventure. If you’re familiar with how the AT29C040A works please consider lending a hand.

Turning The InnoTab Into A Linux Tablet

July 11, 2012 by Brian Benchoff 12 Comments

A few weeks ago we caught wind of [Mick] breaking out his screwdrivers and soldering iron to get a serial console on his son’s VTech InnoTab. [Mick] was able to get the touchscreen working and successfully ported SCUMMVM to the device, but there was still a long road ahead to get the source for this pint-sized tablet.

[David Anders] from elinux.org wrote in to tell us VTech is now giving away their source for the InnoTab, something they’ve been holding back so far. [Dave] is now verifying the VTech release is 100% complete, so if you’d like to give him a hand, drop him a line.

If you’re thinking this is your ticket to an inexpensive and powerful Linux tablet, prepare to be disappointed. The InnoTab is an ARM 11 running at 180 MHz with a paltry 64 MB of RAM. That’s not exactly top-of-the-line hardware, but at the very least you’ll be able to play Doom on it.

A Tale Of (un)bricking A $10k Microsoft Surface Unit

June 29, 2012 by Mike Szczys 20 Comments

We’ve all had that sinking feeling as a piece of hardware stops responding and the nasty thought of “did I just brick this thing?” rockets to the front of our minds. [Florian Echtler] recently experienced this in extremis as his hacking on the University of Munich’s Microsoft Surface 2.0 left it unresponsive. He says this is an 8,000 Euro piece of hardware, which translates to around $10,000! Obviously it was his top priority to get the thing working again.

So what’s the first thing you should do if you get your hands on a piece of hardware like this? Try to run Linux on the thing, of course. And [Florian] managed to make that happen pretty easily (there’s a quick proof-of-concept video after the break). He took a Linux kernel drive written for a different purpose and altered it to interface with the MS Surface. After working out a few error message he packaged it and called to good. Some time later the department called him and asked if his Linux kernel work might have anything to do with the display being dead. Yikes.

He dug into the driver and found that a bug may have caused the firmware on the USB interface chip to be overwritten. The big problem being that they don’t just distribute the image for this chip. So he ended up having to dump what was left from the EEPROM and rebuild the header byte by byte.

Continue reading “A Tale Of (un)bricking A $10k Microsoft Surface Unit” →

[Sprite_tm] Connects An LCD To A Tiny Linux Board

June 25, 2012 by Brian Benchoff 11 Comments

One of [Sprite_tm]’s colleagues recently challenged him to connect a small LCD touch screen to a Raspberry Pi. Sadly, [Sprite_tm] has yet to take delivery of a Raspberry Pi, but he did manage to connect an LCD to a Linux board without video capabilities.

Because [Sprite_tm]’s display has a 16-bit parallel interface, and 16 GPIO pins are hard to come by on the Carambola Linux board, a few shift registers had to be brought into the build to make the LCD work. These shift registers are connected to the Carambola board via an SPI interface; a very simple way to connect all the LCD pins to the Linux board.

Of course, there’s no way for Linux to speak to the LCD without a kernel driver; [Sprite_tm] wrote a framebuffer driver so the LCD can be used as a console, an X session, or used by any other program that can write to a framebuffer device.

Like all good driver authors, [Sprite_tm] is giving away the patch to enable SPI-ified LCD panels on the Carambola along with the shift register schematic. With any luck we’ll also see the Raspi drivers when [Sprite_tm] takes delivery of his Raspberry Pi.

Adding Wireless To The Raspberry Pi

June 15, 2012 by Brian Benchoff 19 Comments

For those of us who haven’t received their Raspberry Pis yet, it may come as a bit of a shock to realize the RasPi doesn’t have an on board WiFi adapter. While the Model B RasPi has an RJ45 Ethernet plug, but the Model A must rely on USB-bound networking dongles. [Mike] over at Mitch Tech put up a great guide to using a Realtek WiFi dongle with his Raspberry Pi.

Stock, the standard Debian install recommended by the folks at Raspberry Pi has the drivers for the Realtek WiFi adapter, but no firmware. [Mike] goes over how to get the firmware for this series of WiFi adapters to keep the kernel from complaining. Interestingly, [Mike]’s instructions also work for a slew of Realtek-based wireless dongles, so the installation instructions should work for a bunch of adapters available from DealExtreme or eBay.

[Mike] also has a guide for installing Quake 3 on a RasPi. Combine these two builds and you’ve got the perfect setup for a Raspberry Pi LAN party. Anyone want to host?

The First Step To Running IPhone Apps In Linux

June 10, 2012 by Brian Benchoff 33 Comments

[Christina] has been working on a project she calls Magenta to put Darwin/BSD on top of Linux. What does that mean? Well, hopefully it’s the first step towards running iPhone/iPad apps on a Linux machine.

Before you get too excited, there are a few caveats; Magenta only works on ARMv7 platforms, none of the fancy iOS frameworks are included, and it’s currently impossible to run iOS apps with this build. Think of this project as a very, very early version of Wine. If you’d like to take Magenta for a spin, [Christina] put the source up here.

Although [Christina]’s project is entirely useless for anyone wanting Siri on their Android phone, it’s possible to add all those fancy iOS frameworks to Magenta and create an open source OS able to run iPhone apps.

We really have to admire [Christina]’s work on this. It’s an amazingly impressive project, and her final goal of recreating the iOS stack would be a boon to the jailbreaking scene. Cue the sound of millions of iPhone clones marching out of China…

via [OleRazzleDazzle] on the reddits

New STM32 Discovery Board Can Now Be Programmed On Linux

June 4, 2012 by Mike Szczys 12 Comments

Last Wednesday I posted a video review of the new STM32F0-Discovery board which is built around an ARM Cortex-M0 chip. I speculated that it should work with the open source project aimed at programming these discovery boards. I tested it out and a connection could be made, but no code could be flashed. So I spent a few hours over the weekend and added support.

My updates are already in the stlink repository. After cloning the code, you can use three commands to compile the software (./autogen.sh, ./configure, make). That’s assuming you have all of the necessary dependencies (I had to install libusb-1.0-0-dev) and that you add the udev rule suggested in the documentation (also found in the repository). The program st-util connects to the board and provides a listening port for an ARM debugger (I’m using arm-none-eabi-gdb from CodeSourcery G++ Lite).

When I first started testing, the chip id was reporting as 0. It turns out the register address polled for this information was wrong. After finding that in the almost-900 page reference manual I went through the painstaking process of finding the hex values necessary to properly memory map the device. From there I also updated the blink example to generate an ELF file compatible with the Cortex-M0 chip. So out of the gate you should be able to use an ARM cross compiling toolchain to compile the example, connect to the board with this utility, then use the debugger from the toolchain to connect and flash that example to RAM.

There’s lots more to be done. To fully utilize the chip it is necessary to use a startup file and linker script when compiling. I’ve done nothing in this area, but I hope to work on some tutorials as I get further along. Of course if you have your own successes developing for this board using a Linux machine we want to hear about it!