README.txt

This is a KiCad project allowing to control an Apple M1/M2. It started
its life as "m1-ubmc", but its real name is "Central Scrutinizer".

Basically a FUSB302, a couple of level shifters and a RPi Pico. The
project has the component references for JLCPCB except for the Pico,
and is (at the time of writing), pretty cheap to build. Gives you
serial, reboot control and USB passthrough over a micro-USB connector.

Someone who knows what they are doing could surely do much better. It
works well enough for me.

Each produced revision corresponds to a tag:

- v0: First produced version. Ignore it, it's a dud.

- v1: It's alive! Works as well as expected.

- v2: Supports SBU pin swapping. Fully functionnal, but only a
  stepping stone towards v3.

- v3: Supports USB2.0 lines being routed as serial lines, meaning you
  can use cheap USB-C cables as long as you don't need USB2.0
  pass-through. Also comes with UART1 pins routed out, which could be
  used as non-USB control channel (old fashioned console server, for
  example).

  Be careful though, the USB switches used here are so small that
  JLCPCB couldn't properly solder them, resulting in an embarrassing
  80% defect rate... You've been warned.

- v3.1: Exactly the same as v3, only with switches that are physically
  larger, meaning the assembly is much easier.

- v3.2: Limited improvements on v3.1:
  * a 1.2v LDO as the supply for the level shifters (instead of the
    simplistic voltage divider),
  * Molex connectors instead of the LCSC-supplied connectors that are
    hard to source anywhere else,
  * Nexperia's 74AVC1T45 instead of Diode's, for smaller footprint and
    lower minimal voltage
  * ... and a new silkscreen, which makes everything better!

Anything else is probably even worse than the above.

* Building your own:

This is the preferred option, really. I've used JLCPCB for all the
revisions above, both good and bad. If you're not good at soldering
very small stuff, get them to do the heavy lifting. The process is
very straightforward, but you will have to produce at least 5
boards. Find some fellow hackers and share the costs!

Of course, JLCPCB isn't the only game in town. If you know of a decent
PCB+assembly shop and can help with making the PCB easy to get
produced, let me know.

* Final assembly:

If you managed to get your hands on a bare CS board and not a fully
assembled device, you must first solder a Pico to it. Make sure that:

  - the two boards are back to back (components are outside of the
    board sandwich).

  - the two micro-USB connectors on the same end of the assembly -- if
    you have the USB-C and Pico micro-USB close to each other, you're
    doing it wrong.

  - the two boards are far apart enough that the two micro-USB
    connectors can be plugged without interfering with one another.

  - you use a bog standard RPi Pico. Not a Pico W, not a one of the
    many variants with a creative pinout... It may work, it may
    not. Be cheap, don't use anything fancy.

* Dual board configuration:

So you have a pair of Apple machines, two CS boards, but only a single
Pico? Guess what, that's everything you need. Each CS board can use
two different configurations that can work together:

- the default configuration is to use UART0, I2C0, and a defined set
  of GPIOs,

- and there is an alternate setup using UART1, I2C1, and another set
  of GPIOs.

v0 and v1 use a set of 0R resistors that need to be painfully moved
(see the schematics to identify the resistors and their landing spot).
v2+ use a set of PCB jumpers that are easier to modify: for each of
JP1 to JP8, cut the trace between pads 1 and 2, and place a blob of
solder across pads 2 and 3.

To assemble the whole thing, I use long wrapping connectors that allow
all three boards (one Pico and 2 CS) to be stacked. The SW will
automatically detect which board is present and use the right
configuration.

* Software:

For the SW that runs on the RPi Pico and how to use the damn thing,
head to 

https://git.kernel.org/pub/scm/linux/kernel/git/maz/cs-sw.git