My interests regarding Erlang on the Beaglebone (or any other small low power ARM system) is less about the peripheral device capability and more about running "big system" stuff on small platforms.
I've thought about hooking SPI (or I2C) peripherals to the Beaglebone, but it just seems too complicated to be worth the effort. Apparently, I will need to patch the Linux kernel and then convince Erlang to play with it by writing a Port driver. It's really at the Linux level where things start to get complex:
Every peripheral uses SPI in its own manner. Being synchronous, you just can't ask a SPI device to "get 1024 bytes" and just consume data. As a master, you need to send a byte for every byte you want to receive (and understand that for 4-wire SPI you will receive a byte simultaneously during the sending of a byte).
You can implement a peripheral's SPI protocol in kernel or user space under Linux.
However, the notion of I/O buffering and time sliced multitasking is somewhat counter to what SPI is about. (Of course you can do SPI in a multitasking environment, but unlike asynchronous UART buffering, if you write a user space SPI driver, you can't expect the kernel to do more than 1 byte worth of SPI work for while you wait for your next slice.)
A kernel based SPI protocol is more efficient, but it means that you are mucking about with kernel development for *every* peripheral you want to support. I don't want to write kernel drivers for every SPI device.
Alas, handling all of this is trivial with a simple microcontroller.
I believe that dealing with low level synchronous protocols is not a good fit for Erlang. I prefer to have Erlang modelling my application domain than worry about bit banging.
My current choice for a home sensor transceiver is a RFM12B. It talks SPI. It has a 2 byte nternal buffer for bytes it receives over-the-air. You need a very responsive SPI driver or you will lose data.
I will use a $3 microcontroller as a bridge between the RFM12B and the Beaglebone UART. The microcontroller will handle the SPI and stream it to a simple asynchronous serial protocol for Linux to receive and buffer.
The Erlang on the Beaglebone will handle the sensor protocol parsing via a standard Linux UART (/dev/XXX). Because Erlang is adept at parsing binary, I'll keep the UART protocol binary.
I won't use Linux/Erlang to sweat the small stuff -- microcontrollers make excellent bridges!