Open Steam Controller
Welcome to the Open Steam Controller Project!
This is a project where I have been working to deconstruct, document,
repurpose and expand upon the Steam Controller firmware and hardware.
The Steam Controller
First, it is important to talk a little about the Steam Controller (the
hardware that this project is focused on).
The Steam Controller is a video game controller released by Valve Corporation
on November 10, 2015. This was part of Valve's initiative to give PC gamers the
option of a console-like experience (i.e. the couch gamer who sits in front of
a TV and uses a controller instead of keyboard and mouse).
The Steam Controller tried to keep some aspects familiar to modern video game
controllers (i.e. a left analog stick, four face buttons, two shoulder and
bumper buttons) while also changing up some of the norms we have come to
expect (i.e. replacing the directional pad and right analog stick with trackpads).
Additional details on the controller can be found on the official
Product Page
Why?
You may be wondering why this project exists and why I have invested a
non-negligible amount of my time and energy into it over the past couple of
years.
First, I found the design of this controller to be compelling. Having two
trackpads in place of the D-pad and right analog stick is an interesting idea.
The trackpads can be configured to act in a variety of ways and not only
mimic what they replaced, but also provide new interaction paradigms. Also,
the idea of using the haptics to play a little Jingle when the controller
starts up or shuts down is a neat touch that made the controller further
stand out. Being able to fully customize these Jingles was a near immediate
desire when I first started using the controller.
Second, the controller was left fairly accessible. Being able to upload
firmware updates manually made the barrier to entry for running custom
firmware much lower. There was still a considerable challenge to get even
a "Hello World" (i.e. blink the Steam Button LED) working. However, this was
not nearly as tough as I imagine doing something similar on a controller
that is designed to be more temper resistant would be. I really appreciate
the fact that Valve left this hardware as accessible as they did and do
not discourage people from trying to hack it.
Third, iFixit did a really nice teardown
of the controller. This gave me an idea of what the controller had going on
internally, without needing to (initially) take apart my hardware. This
pointed out a lot of neat peripherals and processors that I thought would
be neat to work with, especially in the context of a product that already
was designed for a particular purpose.
The Open Steam Controller Project
Now that the controller and some of its (default) capabilities have been explained,
we can start talking about this project. Namely I want to cover what has been
accomplished, and what I hope to accomplish moving forward.
Note, the following is a bit verbose and narrative. There is a lot of content
in this project and this is an attempt to break down the details in a way that will
give an easy to follow lay of the land for people new to this effort. If you are a TLDR kind
of person, check out the Notice and Warning Section below and then feel free to
jump into the Subprojects Section to get to the meat of effort. You should also be sure to
check out the demo videos that show some of the major accomplishments in action.
As mentioned previously, the primary intention of this project is to explore, deconstruct and
expand upon configuration options and usages for the Steam Controller. However,
that is a bit vague. So let's start with some examples. First, a major goal
of this project was to be able to write custom firmware for the main processor
on the controller. This is what opens up the door for a lot of other
possibilities moving forward.
However, before I could start writing firmware I needed more
info on the controller. Valve was nice enough to leave the door open to
accessing the binary version of their firmware and the ability to update
the main processor easily. However, they did not provide schematics or
a list of components or datasheets that an embedded software engineer
would typically have if tasked with the process of writing custom
firmware. Therefore, I needed to turn to reverse engineering. This essentially
boils down to deconstructing the hardware and official firmware so that I
could understand how to write my own firmware. At this point the Reverse
Engineering effort has mostly run its course, as a lot has been discovered,
documented and utilized for other efforts. Details on the Reverse Engineering
effort can be found in the Reverse Engineering Subproject.
Now that a Reverse Engineering effort has been established and I
have started gathering information on the hardware, I was able to start writing
custom Firmware. Check out the Firmware Subproject to see the current
state of software. Mostly this is utility software to allow a user to
query different peripherals or take measurements at different states (as
some of that information needed to be captured and fed back into the Reverse
Engineering process to keep it moving forward). However, it eventually became
clear that there was enough functionality that was captured here that it would not
be too much additional work to make this hardware act as a controller for
other consoles (i.e. the Nintendo Switch).
Next we come to what was originally the sole intention of this project. That is,
the goal of being able to have full control of the songs (Jingles) that the
Steam Controller plays (via the Trackpad Haptics) on power up and shut down.
Due to some discoveries via the Reverse Engineering effort, this project
allows for Jingles to be fully customized and for these customizations to
persist while still running Valve's official firmware. For details on how
to customize the Jingles on your controller, or for more details (i.e. how Jingle
Data is formatted and how we can customize Jingles without modifying the official
firmware) see The Jingles Subproject.
Finally, it is important to mention that another intention of this project is
for it to to be an educational and/or motivational resource. Maybe you are
interested in the Steam Controller. Or maybe you are interested in writing
embedded software for a commercial device. Either way the hope is for this
project to provide clear and concise information to inspire and enable
people to to learn and do more. I know I learned a lot from this effort, and
if any of that can be shared and help others out that would be great.
For a starting point on additional details and the accomplishments and future
intentions of this project please see the Subprojects section below.
Notice and Warning
Please recognize that by utilizing any part of this project you are doing so at
your own risk. This is a reverse engineering effort and I make no claims to
have a complete understanding of the hardware I am providing custom or modified
firmware for. Hopefully the testing I perform before publishing my findings and
modifications will prevent damage to your Steam Controller or anything you may
connect your Steam Controller to (i.e. the Nintendo Switch). However, I cannot
guarantee that.
Also please note this is being shared primarily for educational purposes. While
this may allow a user to do things such as use the Steam Controller on the
Nintendo Switch, please recognize that this is almost definitely going to be
coming with trade-offs compared to officially supported hardware and firmware.
If you want a cheap Switch Controller and are OK with it being
wired, check out the ones PowerA or Hori makes. If you want a fully featured
controller, consider spending the extra money and get a Pro Controller (it
really is worth it).
Finally note that I say all of this with the hope of not discouraging anyone.
Please dive in and get your hands dirty. Just please be aware that there is a
(hopefully) very small, but non-zero, chance that a mistake could lead to
bricked or broken hardware.
Subprojects
This section gives brief outlines and demonstrations (if applicable) of the
major efforts of this project. Further details on each Subproject can
be found in their respective directories.
Firmware
The work in this directory is geared towards creating a completely custom firmware
build for the Steam Controller. This project can be configured to have the
controller act as a development system that allows for querying peripherals
and exploring or verifying system behaviors. Additionally the project can
be configured for more practical purpose, such as behaving like a wired
Nintendo Switch controller.
Below are some videos demonstrating the different firmware builds:
Open Steam Controller: Nintendo Switch
Open Steam Controller: Development Board
Jingle
The work in this directory is geared towards creating a user friendly way to
customize what Jingles are played when the Steam Controller starts up and
shuts down.
Below is a video demonstrating how to customize Jingles on the Steam Controller:
Open Steam Controller: Jingle Customization
Reverse Engineering
The work in this directory focuses on deconstructing the firmware and hardware
of the Steam Controller. The understanding gained from this often is a
significant part of the other Subprojects.
USB Configuration
Steam offers the ability to change certain configuration options for a Steam
Controller (i.e. change LED brightness, change which Jingle will be played
from system memory). This directory contains work for understanding,
reproducing and, maybe, expanding upon this functionality.
Contributing
This is an open source project, so please make use of this however you would
like (as long as it does not violate any licenses stated within).
If you would like to offer contributions back to this repo that would be great.
That could come in the form of issues/discussions on how this could be more
user friendly or by adding features or support that is not yet there.
Note that there are TODO documents for each Subproject. The idea
is to outline goals I would like to accomplish. If you want to help with any of
these that would be awesome. It would be even more awesome if you started a
conversation regarding your intentions so as to limit the chances of duplicated
effort or incongruous designs.
Bugs and Issues
I will do my best to provide easy to use and robust software. However, there
will still most likely be bugs. If you find a bug, please report it.
The best way to report a bug is to use the Issues tab on GitHub.
When reporting a bug/issue, please make sure to provide sufficient details. Key
details to include are:
- Exactly what steps did you take?
- Can you reproduce the error by following your own steps?
- Do you have any files that make the bug occur (i.e. specific .musicxml file)?
Resources and Influences
This section lists some projects that influenced this project, as well as links
to some resources that may continue to be helpful to stay current on.
Pilatomic Steam Controller Singer
- Example of using the haptics to play music.
- Example of PC side code written in C using libusb.
- Allows for playing songs of any length, but at cost of controller being occupied by Singer software.
HID Joy-Con Whispering
- Application for communicating with Pro Controller via USB HID.
- Helpful for Switch Faux Controller development to get USB communications in place.
Nintendo Switch Reverse Engineering
- Notes on Reverse Engineering of Nintendo Switch Controllers.
- Helpful details on HID communications with Pro Controller.
Standalone Steam Controller Driver
- Source for breaking down some USB commands.
- Goal of this project is to be able to use Steam Controller as a game controller outside of the Steam platform.
Steam Controller Update News
- Useful to get an idea of what changed from official firmware to firmware release.
UnBricking Steam Controller (Manual Firmware Update, Rollback)
- Step by step guide on how to manually change the Steam Controller firmware.
- Much of this information is captured in Loading Firmware.
- Loading Firmware presents the information in the context of how it applies to Open Steam Controller Project and its Subprojects.
Steam Communities
TODO
While a lot has been accomplished in this project thus far, there is still so much that
can be done with the Steam Controller (especially given the groundwork that has
been laid up to this point). In order to capture and track these ideas TODO documents
have been made for each Subproject. A good place to start is the top-level
TODO Document. This covers the highest level goals for the project
while providing links to Subproject specific TODOS.