[opentitanlib] Add ftdi transport

The new transport can be used to bootstrap the CW340 and the Voyager
board via the FTDI chip.

Signed-off-by: Douglas Reis <[email protected]>

sw/host/opentitanlib/BUILD

@@ -65,6 +65,7 @@ rust_library(
         "src/app/mod.rs",
         "src/app/spi.rs",
         "src/backend/chip_whisperer.rs",
+        "src/backend/ftdi.rs",
         "src/backend/hyperdebug.rs",
         "src/backend/mod.rs",
         "src/backend/proxy.rs",
@@ -174,6 +175,10 @@ rust_library(
         "src/transport/chip_whisperer/mod.rs",
         "src/transport/chip_whisperer/spi.rs",
         "src/transport/chip_whisperer/usb.rs",
+        "src/transport/ftdi/chip.rs",
+        "src/transport/ftdi/gpio.rs",
+        "src/transport/ftdi/mod.rs",
+        "src/transport/ftdi/spi.rs",
         "src/transport/common/fpga.rs",
         "src/transport/common/mod.rs",
         "src/transport/common/uart.rs",
@@ -297,9 +302,12 @@ rust_library(
         "@crate_index//:deser-hjson",
         "@crate_index//:directories",
         "@crate_index//:ecdsa",
+        "@crate_index//:embedded-hal",
         "@crate_index//:env_logger",
         "@crate_index//:erased-serde",
         "@crate_index//:ftdi",
+        "@crate_index//:ftdi-embedded-hal",
+        "@crate_index//:ftdi-mpsse",
         "@crate_index//:hex",
         "@crate_index//:humantime",
         "@crate_index//:humantime-serde",

sw/host/opentitanlib/src/app/config/mod.rs

@@ -67,6 +67,7 @@ static BUILTINS: Lazy<HashMap<&'static str, &'static str>> = Lazy::new(|| {
         "/__builtin__/ti50emulator.json" => include_str!("ti50emulator.json"),
         "/__builtin__/opentitan_cw310.json" => include_str!("opentitan_cw310.json"),
         "/__builtin__/opentitan_cw340.json" => include_str!("opentitan_cw340.json"),
+        "/__builtin__/opentitan_ftdi.json" => include_str!("opentitan_ftdi.json"),
         "/__builtin__/opentitan.json" => include_str!("opentitan.json"),
         "/__builtin__/hyperdebug.json" => include_str!("hyperdebug.json"),
         "/__builtin__/hyperdebug_chipwhisperer.json" => include_str!("hyperdebug_chipwhisperer.json"),

sw/host/opentitanlib/src/app/config/opentitan_ftdi.json

@@ -0,0 +1,82 @@
+{
+  "includes": ["/__builtin__/opentitan.json"],
+  "interface": "ftdi",
+  "pins": [
+    {
+      "name": "RESET",
+      "mode": "PushPull",
+      "invert": false,
+      "alias_of": "adbus5",
+      "pull_mode": "None"
+    },
+    {
+      "name": "TRST",
+      "mode": "PushPull",
+      "level": false,
+      "alias_of": "adbus4",
+      "pull_mode": "None"
+    },
+    {
+      "name": "IOC0",
+      "alias_of": "bdbus4"
+    },
+    {
+      "name": "IOC1",
+      "alias_of": "bdbus5"
+    },
+    {
+      "name": "IOC2",
+      "alias_of": "bdbus6"
+    },
+    {
+      "name": "MUX_FTDI",
+      "alias_of": "bdbus7"
+    },
+    {
+      "name": "IOC8",
+      "alias_of": "adbus6"
+    },
+    {
+      "name": "IOC5",
+      "alias_of": "adbus7"
+    }
+  ],
+  "spi": [
+    {
+      "name": "BOOTSTRAP"
+    }
+  ],
+  "uarts": [
+    {
+      "name": "console",
+      "alias_of": "0"
+    },
+    {
+      "name": "dut",
+      "alias_of": "3"
+    }
+  ],
+  "strappings": [
+    {
+      "name": "ROM_BOOTSTRAP",
+      "pins": [
+        {
+          "name": "SW_STRAP0",
+          "level": true
+        },
+        {
+          "name": "SW_STRAP1",
+          "level": true
+        },
+        {
+          "name": "SW_STRAP2",
+          "level": true
+        },
+        {
+          "name": "MUX_FTDI",
+          "level": true
+        }
+      ]
+    }
+  ]
+}

sw/host/opentitanlib/src/backend/ftdi.rs

@@ -0,0 +1,14 @@
+// Copyright lowRISC contributors (OpenTitan project).
+// Licensed under the Apache License, Version 2.0, see LICENSE for details.
+// SPDX-License-Identifier: Apache-2.0
+
+use anyhow::Result;
+
+use crate::backend::BackendOpts;
+use crate::transport::ftdi::chip::Chip;
+use crate::transport::ftdi::Ftdi;
+use crate::transport::Transport;
+
+pub fn create<C: Chip + 'static>(_args: &BackendOpts) -> Result<Box<dyn Transport>> {
+    Ok(Box::new(Ftdi::<C>::new()?))
+}

sw/host/opentitanlib/src/backend/mod.rs

@@ -11,13 +11,15 @@ use crate::app::config::process_config_file;
 use crate::app::{TransportWrapper, TransportWrapperBuilder};
 use crate::transport::chip_whisperer::board::{Cw310, Cw340};
 use crate::transport::dediprog::Dediprog;
+use crate::transport::ftdi::chip::Ft4232hq;
 use crate::transport::hyperdebug::{
     C2d2Flavor, ChipWhispererFlavor, ServoMicroFlavor, StandardFlavor, Ti50Flavor,
 };
 use crate::transport::{EmptyTransport, Transport};
 use crate::util::parse_int::ParseInt;
 
 mod chip_whisperer;
+mod ftdi;
 mod hyperdebug;
 mod proxy;
 mod ti50emulator;
@@ -131,6 +133,10 @@ pub fn create(args: &BackendOpts) -> Result<TransportWrapper> {
             chip_whisperer::create::<Cw340>(args)?,
             Some(Path::new("/__builtin__/opentitan_cw340.json")),
         ),
+        "ftdi" => (
+            ftdi::create::<Ft4232hq>(args)?,
+            Some(Path::new("/__builtin__/opentitan_ftdi.json")),
+        ),
         "dediprog" => {
             let dediprog: Box<dyn Transport> = Box::new(Dediprog::new(
                 args.usb_vid,

sw/host/opentitanlib/src/transport/ftdi/chip.rs

@@ -0,0 +1,24 @@
+// Copyright lowRISC contributors (OpenTitan project).
+// Licensed under the Apache License, Version 2.0, see LICENSE for details.
+// SPDX-License-Identifier: Apache-2.0
+
+pub trait Chip {
+    const VENDOR_ID: u16 = 0x0403;
+    const PRODUCT_ID: u16;
+
+    const UART_BAUD: u32 = 115200;
+
+    const INTERFACES: &'static [ftdi::Interface];
+}
+
+pub struct Ft4232hq {}
+
+impl Chip for Ft4232hq {
+    const PRODUCT_ID: u16 = 0x6011;
+    const INTERFACES: &'static [ftdi::Interface] = &[
+        ftdi::Interface::A,
+        ftdi::Interface::B,
+        // ftdi::Interface::C,
+        ftdi::Interface::D,
+    ];
+}

sw/host/opentitanlib/src/transport/ftdi/gpio.rs

@@ -0,0 +1,83 @@
+// Copyright lowRISC contributors (OpenTitan project).
+// Licensed under the Apache License, Version 2.0, see LICENSE for details.
+// SPDX-License-Identifier: Apache-2.0
+
+use anyhow::Result;
+use std::cell::RefCell;
+use std::collections::HashMap;
+use std::rc::Rc;
+
+use embedded_hal::digital::OutputPin;
+use ftdi_embedded_hal as ftdi_hal;
+
+use crate::io::gpio::{GpioError, GpioPin, PinMode, PullMode};
+use crate::transport::ftdi::Chip;
+
+pub struct Pin {
+    pin: Rc<RefCell<ftdi_hal::OutputPin<ftdi::Device>>>,
+    pinname: String,
+}
+
+impl Pin {
+    pub fn open<C: Chip>(
+        ftdi_interfaces: &HashMap<ftdi::Interface, ftdi_hal::FtHal<ftdi::Device>>,
+        pinname: String,
+    ) -> Result<Self> {
+        let pinname = pinname.to_lowercase();
+        let (interface, pin) = pinname.split_at(1);
+        let interface = match interface {
+            "a" => ftdi::Interface::A,
+            "b" => ftdi::Interface::B,
+            "c" => ftdi::Interface::C,
+            "d" => ftdi::Interface::D,
+            &_ => panic!("{}", pinname.clone()),
+        };
+
+        let hal = ftdi_interfaces
+            .get(&interface)
+            .ok_or_else(|| GpioError::InvalidPinName(pinname.clone()))?;
+        let pin = match pin {
+            "dbus0" => hal.ad0(),
+            "dbus1" => hal.ad1(),
+            "dbus2" => hal.ad2(),
+            "dbus3" => hal.ad3(),
+            "dbus4" => hal.ad4(),
+            "dbus5" => hal.ad5(),
+            "dbus6" => hal.ad6(),
+            "dbus7" => hal.ad7(),
+            _ => return Err(GpioError::InvalidPinName(pinname).into()),
+        }?;
+
+        Ok(Self {
+            pin: Rc::new(RefCell::new(pin)),
+            pinname,
+        })
+    }
+}
+
+impl GpioPin for Pin {
+    fn read(&self) -> Result<bool> {
+        Ok(false)
+    }
+
+    fn write(&self, value: bool) -> Result<()> {
+        if value {
+            self.pin.borrow_mut().set_high()?;
+        } else {
+            self.pin.borrow_mut().set_low()?;
+        }
+        Ok(())
+    }
+
+    fn set_mode(&self, _mode: PinMode) -> Result<()> {
+        Ok(())
+    }
+
+    fn set_pull_mode(&self, _mode: PullMode) -> Result<()> {
+        Ok(())
+    }
+
+    fn get_internal_pin_name(&self) -> Option<&str> {
+        Some(&self.pinname)
+    }
+}