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!

Teaching BeagleBone To Play With LIDD Displays

May 18, 2012 by Mike Szczys 5 Comments

[Chris] hasn’t managed to get his hands on a Raspberry Pi yet, so he ordered a BeagleBone and got down to business. He was surprised to find that there isn’t much info out there about using LIDD type displays with the hardware. This protocol is used in many of the 320×240 smart LCD modules on the market, so he hammered out his own drivers and is sharing the details.

The system is designed to run a Linux kernel and [Chris] has chosen to go with Angstrom. His journey started by working out how to compile and patch the kernel himself. From there it was just a matter of getting the pin mapping right, and compiling a driver (it sounds way too simple when put like that).

Apparently he’s pretty close to getting the X desktop environment up and running. No idea what he plans for the hardware, but we’re all for people sharing their work to make it easier for others. Thanks!

Accessing An SD Card Through A Parallel Port, Just Because

May 13, 2012 by Brian Benchoff 24 Comments

[Vinod] sent in a very cool build he says is somewhat of a ‘mad project’: he mounted an MMC and SD card under Linux using the parallel port on his computer. Even though parallel ports are getting rarer these days, we absolutely love [Vinod]’s dedication and willingness to dig around the Linux kernel.

The hardware portion of the build is very simple – just an SD/MMC header and a few resistors wired up to a parallel port. The software side of the hack gets pretty interesting with [Vinod] building a kernel module, something we rarely see on Hackaday.

We’d have to agree with [Vinod]’s ‘mad project’ sentiment, if only because of the terrible throughput of [Vinod]’s adapter; it takes him more than a minute to transfer a 1.5 MB file onto the SD card – terribly slow, to put it mildly. Nevertheless, we’ve got to respect [Vinod] for pushing the limits of uselessness and still building something cool in the process.