Initial commit E300 support.

21 files changed, 4205 insertions, 0 deletions

diff --git a/firmware/e300/rev_b/Makefile b/firmware/e300/rev_b/Makefile
new file mode 100644
index 000000000..0f13dc60b
--- /dev/null
+++ b/firmware/e300/rev_b/Makefile
@@ -0,0 +1,76 @@
+#
+# Copyright 2009 Ettus Research LLC
+#
+
+##################################################
+# Compiler
+##################################################
+CC = avr-gcc
+OBJCOPY = avr-objcopy
+STRIP = avr-strip
+OBJDUMP = avr-objdump
+SREC = srec_cat
+CFLAGS = -Os -std=gnu99 -Wall -fshort-enums -pedantic-errors -Wl,--gc-sections \
+	-Wstrict-prototypes -Wmissing-prototypes -Wcast-align -Wshadow \
+	-DENABLE_SERIAL -DCHARGER_TI -DLED_POLARITY -DDEBUG_VOID
+# -DENABLE_SERIAL	: Output serial debug
+# -DCHARGER_TI		: Use TI charger (rev B) instead of LTC (rev A)
+# -DLED_POLARITY	: Dual-polarity LED on rev B
+# -DDDR3L		: Lower DDR voltage (rev B R-divider changed, so disable this to get back into nominal range)
+# -DDEBUG_VOID		: Use (void) debug function replacements instead of inline NOOP (use if .text overflows)
+# -DI2C_REWORK		: Rev A only
+# -DDEBUG		: Enable debug routines (LED blinks, etc)
+# -DDEBUG_SAFETY	: Extra debug prints
+# -DATTINY88_DIP	: ATTINY88 DIP testing on STK600
+# -DHARDWIRE_ENABLE : LTC3675 dedicated enable lines - don't use
+
+#-Werror
+#-D IO_DEBUG
+
+##################################################
+# Files
+##################################################
+HDRS =
+SRCS =  main.c io.c power.c ltc3675.c i2c.c debug.c bq24190.c
+TARGET = main
+
+##################################################
+# Device
+##################################################
+MMCU = attiny88
+#PROGRAMMER = avrisp2
+PROGRAMMER = stk600
+PORT = usb
+AVRDUDE = avrdude -p $(MMCU) -c $(PROGRAMMER) -P $(PORT)
+
+##################################################
+# Global Targets
+##################################################
+all: $(TARGET).hex
+
+clean:
+	$(RM) *.o *.elf *.hex
+
+install: all
+	$(AVRDUDE) -U flash:w:$(TARGET).hex:i
+
+##################################################
+# Dependency Targets
+##################################################
+fuses.hex: $(TARGET).elf
+	$(OBJCOPY) -j .fuse -O ihex $< $@ --change-section-lma .fuse=0
+
+lfuse.hex: fuses.hex
+	$(SREC) $< -Intel -crop 0x00 0x01 -offset  0x00 -O $@ -Intel
+
+hfuse.hex: fuses.hex
+	$(SREC) $< -Intel -crop 0x01 0x02 -offset -0x01 -O $@ -Intel
+
+$(TARGET).hex: $(TARGET).elf
+	$(OBJCOPY) -R .eeprom -R .fuse -O ihex $< $@
+
+$(TARGET).elf: $(SRCS:.c=.o)
+	$(CC) -mmcu=$(MMCU) $^ -o $@
+
+%.o: %.c $(HDRS) Makefile
+	$(CC) -mmcu=$(MMCU) -c $< -o $@ $(CFLAGS)
diff --git a/firmware/e300/rev_b/PMC.atsln b/firmware/e300/rev_b/PMC.atsln
new file mode 100644
index 000000000..e9f4ffc79
--- /dev/null
+++ b/firmware/e300/rev_b/PMC.atsln
@@ -0,0 +1,29 @@
+
+Microsoft Visual Studio Solution File, Format Version 11.00
+# Atmel Studio Solution File, Format Version 11.00
+Project("{54F91283-7BC4-4236-8FF9-10F437C3AD48}") = "PMC", "PMC.cproj", "{A379D421-4236-44AF-A711-52B7BDA29919}"
+EndProject
+Global
+	GlobalSection(SolutionConfigurationPlatforms) = preSolution
+		Debug|AVR = Debug|AVR
+		Release (DDR3L)|AVR = Release (DDR3L)|AVR
+		Release (DDR3L, Ti)|AVR = Release (DDR3L, Ti)|AVR
+		Release (Dev)|AVR = Release (Dev)|AVR
+		Release|AVR = Release|AVR
+	EndGlobalSection
+	GlobalSection(ProjectConfigurationPlatforms) = postSolution
+		{A379D421-4236-44AF-A711-52B7BDA29919}.Debug|AVR.ActiveCfg = Debug|AVR
+		{A379D421-4236-44AF-A711-52B7BDA29919}.Debug|AVR.Build.0 = Debug|AVR
+		{A379D421-4236-44AF-A711-52B7BDA29919}.Release (DDR3L)|AVR.ActiveCfg = Release (DDR3L)|AVR
+		{A379D421-4236-44AF-A711-52B7BDA29919}.Release (DDR3L)|AVR.Build.0 = Release (DDR3L)|AVR
+		{A379D421-4236-44AF-A711-52B7BDA29919}.Release (DDR3L, Ti)|AVR.ActiveCfg = Release (DDR3L, Ti)|AVR
+		{A379D421-4236-44AF-A711-52B7BDA29919}.Release (DDR3L, Ti)|AVR.Build.0 = Release (DDR3L, Ti)|AVR
+		{A379D421-4236-44AF-A711-52B7BDA29919}.Release (Dev)|AVR.ActiveCfg = Release (Dev)|AVR
+		{A379D421-4236-44AF-A711-52B7BDA29919}.Release (Dev)|AVR.Build.0 = Release (Dev)|AVR
+		{A379D421-4236-44AF-A711-52B7BDA29919}.Release|AVR.ActiveCfg = Release|AVR
+		{A379D421-4236-44AF-A711-52B7BDA29919}.Release|AVR.Build.0 = Release|AVR
+	EndGlobalSection
+	GlobalSection(SolutionProperties) = preSolution
+		HideSolutionNode = FALSE
+	EndGlobalSection
+EndGlobal
diff --git a/firmware/e300/rev_b/PMC.cproj b/firmware/e300/rev_b/PMC.cproj
new file mode 100644
index 000000000..e3784d10b
--- /dev/null
+++ b/firmware/e300/rev_b/PMC.cproj
@@ -0,0 +1,288 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <PropertyGroup>
+    <SchemaVersion>2.0</SchemaVersion>
+    <ProjectVersion>6.0</ProjectVersion>
+    <ToolchainName>com.Atmel.AVRGCC8</ToolchainName>
+    <ProjectGuid>{a379d421-4236-44af-a711-52b7bda29919}</ProjectGuid>
+    <avrdevice>ATtiny88</avrdevice>
+    <avrdeviceseries>none</avrdeviceseries>
+    <OutputType>Executable</OutputType>
+    <Language>C</Language>
+    <OutputFileName>$(MSBuildProjectName)</OutputFileName>
+    <OutputFileExtension>.elf</OutputFileExtension>
+    <OutputDirectory>$(MSBuildProjectDirectory)\$(Configuration)</OutputDirectory>
+    <AssemblyName>PMC</AssemblyName>
+    <Name>PMC</Name>
+    <RootNamespace>PMC</RootNamespace>
+    <ToolchainFlavour>Native</ToolchainFlavour>
+    <KeepTimersRunning>true</KeepTimersRunning>
+    <OverrideVtor>false</OverrideVtor>
+    <OverrideVtorValue />
+    <eraseonlaunchrule>0</eraseonlaunchrule>
+    <AsfVersion>3.1.3</AsfVersion>
+    <avrtool>com.atmel.avrdbg.tool.stk600</avrtool>
+    <avrtoolinterface>ISP</avrtoolinterface>
+    <com_atmel_avrdbg_tool_stk600>
+      <ToolType>com.atmel.avrdbg.tool.stk600</ToolType>
+      <ToolName>STK600</ToolName>
+      <ToolNumber>004A8D68669B</ToolNumber>
+      <KeepTimersRunning>true</KeepTimersRunning>
+      <OverrideVtor>false</OverrideVtor>
+      <OverrideVtorValue>
+      </OverrideVtorValue>
+      <Channel>
+        <host>127.0.0.1</host>
+        <port>49172</port>
+        <ssl>False</ssl>
+      </Channel>
+      <ToolOptions>
+        <InterfaceName>ISP</InterfaceName>
+        <InterfaceProperties>
+          <JtagDbgClock>249000</JtagDbgClock>
+          <JtagProgClock>1000000</JtagProgClock>
+          <IspClock>25000</IspClock>
+          <JtagInChain>false</JtagInChain>
+          <JtagEnableExtResetOnStartSession>false</JtagEnableExtResetOnStartSession>
+          <JtagDevicesBefore>0</JtagDevicesBefore>
+          <JtagDevicesAfter>0</JtagDevicesAfter>
+          <JtagInstrBitsBefore>0</JtagInstrBitsBefore>
+          <JtagInstrBitsAfter>0</JtagInstrBitsAfter>
+        </InterfaceProperties>
+      </ToolOptions>
+    </com_atmel_avrdbg_tool_stk600>
+    <com_atmel_avrdbg_tool_ispmk2>
+      <ToolType>com.atmel.avrdbg.tool.ispmk2</ToolType>
+      <ToolName>AVRISP mkII</ToolName>
+      <ToolNumber>000200136505</ToolNumber>
+      <KeepTimersRunning>true</KeepTimersRunning>
+      <OverrideVtor>false</OverrideVtor>
+      <OverrideVtorValue>
+      </OverrideVtorValue>
+      <Channel>
+        <host>127.0.0.1</host>
+        <port>49228</port>
+        <ssl>False</ssl>
+      </Channel>
+      <ToolOptions>
+        <InterfaceName>ISP</InterfaceName>
+        <InterfaceProperties>
+          <JtagDbgClock>249000</JtagDbgClock>
+          <JtagProgClock>1000000</JtagProgClock>
+          <IspClock>8000</IspClock>
+          <JtagInChain>false</JtagInChain>
+          <JtagEnableExtResetOnStartSession>false</JtagEnableExtResetOnStartSession>
+          <JtagDevicesBefore>0</JtagDevicesBefore>
+          <JtagDevicesAfter>0</JtagDevicesAfter>
+          <JtagInstrBitsBefore>0</JtagInstrBitsBefore>
+          <JtagInstrBitsAfter>0</JtagInstrBitsAfter>
+        </InterfaceProperties>
+      </ToolOptions>
+    </com_atmel_avrdbg_tool_ispmk2>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)' == 'Release' ">
+    <ToolchainSettings>
+      <AvrGcc>
+        <avrgcc.common.outputfiles.hex>True</avrgcc.common.outputfiles.hex>
+        <avrgcc.common.outputfiles.lss>True</avrgcc.common.outputfiles.lss>
+        <avrgcc.common.outputfiles.eep>True</avrgcc.common.outputfiles.eep>
+        <avrgcc.compiler.general.ChangeDefaultCharTypeUnsigned>True</avrgcc.compiler.general.ChangeDefaultCharTypeUnsigned>
+        <avrgcc.compiler.general.ChangeDefaultBitFieldUnsigned>True</avrgcc.compiler.general.ChangeDefaultBitFieldUnsigned>
+        <avrgcc.compiler.symbols.DefSymbols>
+          <ListValues>
+            <Value>I2C_REWORK</Value>
+            <Value>ENABLE_SERIAL</Value>
+          </ListValues>
+        </avrgcc.compiler.symbols.DefSymbols>
+        <avrgcc.compiler.optimization.level>Optimize for size (-Os)</avrgcc.compiler.optimization.level>
+        <avrgcc.compiler.optimization.PackStructureMembers>True</avrgcc.compiler.optimization.PackStructureMembers>
+        <avrgcc.compiler.optimization.AllocateBytesNeededForEnum>True</avrgcc.compiler.optimization.AllocateBytesNeededForEnum>
+        <avrgcc.compiler.warnings.AllWarnings>True</avrgcc.compiler.warnings.AllWarnings>
+        <avrgcc.compiler.warnings.WarningsAsErrors>True</avrgcc.compiler.warnings.WarningsAsErrors>
+        <avrgcc.linker.libraries.Libraries>
+          <ListValues>
+            <Value>m</Value>
+          </ListValues>
+        </avrgcc.linker.libraries.Libraries>
+      </AvrGcc>
+    </ToolchainSettings>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)' == 'Debug' ">
+    <ToolchainSettings>
+      <AvrGcc>
+        <avrgcc.common.outputfiles.hex>True</avrgcc.common.outputfiles.hex>
+        <avrgcc.common.outputfiles.lss>True</avrgcc.common.outputfiles.lss>
+        <avrgcc.common.outputfiles.eep>True</avrgcc.common.outputfiles.eep>
+        <avrgcc.compiler.general.ChangeDefaultCharTypeUnsigned>True</avrgcc.compiler.general.ChangeDefaultCharTypeUnsigned>
+        <avrgcc.compiler.general.ChangeDefaultBitFieldUnsigned>True</avrgcc.compiler.general.ChangeDefaultBitFieldUnsigned>
+        <avrgcc.compiler.symbols.DefSymbols>
+          <ListValues>
+            <Value>ATTINY88_DIP</Value>
+            <Value>DEBUG</Value>
+            <Value>I2C_REWORK</Value>
+          </ListValues>
+        </avrgcc.compiler.symbols.DefSymbols>
+        <avrgcc.compiler.optimization.level>Optimize (-O1)</avrgcc.compiler.optimization.level>
+        <avrgcc.compiler.optimization.PackStructureMembers>True</avrgcc.compiler.optimization.PackStructureMembers>
+        <avrgcc.compiler.optimization.AllocateBytesNeededForEnum>True</avrgcc.compiler.optimization.AllocateBytesNeededForEnum>
+        <avrgcc.compiler.optimization.DebugLevel>Default (-g2)</avrgcc.compiler.optimization.DebugLevel>
+        <avrgcc.compiler.warnings.AllWarnings>True</avrgcc.compiler.warnings.AllWarnings>
+        <avrgcc.compiler.warnings.WarningsAsErrors>True</avrgcc.compiler.warnings.WarningsAsErrors>
+        <avrgcc.linker.libraries.Libraries>
+          <ListValues>
+            <Value>m</Value>
+          </ListValues>
+        </avrgcc.linker.libraries.Libraries>
+        <avrgcc.assembler.debugging.DebugLevel>Default (-Wa,-g)</avrgcc.assembler.debugging.DebugLevel>
+      </AvrGcc>
+    </ToolchainSettings>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)' == 'Release (DDR3L)' ">
+    <ToolchainSettings>
+      <AvrGcc>
+        <avrgcc.common.outputfiles.hex>True</avrgcc.common.outputfiles.hex>
+        <avrgcc.common.outputfiles.lss>True</avrgcc.common.outputfiles.lss>
+        <avrgcc.common.outputfiles.eep>True</avrgcc.common.outputfiles.eep>
+        <avrgcc.compiler.general.ChangeDefaultCharTypeUnsigned>True</avrgcc.compiler.general.ChangeDefaultCharTypeUnsigned>
+        <avrgcc.compiler.general.ChangeDefaultBitFieldUnsigned>True</avrgcc.compiler.general.ChangeDefaultBitFieldUnsigned>
+        <avrgcc.compiler.symbols.DefSymbols>
+          <ListValues>
+            <Value>I2C_REWORK</Value>
+            <Value>ENABLE_SERIAL</Value>
+            <Value>DDR3L</Value>
+          </ListValues>
+        </avrgcc.compiler.symbols.DefSymbols>
+        <avrgcc.compiler.optimization.level>Optimize for size (-Os)</avrgcc.compiler.optimization.level>
+        <avrgcc.compiler.optimization.PackStructureMembers>True</avrgcc.compiler.optimization.PackStructureMembers>
+        <avrgcc.compiler.optimization.AllocateBytesNeededForEnum>True</avrgcc.compiler.optimization.AllocateBytesNeededForEnum>
+        <avrgcc.compiler.warnings.AllWarnings>True</avrgcc.compiler.warnings.AllWarnings>
+        <avrgcc.compiler.warnings.WarningsAsErrors>True</avrgcc.compiler.warnings.WarningsAsErrors>
+        <avrgcc.linker.libraries.Libraries>
+          <ListValues>
+            <Value>m</Value>
+          </ListValues>
+        </avrgcc.linker.libraries.Libraries>
+      </AvrGcc>
+    </ToolchainSettings>
+    <OutputPath>bin\Release (DDR3)\</OutputPath>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)' == 'Release (Dev)' ">
+    <ToolchainSettings>
+      <AvrGcc>
+        <avrgcc.common.outputfiles.hex>True</avrgcc.common.outputfiles.hex>
+        <avrgcc.common.outputfiles.lss>True</avrgcc.common.outputfiles.lss>
+        <avrgcc.common.outputfiles.eep>True</avrgcc.common.outputfiles.eep>
+        <avrgcc.compiler.general.ChangeDefaultCharTypeUnsigned>True</avrgcc.compiler.general.ChangeDefaultCharTypeUnsigned>
+        <avrgcc.compiler.general.ChangeDefaultBitFieldUnsigned>True</avrgcc.compiler.general.ChangeDefaultBitFieldUnsigned>
+        <avrgcc.compiler.symbols.DefSymbols>
+          <ListValues>
+            <Value>I2C_REWORK</Value>
+            <Value>ENABLE_SERIAL</Value>
+            <Value>ATTINY88_DIP</Value>
+          </ListValues>
+        </avrgcc.compiler.symbols.DefSymbols>
+        <avrgcc.compiler.optimization.level>Optimize for size (-Os)</avrgcc.compiler.optimization.level>
+        <avrgcc.compiler.optimization.PrepareFunctionsForGarbageCollection>True</avrgcc.compiler.optimization.PrepareFunctionsForGarbageCollection>
+        <avrgcc.compiler.optimization.PackStructureMembers>True</avrgcc.compiler.optimization.PackStructureMembers>
+        <avrgcc.compiler.optimization.AllocateBytesNeededForEnum>True</avrgcc.compiler.optimization.AllocateBytesNeededForEnum>
+        <avrgcc.compiler.warnings.AllWarnings>True</avrgcc.compiler.warnings.AllWarnings>
+        <avrgcc.compiler.warnings.WarningsAsErrors>True</avrgcc.compiler.warnings.WarningsAsErrors>
+        <avrgcc.linker.libraries.Libraries>
+          <ListValues>
+            <Value>m</Value>
+          </ListValues>
+        </avrgcc.linker.libraries.Libraries>
+        <avrgcc.linker.optimization.GarbageCollectUnusedSections>True</avrgcc.linker.optimization.GarbageCollectUnusedSections>
+      </AvrGcc>
+    </ToolchainSettings>
+    <OutputPath>bin\Release (Dev)\</OutputPath>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)' == 'Release (DDR3L, Ti)' ">
+    <ToolchainSettings>
+      <AvrGcc>
+  <avrgcc.common.outputfiles.hex>True</avrgcc.common.outputfiles.hex>
+  <avrgcc.common.outputfiles.lss>True</avrgcc.common.outputfiles.lss>
+  <avrgcc.common.outputfiles.eep>True</avrgcc.common.outputfiles.eep>
+  <avrgcc.compiler.general.ChangeDefaultCharTypeUnsigned>True</avrgcc.compiler.general.ChangeDefaultCharTypeUnsigned>
+  <avrgcc.compiler.general.ChangeDefaultBitFieldUnsigned>True</avrgcc.compiler.general.ChangeDefaultBitFieldUnsigned>
+  <avrgcc.compiler.symbols.DefSymbols>
+    <ListValues>
+      <Value>I2C_REWORK_disabled</Value>
+      <Value>DDR3L_disabled_revB_R_FB_network_changed</Value>
+      <Value>CHARGER_TI</Value>
+      <Value>ENABLE_SERIAL_disabled</Value>
+      <Value>LED_POLARITY</Value>
+    </ListValues>
+  </avrgcc.compiler.symbols.DefSymbols>
+  <avrgcc.compiler.optimization.level>Optimize for size (-Os)</avrgcc.compiler.optimization.level>
+  <avrgcc.compiler.optimization.PackStructureMembers>True</avrgcc.compiler.optimization.PackStructureMembers>
+  <avrgcc.compiler.optimization.AllocateBytesNeededForEnum>True</avrgcc.compiler.optimization.AllocateBytesNeededForEnum>
+  <avrgcc.compiler.warnings.AllWarnings>True</avrgcc.compiler.warnings.AllWarnings>
+  <avrgcc.compiler.warnings.WarningsAsErrors>True</avrgcc.compiler.warnings.WarningsAsErrors>
+  <avrgcc.linker.libraries.Libraries>
+    <ListValues>
+      <Value>m</Value>
+    </ListValues>
+  </avrgcc.linker.libraries.Libraries>
+</AvrGcc>
+    </ToolchainSettings>
+    <OutputPath>bin\Release (DDR3L, Ti)\</OutputPath>
+  </PropertyGroup>
+  <ItemGroup>
+    <Compile Include="bq24190.c">
+      <SubType>compile</SubType>
+    </Compile>
+    <Compile Include="bq24190.h">
+      <SubType>compile</SubType>
+    </Compile>
+    <Compile Include="config.h">
+      <SubType>compile</SubType>
+    </Compile>
+    <Compile Include="debug.c">
+      <SubType>compile</SubType>
+    </Compile>
+    <Compile Include="debug.h">
+      <SubType>compile</SubType>
+    </Compile>
+    <Compile Include="error.h">
+      <SubType>compile</SubType>
+    </Compile>
+    <Compile Include="global.h">
+      <SubType>compile</SubType>
+    </Compile>
+    <Compile Include="i2c.c">
+      <SubType>compile</SubType>
+    </Compile>
+    <Compile Include="i2c.h">
+      <SubType>compile</SubType>
+    </Compile>
+    <Compile Include="io.c">
+      <SubType>compile</SubType>
+    </Compile>
+    <Compile Include="io.h">
+      <SubType>compile</SubType>
+    </Compile>
+    <Compile Include="ltc3675.c">
+      <SubType>compile</SubType>
+    </Compile>
+    <Compile Include="ltc3675.h">
+      <SubType>compile</SubType>
+    </Compile>
+    <Compile Include="ltc4155.c">
+      <SubType>compile</SubType>
+    </Compile>
+    <Compile Include="ltc4155.h">
+      <SubType>compile</SubType>
+    </Compile>
+    <Compile Include="main.c">
+      <SubType>compile</SubType>
+    </Compile>
+    <Compile Include="power.c">
+      <SubType>compile</SubType>
+    </Compile>
+    <Compile Include="power.h">
+      <SubType>compile</SubType>
+    </Compile>
+  </ItemGroup>
+  <Import Project="$(AVRSTUDIO_EXE_PATH)\\Vs\\Compiler.targets" />
+</Project>
\ No newline at end of file
diff --git a/firmware/e300/rev_b/bq24190.c b/firmware/e300/rev_b/bq24190.c
new file mode 100644
index 000000000..029beacf6
--- /dev/null
+++ b/firmware/e300/rev_b/bq24190.c
@@ -0,0 +1,335 @@
+/*
+ * bq24190.c
+ *
+ * Created: 11/12/2012 4:58:12 PM
+ *  Author: Balint Seeber
+ */
+
+#ifdef CHARGER_TI
+
+#include "config.h"
+#include "bq24190.h"
+
+#include <util/delay.h>
+
+#include "io.h"
+#include "i2c.h"
+#include "debug.h"
+#include "global.h"
+#include "error.h"
+
+#ifndef I2C_REWORK
+#include "power.h"
+#endif // I2C_REWORK
+
+static io_pin_t USBPM_IRQ	= IO_PB(1);
+
+#ifdef ATTINY88_DIP
+
+static io_pin_t CHRG_SDA     = IO_PC(2);
+static io_pin_t CHRG_SCL     = IO_PC(3);
+
+#else
+
+#ifdef I2C_REWORK
+
+static io_pin_t CHRG_SDA     = IO_PC(4);
+static io_pin_t CHRG_SCL     = IO_PC(5);
+
+#else
+
+#define CHRG_SDA	PWR_SDA
+#define CHRG_SCL	PWR_SCL
+
+#endif // I2C_REWORK
+
+#endif // ATTINY88_DIP
+
+const bool _bq24190_pull_up = false;
+
+#define BQ24190_BASE_ADDRESS    (0x6B << 1)
+#define BQ24190_WRITE_ADDRESS   (BQ24190_BASE_ADDRESS + 0)
+#define BQ24190_READ_ADDRESS    (BQ24190_BASE_ADDRESS + 1)
+
+enum BQ24190Registers
+{
+	BQ24190_REG_INPUT_SOURCE_CTL= 0,
+	BQ24190_REG_PWR_ON_CONFIG	= 1,
+	BQ24190_REG_CHARGE_CURRENT	= 2,
+	BQ24190_REG_PRE_TERM_CURRENT= 3,
+	BQ24190_REG_CHARGE_VOLTAGE	= 4,
+	BQ24190_REG_TIMER_CONTROL	= 5,
+	BQ24190_REG_SYSTEM_STATUS	= 8,
+	BQ24190_REG_FAULT			= 9
+};
+/*
+enum BQ24190TimerControl
+{
+	
+};
+*/
+enum BQ24190Shifts
+{
+	BQ24190_SHIFTS_CHARGER_CONFIG	= 4,
+	BQ24190_SHIFTS_I2C_WATCHDOG		= 4,
+	BQ24190_SHIFTS_CHARGER_STATUS	= 4,
+	BQ24190_SHIFTS_CHARGER_FAULT	= 4,
+};
+
+enum BQ24190VBusStatus
+{
+	BQ24190_VBUS_UNKNOWN,
+	BQ24190_VBUS_USB,
+	BQ24190_VBUS_ADAPTER,
+	BQ24190_VBUS_OTG
+};
+
+enum BQ24190ChargerStatus
+{
+	BQ24190_CHRG_STAT_NOT_CHARGING,
+	BQ24190_CHRG_STAT_PRE_CHARGE,
+	BQ24190_CHRG_STAT_FAST_CHARGING,
+	BQ24190_CHRG_STAT_CHARGE_TERMINATION_DONE,
+	BQ24190_CHRG_STAT_MASK = BQ24190_CHRG_STAT_CHARGE_TERMINATION_DONE
+};
+
+enum BQ24190SystemStatus
+{
+	BQ24190_STATUS_DPM					= 0x08,
+	BQ24190_STATUS_POWER_GOOD			= 0x04,
+	BQ24190_STATUS_THERMAL_REGULATION	= 0x02,
+	BQ24190_STATUS_VSYSMIN_REGULATION	= 0x01
+};
+
+enum BQ24190Faults
+{
+	BQ24190_FAULT_WATCHDOG_EXPIRED	= 0x80,
+	BQ24190_FAULT_VBUS_OVERLOADED	= 0x40,
+	BQ24190_FAULT_BATOVP			= 0x08
+};
+
+enum BQ24190ChargerFaults
+{
+	BQ24190_CHRGFAULT_NORMAL,
+	BQ24190_CHRGFAULT_INPUT,
+	BQ24190_CHRGFAULT_THERMAL,
+	BQ24190_CHRGFAULT_SAFETY_TIMER
+};
+
+enum BQ24190NTCFaults
+{
+	BQ24190_NTCFAULT_NORMAL,
+	BQ24190_NTCFAULT_TS1_COLD,
+	BQ24190_NTCFAULT_TS1_HOT,
+	BQ24190_NTCFAULT_TS2_COLD,
+	BQ24190_NTCFAULT_TS2_HOT,
+	BQ24190_NTCFAULT_BOTH_COLD,
+	BQ24190_NTCFAULT_BOTH_HOT
+};
+
+bool bq24190_toggle_charger(bool on)
+{
+	uint8_t config = 0;
+	if (i2c_read2_ex(CHRG_SDA, CHRG_SCL, BQ24190_READ_ADDRESS, BQ24190_REG_PWR_ON_CONFIG, &config, _bq24190_pull_up) == false)
+		return false;
+	
+	debug_log_ex("BQPC ", false);
+	debug_log_hex(config);
+	
+	config &= ~(0x3 << BQ24190_SHIFTS_CHARGER_CONFIG);
+	if (on)
+		config |= (0x01 << BQ24190_SHIFTS_CHARGER_CONFIG);	// Enable charger
+	
+	if (i2c_write_ex(CHRG_SDA, CHRG_SCL, BQ24190_WRITE_ADDRESS, BQ24190_REG_PWR_ON_CONFIG, config, _bq24190_pull_up) == false)
+		return false;
+	
+	////////
+/*
+	if (i2c_read2_ex(CHRG_SDA, CHRG_SCL, BQ24190_READ_ADDRESS, BQ24190_REG_PWR_ON_CONFIG, &config, _bq24190_pull_up) == false)
+		return false;
+	
+	debug_log_ex("BQPC ", false);
+	debug_log_hex(config);
+*/
+	////////
+	
+	return true;
+}
+
+bool bq24190_init(bool disable_charger)
+{
+#ifdef I2C_REWORK
+	i2c_init_ex(CHRG_SDA, CHRG_SCL, _bq24190_pull_up);
+#endif // I2C_REWORK
+	io_input_pin(USBPM_IRQ);
+#if !defined(DEBUG) && !defined(ATTINY88_DIP)
+	//io_set_pin(USBPM_IRQ);	// [Enable pull-up for Open Drain] AVR pull-up not enough
+#endif // DEBUG
+	if (disable_charger)
+	{
+		if (bq24190_toggle_charger(false) == false)
+			return false;
+	}
+	
+	///////////////////////////////////
+	
+	uint8_t timer_control = 0;
+	if (i2c_read2_ex(CHRG_SDA, CHRG_SCL, BQ24190_READ_ADDRESS, BQ24190_REG_TIMER_CONTROL, &timer_control, _bq24190_pull_up) == false)
+		return false;
+	
+	debug_log_ex("BQTC ", false);
+	debug_log_hex(timer_control);
+	
+	timer_control &= ~(0x3 << BQ24190_SHIFTS_I2C_WATCHDOG);
+	timer_control |= (0x00 << BQ24190_SHIFTS_I2C_WATCHDOG);	// Disable I2C watch dog
+	
+	if (i2c_write_ex(CHRG_SDA, CHRG_SCL, BQ24190_WRITE_ADDRESS, BQ24190_REG_TIMER_CONTROL, timer_control, _bq24190_pull_up) == false)
+		return false;
+	
+	///////////////////////////////////
+	
+	//BQ24190_REG_PWR_ON_CONFIG
+	// Minimum System Voltage Limit: (default) 101 3.5V
+	
+	//BQ24190_REG_CHARGE_CURRENT
+	// Fast Charge Current Limit: (default) 011000 2048mA
+	
+	//BQ24190_REG_PRE_TERM_CURRENT
+	// Pre-charge current limit: (default) 0001 256mA
+	// Termination current limit: (default) 0001 256mA
+	
+	//BQ24190_REG_CHARGE_VOLTAGE
+	// Charge voltage limit: (default) 101100 4.208V
+	
+	///////////////////////////////////
+	
+	uint8_t input_src_ctl = 0;
+	if (i2c_read2_ex(CHRG_SDA, CHRG_SCL, BQ24190_READ_ADDRESS, BQ24190_REG_INPUT_SOURCE_CTL, &input_src_ctl, _bq24190_pull_up) == false)
+		return false;
+	
+	debug_log_ex("BQIS ", false);
+	debug_log_hex(input_src_ctl);
+	
+	// Input voltage limit: (default) 0110 4.36V
+	
+	//input_src_ctl &= ~(0x07);
+	input_src_ctl |= (0x07);	// Set 3A limit
+	
+	if (i2c_write_ex(CHRG_SDA, CHRG_SCL, BQ24190_WRITE_ADDRESS, BQ24190_REG_INPUT_SOURCE_CTL, input_src_ctl, _bq24190_pull_up) == false)
+		return false;
+	
+	return true;
+}
+
+bool bq24190_has_interrupt(void)
+{
+	//bool state = io_test_pin(USBPM_IRQ);
+	//debug_log_ex("BQIRQ", false);
+	//debug_log_byte(state);
+	//return (state != 1);
+	return (io_test_pin(USBPM_IRQ) == false);
+}
+
+static uint8_t _bq24190_last_status, _bq24190_last_fault;
+
+bool _bq24190_handle_irq(void)
+{
+	uint8_t val = 0x00;
+	bool result = false;
+	
+	if (i2c_read2_ex(CHRG_SDA, CHRG_SCL, BQ24190_READ_ADDRESS, BQ24190_REG_SYSTEM_STATUS, &val, _bq24190_pull_up) == false)
+		goto _bq24190_handle_fail;
+	
+	debug_log_ex("BQST ", false);
+	debug_log_hex(val);
+	
+	if (i2c_read2_ex(CHRG_SDA, CHRG_SCL, BQ24190_READ_ADDRESS, BQ24190_REG_SYSTEM_STATUS, &val, _bq24190_pull_up) == false)
+		goto _bq24190_handle_fail;
+	
+	_bq24190_last_status = val;
+
+	debug_log_ex("BQST ", false);
+	debug_log_hex(val);
+	
+	/*if (val & LTC4155_WALLSNS_GOOD)
+	{
+		uint8_t wall_state = 0;
+		if (i2c_read2_ex(CHRG_SDA, CHRG_SCL, LTC4155_READ_ADDRESS, LTC4155_REG_WALL, &wall_state, _ltc4155_pull_up) == false)
+			goto _bq24190_handle_fail;
+		
+		wall_state &= ~0x1E;
+		wall_state |= 0x0E;
+		
+		if (i2c_write_ex(CHRG_SDA, CHRG_SCL, LTC4155_WRITE_ADDRESS, LTC4155_REG_WALL, wall_state, _ltc4155_pull_up) == false)
+			goto _bq24190_handle_fail;
+		
+		debug_log("I+");
+	}*/
+	
+	if (i2c_read2_ex(CHRG_SDA, CHRG_SCL, BQ24190_READ_ADDRESS, BQ24190_REG_FAULT, &val, _bq24190_pull_up) == false)
+		goto _bq24190_handle_fail;
+	
+	debug_log_ex("BQF  ", false);
+	debug_log_hex(val);
+	
+	if (i2c_read2_ex(CHRG_SDA, CHRG_SCL, BQ24190_READ_ADDRESS, BQ24190_REG_FAULT, &val, _bq24190_pull_up) == false)
+		goto _bq24190_handle_fail;
+	
+	_bq24190_last_fault = val;
+	
+	debug_log_ex("BQF  ", false);
+	debug_log_hex(val);
+	
+	val = (_bq24190_last_status >> BQ24190_SHIFTS_CHARGER_STATUS) & BQ24190_CHRG_STAT_MASK;
+	
+	if (_state.blink_error == BlinkError_None)
+	{
+		switch (val)
+		{
+			case BQ24190_CHRG_STAT_PRE_CHARGE:
+			case BQ24190_CHRG_STAT_FAST_CHARGING:
+			//case BQ24190_CHRG_STAT_CHARGE_TERMINATION_DONE:
+			{
+				if ((_state.battery_not_present == false)/* &&
+					(_ltc4155_last_good & (LTC4155_WALLSNS_GOOD | LTC4155_USBSNS_GOOD))*/)
+				{
+					//charge_set_led(true);
+					charge_notify(true);
+					break;
+				}
+			}
+			//case BQ24190_CHRG_STAT_NOT_CHARGING:
+			default:
+				//charge_set_led(false);
+				charge_notify(false);
+		}
+	}
+	
+//	bq24190_dump();
+	
+	result = true;
+_bq24190_handle_fail:
+	return result;
+}
+
+bool bq24190_handle_irq(void)	// IRQ is pulsed (not held)
+{
+	pmc_mask_irqs(true);
+	
+	//_delay_ms(250);	// [Wait for registers to update]
+	
+	bool result = _bq24190_handle_irq();
+	
+	pmc_mask_irqs(false);
+	
+	return result;
+}
+
+//void bq24190_dump(void)
+/*
+bool bq24190_set_charge_current_limit(uint8_t deciamps)
+{
+	return true;
+}
+*/
+#endif // CHARGER_TI
diff --git a/firmware/e300/rev_b/bq24190.h b/firmware/e300/rev_b/bq24190.h
new file mode 100644
index 000000000..dc20ca796
--- /dev/null
+++ b/firmware/e300/rev_b/bq24190.h
@@ -0,0 +1,26 @@
+/*
+ * bq24190.h
+ *
+ * Created: 11/12/2012 4:58:23 PM
+ *  Author: Balint Seeber
+ */ 
+
+
+#ifndef BQ24190_H_
+#define BQ24190_H_
+
+#include <stdbool.h>
+#include <stdint.h>
+
+#ifdef CHARGER_TI
+
+bool bq24190_init(bool disable_charger);
+bool bq24190_has_interrupt(void);
+bool bq24190_handle_irq(void);
+//void bq24190_dump(void);
+//bool bq24190_set_charge_current_limit(uint8_t deciamps);
+bool bq24190_toggle_charger(bool on);
+
+#endif // !CHARGER_TI
+
+#endif /* BQ24190_H_ */
diff --git a/firmware/e300/rev_b/config.h b/firmware/e300/rev_b/config.h
new file mode 100644
index 000000000..2547f65f0
--- /dev/null
+++ b/firmware/e300/rev_b/config.h
@@ -0,0 +1,2 @@
+#define __DELAY_BACKWARD_COMPATIBLE__   // Avoid compile-time arg error to '__builtin_avr_delay_cycles'
+#define F_CPU   1000000UL // 1 MHz (8MHz / 8)
diff --git a/firmware/e300/rev_b/debug.c b/firmware/e300/rev_b/debug.c
new file mode 100644
index 000000000..ff7d09445
--- /dev/null
+++ b/firmware/e300/rev_b/debug.c
@@ -0,0 +1,297 @@
+/*
+ * debug.c
+ */
+
+#include "config.h"
+#include "debug.h"
+
+#include <util/delay.h>
+#include <avr/io.h>
+#include <avr/interrupt.h>
+
+#include "io.h"
+#include "power.h"
+#include "global.h"
+
+#define DEBUG_BLINK_DELAY	250	// ms
+
+#ifdef ATTINY88_DIP
+
+#define SERIAL_DEBUG_INDEX			6
+#define SERIAL_DEBUG_PORT			PORTD
+static io_pin_t SERIAL_DEBUG      = IO_PD(SERIAL_DEBUG_INDEX);
+
+#else
+/*
+#ifdef I2C_REWORK
+//static io_pin_t SERIAL_DEBUG      = IO_PC(1);	// EN1
+#else
+//static io_pin_t SERIAL_DEBUG      = EN4;
+#endif // I2C_REWORK
+*/
+// No good: PWR_EN4 trace still connected to LTC3675
+//#define SERIAL_DEBUG_INDEX			1
+//#define SERIAL_DEBUG_PORT			PORTA
+//static io_pin_t SERIAL_DEBUG      = IO_PA(SERIAL_DEBUG_INDEX);
+
+// AVR_MISO
+#define SERIAL_DEBUG_INDEX			4
+#define SERIAL_DEBUG_PORT			PORTB
+static io_pin_t SERIAL_DEBUG      = IO_PB(SERIAL_DEBUG_INDEX);
+
+#endif // ATTINY88_DIP
+/*
+#ifdef DEBUG
+
+#else
+
+#endif // DEBUG
+*/
+#ifdef DEBUG
+
+#ifdef ATTINY88_DIP
+static io_pin_t DEBUG_1 = IO_PB(6);
+static io_pin_t DEBUG_2	= IO_PB(7);
+#endif // ATTINY88_DIP
+
+void debug_init()
+{
+	io_output_pin(DEBUG_1);
+	io_output_pin(DEBUG_2);
+	
+	io_enable_pin(DEBUG_1, true);
+	io_enable_pin(DEBUG_2, true);
+#ifdef ENABLE_SERIAL	
+	io_set_pin(SERIAL_DEBUG);
+	io_output_pin(SERIAL_DEBUG);
+#endif // ENABLE_SERIAL
+}
+
+#else
+
+void debug_init()
+{
+#ifdef ENABLE_SERIAL
+	io_set_pin(SERIAL_DEBUG);
+	io_output_pin(SERIAL_DEBUG);
+#endif // ENABLE_SERIAL
+}
+
+#endif // DEBUG
+
+#if defined(DEBUG) && !defined(DEBUG_VOID)
+
+void debug_set(io_pin_t pin, bool enable)
+{
+	io_enable_pin(pin, !enable);
+}
+
+void debug_blink(uint8_t count)
+{
+	io_enable_pin(DEBUG_1, false);
+	io_enable_pin(DEBUG_2, true);
+	_delay_ms(DEBUG_BLINK_DELAY * 2);
+
+	for (; count > 0; count--) {
+		io_enable_pin(DEBUG_2, false);
+		_delay_ms(DEBUG_BLINK_DELAY);
+		io_enable_pin(DEBUG_2, true);
+		_delay_ms(DEBUG_BLINK_DELAY);
+	}
+
+	io_enable_pin(DEBUG_1, true);
+	io_enable_pin(DEBUG_2, true);
+	_delay_ms(DEBUG_BLINK_DELAY * 2);
+}
+
+void debug_blink_rev(uint8_t count)
+{
+	io_enable_pin(DEBUG_2, false);
+	io_enable_pin(DEBUG_1, true);
+	_delay_ms(DEBUG_BLINK_DELAY * 2);
+
+	for (; count > 0; count--) {
+		io_enable_pin(DEBUG_1, false);
+		_delay_ms(DEBUG_BLINK_DELAY);
+		io_enable_pin(DEBUG_1, true);
+		_delay_ms(DEBUG_BLINK_DELAY);
+	}
+
+	io_enable_pin(DEBUG_2, true);
+	io_enable_pin(DEBUG_1, true);
+	_delay_ms(DEBUG_BLINK_DELAY * 2);
+}
+
+void debug_blink2(uint8_t count)
+{
+	io_enable_pin(DEBUG_1, true);
+	io_enable_pin(DEBUG_2, true);
+	_delay_ms(DEBUG_BLINK_DELAY * 2);
+
+	bool b = false;
+	for (; count > 0; count--) {
+		io_enable_pin(DEBUG_1, b);
+		io_enable_pin(DEBUG_2, b);
+		_delay_ms(DEBUG_BLINK_DELAY);
+		b = !b;
+	}
+
+	io_enable_pin(DEBUG_1, true);
+	io_enable_pin(DEBUG_2, true);
+	_delay_ms(DEBUG_BLINK_DELAY * 2);
+}
+
+void debug_wait(void)
+{
+	io_enable_pin(DEBUG_1, true);
+	io_enable_pin(DEBUG_2, true);
+	
+	bool b = false;
+	while (true)
+	{
+		io_enable_pin(DEBUG_1, b);
+		io_enable_pin(DEBUG_2, !b);
+		
+		_delay_ms(DEBUG_BLINK_DELAY);
+		
+		b = !b;
+	}
+	
+	io_enable_pin(DEBUG_1, true);
+	io_enable_pin(DEBUG_2, true);
+}
+
+#else
+
+#ifndef DEBUG_VOID
+
+void debug_blink_rev(uint8_t count)
+{
+	charge_set_led(true);
+	_delay_ms(DEBUG_BLINK_DELAY * 4);
+
+	for (; count > 0; count--) {
+		charge_set_led(false);
+		_delay_ms(DEBUG_BLINK_DELAY);
+		charge_set_led(true);
+		_delay_ms(DEBUG_BLINK_DELAY * 2);
+	}
+
+	_delay_ms(DEBUG_BLINK_DELAY * 2);
+	charge_set_led(false);
+	_delay_ms(DEBUG_BLINK_DELAY * 4);
+}
+#endif // DEBUG_VOID
+
+#endif // DEBUG
+
+#ifdef ENABLE_SERIAL
+
+static void _serial_tx(uint8_t* buffer)
+{
+	//uint8_t time_fix = 0;
+	// 3333/2 - 10
+	// 650
+	//	[-2 for DEV] -20 works (perhaps different USB-Serial converter)
+	//	[-20 for PRD] Which board?
+	//	+20 Board #5 (-0: 3.592, -10: 3.280)
+	const uint16_t delay = 650+20;
+	uint16_t countdown;
+	
+	for (uint8_t j = 0; j < 10; ++j)
+	{
+		if (buffer[j])
+		SERIAL_DEBUG_PORT |= _BV(SERIAL_DEBUG_INDEX);
+		else
+		SERIAL_DEBUG_PORT &= ~_BV(SERIAL_DEBUG_INDEX);
+		
+		countdown = delay;
+		while (--countdown)
+		__asm("nop");
+	}
+}
+
+static void _serial_tx_char(char c)
+{
+	uint8_t buffer[10];
+	uint8_t i = 0;
+	
+	buffer[i++] = 0;	// START
+	for (int idx = 0; idx < 8; ++idx)
+	buffer[i++] = (((uint8_t)(c) & ((uint8_t)1<<((idx)))) ? 0x01 : 0x00);	// Endianness: 7-
+	buffer[i++] = 1;	// STOP
+	
+	_serial_tx(buffer);
+}
+
+void debug_log_ex_P(const char* message, bool new_line)
+{
+	char c = pgm_read_byte(message);
+	if (c == '\0')
+		return;
+	
+	pmc_mask_irqs(true);
+
+	do
+	{
+		_serial_tx_char(c);
+		c = pgm_read_byte(++message);
+	} while (c != '\0');
+	
+	if (new_line)
+		_serial_tx_char('\n');
+
+	io_set_pin(SERIAL_DEBUG);
+	
+	pmc_mask_irqs(false);
+}
+
+void _debug_log_ex(const char* message, bool new_line)
+{
+	if (message[0] == '\0')
+	return;
+	
+	pmc_mask_irqs(true);
+
+	do
+	{
+		_serial_tx_char(*message);
+	} while (*(++message) != '\0');
+	
+	if (new_line)
+	_serial_tx_char('\n');
+
+	io_set_pin(SERIAL_DEBUG);
+	
+	pmc_mask_irqs(false);
+}
+
+void debug_log_byte_ex(uint8_t n, bool new_line)
+{
+	char ch[4];
+	ch[0] = '0' + (n / 100);
+	ch[1] = '0' + ((n % 100) / 10);
+	ch[2] = '0' + (n % 10);
+	ch[3] = '\0';
+	_debug_log_ex(ch, new_line);
+}
+
+void debug_log_hex_ex(uint8_t n, bool new_line)
+{
+	char ch[4];
+	ch[0] = 'x';
+	uint8_t _n = n >> 4;
+	if (_n < 10)
+		ch[1] = '0' + _n;
+	else
+		ch[1] = 'A' + (_n - 10);
+	n &= 0x0F;
+	if (n < 10)
+		ch[2] = '0' + n;
+	else
+		ch[2] = 'A' + (n - 10);
+	ch[3] = '\0';
+	_debug_log_ex(ch, new_line);
+}
+
+#endif // ENABLE_SERIAL
diff --git a/firmware/e300/rev_b/debug.h b/firmware/e300/rev_b/debug.h
new file mode 100644
index 000000000..5e6435972
--- /dev/null
+++ b/firmware/e300/rev_b/debug.h
@@ -0,0 +1,90 @@
+/*
+ * debug.h
+ */ 
+
+#ifndef DEBUG_H_
+#define DEBUG_H_
+
+#include <stdint.h>
+#include <stdbool.h>
+#include <avr/pgmspace.h>
+
+#include "io.h"
+
+#ifdef DEBUG
+#define DEBUG_INLINE
+#define DEBUG_NOOP	;
+#define LED_ON		false
+#define LED_OFF		true
+#else
+#define DEBUG_INLINE inline
+#define DEBUG_NOOP	{}
+#define LED_ON		true
+#define LED_OFF		false
+#endif // DEBUG
+
+//#define DEBUG_VOID
+#define DEBUG_SAFETY
+
+#ifdef DEBUG_VOID
+
+//#define debug_init	(void)
+#define debug_set	(void)
+#define debug_blink	(void)
+#define debug_blink_rev	(void)
+#define debug_blink2 (void)
+#define debug_wait	(void)
+
+#else
+
+//DEBUG_INLINE void debug_init(void) DEBUG_NOOP
+DEBUG_INLINE void debug_set(io_pin_t pin, bool enable) DEBUG_NOOP
+DEBUG_INLINE void debug_blink(uint8_t count) DEBUG_NOOP
+//DEBUG_INLINE void debug_blink_rev(uint8_t count) DEBUG_NOOP
+void debug_blink_rev(uint8_t count);
+DEBUG_INLINE void debug_blink2(uint8_t count) DEBUG_NOOP
+DEBUG_INLINE void debug_wait(void) DEBUG_NOOP
+
+#endif // DEBUG_VOID
+
+#if defined(DEBUG) && !defined(ENABLE_SERIAL)
+#define ENABLE_SERIAL
+#endif // DEBUG && !ENABLE_SERIAL
+
+/*DEBUG_INLINE */void debug_init(void)/* DEBUG_NOOP*/;
+
+#ifdef ENABLE_SERIAL
+
+void debug_log_ex_P(const char* message, bool new_line);
+void debug_log_hex_ex(uint8_t n, bool new_line);
+void debug_log_byte_ex(uint8_t n, bool new_line);
+void _debug_log_ex(const char* message, bool new_line);
+
+// Prototypes to silence avr-gcc
+inline void debug_log_P(const char* message);
+inline void debug_log_hex(uint8_t n);
+inline void debug_log_byte(uint8_t n);
+inline void _debug_log(const char* message);
+
+inline void debug_log_P(const char* message) { debug_log_ex_P(message, true); }
+inline void debug_log_hex(uint8_t n) { debug_log_hex_ex(n, true); }
+inline void debug_log_byte(uint8_t n) { debug_log_byte_ex(n, true); }
+inline void _debug_log(const char* message) { _debug_log_ex(message, true); }
+
+#else
+
+inline void debug_log_ex_P		(const char* message, bool new_line) {};
+inline void debug_log_hex_ex	(uint8_t n, bool new_line) {};
+inline void debug_log_byte_ex	(uint8_t n, bool new_line) {};
+inline void _debug_log_ex		(const char* message, bool new_line) {};
+
+#define debug_log_P			(void)
+#define debug_log_hex		(void)
+#define debug_log_byte		(void)
+#define _debug_log			(void)
+#endif // ENABLE_SERIAL
+
+#define debug_log(x)		debug_log_P(PSTR(x))
+#define debug_log_ex(x,nl)	debug_log_ex_P(PSTR(x), nl)
+
+#endif /* DEBUG_H_ */
diff --git a/firmware/e300/rev_b/error.h b/firmware/e300/rev_b/error.h
new file mode 100644
index 000000000..82a8f0aca
--- /dev/null
+++ b/firmware/e300/rev_b/error.h
@@ -0,0 +1,31 @@
+/*
+ * error.h
+ *
+ * Created: 4/09/2012 6:25:53 PM
+ *  Author: Balint Seeber
+ */ 
+
+
+#ifndef ERROR_H_
+#define ERROR_H_
+
+enum ErrorBlinkCount	// Lower number = higher priority
+{
+	BlinkError_None,
+	// Low power/battery
+	BlinkError_LowVoltage,
+	BlinkError_LTC3675_UnderVoltage = BlinkError_LowVoltage,
+	BlinkError_LTC4155_UnderVoltage = BlinkError_LowVoltage,	// FIXME: This does not work when checking status
+	// Should match power boot steps
+	BlinkError_FPGA_Power,
+	BlinkError_DRAM_Power,
+	BlinkError_1_8V_Peripherals_Power,
+	BlinkError_3_3V_Peripherals_Power,
+	BlinkError_TX_Power,
+	// LTC3675
+	BlinkError_LTC3675_OverTemperature,
+	// LTC4155
+	BlinkError_LTC4155_BadCell
+};
+
+#endif /* ERROR_H_ */
diff --git a/firmware/e300/rev_b/global.h b/firmware/e300/rev_b/global.h
new file mode 100644
index 000000000..50fab581d
--- /dev/null
+++ b/firmware/e300/rev_b/global.h
@@ -0,0 +1,49 @@
+/*
+ * global.h
+ *
+ * Created: 31/08/2012 8:47:14 PM
+ *  Author: Balint Seeber
+ */ 
+
+#ifndef GLOBAL_H_
+#define GLOBAL_H_
+
+#include <stdbool.h>
+#include <stdint.h>
+#include <avr/pgmspace.h>
+
+typedef struct State
+{
+	bool interrupts_enabled;
+	uint8_t interrupt_depth;
+	//bool timers_running;
+	uint8_t active_timers;
+	bool powered;
+	bool battery_not_present;
+	bool battery_charging;
+	bool wake_up;
+	bool power_off;
+	bool core_power_bad;
+	bool ltc3675_irq;
+#ifdef CHARGER_TI
+	bool bq24190_irq;
+#else
+	bool ltc4155_irq;
+#endif // CHARGER_TI
+	//bool low_battery;
+	uint8_t blink_error;
+	uint8_t blinker_state;
+	uint8_t blink_loops;
+	uint8_t blink_last_loop;
+	bool blink_stop;
+} STATE;
+
+//extern volatile bool _timers_running;
+extern volatile STATE _state;
+
+void pmc_set_blink_error(uint8_t count);
+uint8_t pmc_get_blink_error(void);
+
+bool pmc_mask_irqs(bool mask);
+
+#endif /* GLOBAL_H_ */
diff --git a/firmware/e300/rev_b/i2c.c b/firmware/e300/rev_b/i2c.c
new file mode 100644
index 000000000..70a28e61a
--- /dev/null
+++ b/firmware/e300/rev_b/i2c.c
@@ -0,0 +1,518 @@
+#include "config.h"
+#include "i2c.h"
+
+#include <util/delay.h>
+
+#include "io.h"
+#include "debug.h"
+
+/*
+	- Reset bus on failure (lack of ACK, etc)
+	- Clock stretching
+	- In pull-up mode, much code was commented out to ever avoid driving the bus (for a fleeting moment) as this was visible on the scope as short peaks (instead the line will briefly go Hi Z).
+*/
+
+volatile bool _i2c_disable_ack_check = false;
+
+// FIXME: Follow magic numbers should be in a struct that is passed into each function
+
+#define I2C_DEFAULT_RETRY_DELAY     1   // us MAGIC
+#define I2C_DEFAULT_MAX_ACK_RETRIES 10  // * I2C_DEFAULT_RETRY_DELAY us
+
+#define I2C_DEFAULT_BUS_WAIT		10	// us MAGIC
+#define I2C_DEFAULT_MAX_BUS_RETRIES	10
+
+#define I2C_DEFAULT_SCL_LOW_PERIOD  2   // 1.3 us
+#define I2C_DEFAULT_SCL_HIGH_PERIOD 1   // 0.6 us
+#define I2C_DEFAULT_BUS_FREE_TIME   2   // 1.3 us
+#define I2C_DEFAULT_STOP_TIME       1   // 0.6 us
+
+#define I2C_DELAY	_delay_us	// _delay_ms
+
+static bool _i2c_start_ex(io_pin_t sda, io_pin_t scl, bool pull_up)
+{
+	// Assumes: SDA/SCL are both inputs
+
+	uint8_t retries = I2C_DEFAULT_MAX_BUS_RETRIES;
+	while ((io_test_pin(sda) == false) || (io_test_pin(scl) == false))
+	{
+		I2C_DELAY(I2C_DEFAULT_BUS_WAIT);
+		if (retries-- == 0)
+		{
+debug_log("I2C:S1");
+			return false;
+		}			
+	}
+	
+	// START condition
+//	if (pull_up == false)
+		io_clear_pin(sda);	// Set LOW before switching to output
+	io_output_pin(sda);
+//	if (pull_up)
+//		io_clear_pin(sda);
+	I2C_DELAY(I2C_DEFAULT_SCL_LOW_PERIOD);  // Thd, sta
+	
+	retries = I2C_DEFAULT_MAX_BUS_RETRIES;
+	while (io_test_pin(scl) == false)	// SCL should remain high
+	{
+		I2C_DELAY(I2C_DEFAULT_BUS_WAIT);
+		if (retries-- == 0)
+		{
+			io_input_pin(sda);
+debug_log_ex("I2C:S2", false);
+debug_log_hex(scl);
+			return false;
+		}			
+	}
+
+//	if (pull_up == false)
+		io_clear_pin(scl);
+	io_output_pin(scl);
+//	if (pull_up)
+//		io_clear_pin(scl);
+	I2C_DELAY(I2C_DEFAULT_SCL_LOW_PERIOD / 2);   // MAGIC
+
+	return true;
+}
+
+static bool _i2c_stop_ex(io_pin_t sda, io_pin_t scl, bool pull_up)
+{
+	// Assumes:
+	//	SCL is output & LOW
+	//	SDA is input (Hi-Z, or pull-up enabled)
+	
+	// Assuming pull-up already enabled
+	//if (pull_up)
+	//	io_set_pin(sda);
+	
+	bool result = true;
+	
+	// SDA should be HIGH after ACK has been clocked away
+//	bool skip_drive = false;
+	uint8_t retries = 0;
+	while (io_test_pin(sda) == false)
+	{
+		if (retries == I2C_DEFAULT_MAX_ACK_RETRIES)
+		{
+			debug_log_ex("I2C:STP ", false);
+			debug_log_hex(sda);
+			debug_blink_rev(4);
+			
+//			skip_drive = true;
+			result = false;
+			break;	// SDA is being held low?!
+		}
+
+		++retries;
+		I2C_DELAY(I2C_DEFAULT_RETRY_DELAY);
+	}
+	
+	// STOP condition
+//	if ((pull_up == false) || (skip_drive))
+		io_clear_pin(sda);	// Don't tri-state if internal pull-up is used
+//	//else
+//	// Pin will now be driven, but having checked SDA is HIGH above means slave's SDA should be Open Collector (i.e. it won't blow up)
+	io_output_pin(sda);	// Drive LOW
+//	if (pull_up)
+//		io_clear_pin(sda);
+
+	///////////////////////////////////
+	
+//	if (pull_up)
+//		io_set_pin(scl);	// Don't tri-state if internal pull-up is used. Line will be driven, but assuming this is the only master on the clock line (i.e. no one else will pull it low).
+	io_input_pin(scl);
+	if (pull_up)
+		io_set_pin(scl);
+	I2C_DELAY(I2C_DEFAULT_STOP_TIME);
+	
+	///////////////////////////////////
+
+//	if ((pull_up) && (skip_drive == false))
+//		io_set_pin(sda);	// Don't tri-state if internal pull-up is used
+	io_input_pin(sda);
+//	if ((pull_up) && (skip_drive))
+		io_set_pin(sda);
+	I2C_DELAY(I2C_DEFAULT_BUS_FREE_TIME);
+	
+	return result;
+}
+/*
+static void _i2c_stop(io_pin_t sda, io_pin_t scl)
+{
+	_i2c_stop_ex(sda, scl, false);
+}
+*//*
+static void _i2c_abort_safe_ex(io_pin_t pin, bool pull_up)
+{
+	if (io_is_output(pin))
+	{
+		if (io_is_pin_set(pin))	// This is bad - hope no slave is pulling down the line
+		{
+			io_input_pin(pin);	// Pull-up already enabled
+			
+			if (pull_up == false)
+				io_clear_pin(pin);	// Doing this after changing direction ensures the line is not brought down
+		}
+		else	// Currently pulling line down
+		{
+			io_input_pin(pin);	// Hi-Z
+			
+			if (pull_up)	// There will be a moment where the line will float (better than driving the line though...)
+			{
+				io_set_pin(pin);
+			}
+		}
+	}
+	else	// Already an input
+	{
+		if (pull_up)
+		{
+			io_set_pin(pin);	// Enable pull-ups
+		}
+		else
+		{
+			io_clear_pin(pin);	// Disable pull-ups
+		}
+	}
+	
+	// Normally: pin will be Hi-Z input
+	// With internal pull-up: pin will be input with pull-up enabled
+}
+*/
+static void _i2c_abort_safe(io_pin_t pin, bool pull_up)
+{
+	if (pull_up == false)
+		io_clear_pin(pin);	// Should never be output/HIGH, could be input/<was outputting HIGH> so disable pull-ups
+	
+	io_input_pin(pin);
+	
+	if (pull_up)
+		io_set_pin(pin);	// Enable pull-up
+}
+
+static void _i2c_abort_ex(io_pin_t sda, io_pin_t scl, bool pull_up)
+{
+/*	if (pull_up == false)
+	{
+		io_clear_pin(sda);
+		io_clear_pin(scl);
+	}
+	
+	io_input_pin(scl);
+	io_input_pin(sda);
+	
+	if (pull_up)
+	{
+		io_set_pin(sda);
+		io_set_pin(scl);
+	}
+*/
+	_i2c_abort_safe(scl, pull_up);
+	_i2c_abort_safe(sda, pull_up);
+
+	//_i2c_abort_safe_ex(scl, pull_up);
+	//_i2c_abort_safe_ex(sda, pull_up);
+}
+/*
+static void _i2c_abort(io_pin_t sda, io_pin_t scl)
+{
+	_i2c_abort_ex(sda, scl, false);
+}
+*/
+static bool _i2c_write_byte_ex(io_pin_t sda, io_pin_t scl, uint8_t value, bool pull_up)
+{
+    // Assumes:
+    //  SDA output is LOW
+    //  SCL output is LOW
+
+    for (uint8_t i = 0; i < 8; ++i)
+    {
+		bool b = ((value & (0x01 << (7 - i))) != 0x00);	// MSB first
+		
+		if (b)
+		{
+			if (pull_up)
+			{
+//				io_set_pin(sda);	// This is bad (will drive line for a moment), but more stable than letting line float
+				io_input_pin(sda);
+				io_set_pin(sda);
+			}				
+			else
+				io_input_pin(sda);	// Release HIGH
+			
+			if (io_test_pin(sda) == false)
+			{
+				debug_log("I2C:WR ");
+				debug_log_hex(sda);
+				debug_blink_rev(1);
+				return false;
+			}			
+		}			
+		else
+		{
+			if (pull_up)
+			{
+//				if (io_is_output(sda))
+					io_clear_pin(sda);
+//				else
+//				{
+					io_output_pin(sda);	// [This is bad (will drive line for a moment), but more stable than letting line float]
+//					io_clear_pin(sda);
+//				}
+			}
+			else
+			{
+				io_enable_pin(sda, false);
+				io_output_pin(sda);	// Drive LOW
+			}				
+		}
+		
+		///////////////////////////////
+
+        io_input_pin(scl);	// Release HIGH
+		if (pull_up)
+			io_set_pin(scl);
+        I2C_DELAY(I2C_DEFAULT_SCL_HIGH_PERIOD);
+#ifdef I2C_ALLOW_CLOCK_STRETCH
+		uint8_t retries = I2C_DEFAULT_MAX_BUS_RETRIES;
+		while (io_test_pin(scl) == false)	// Clock stretch requested?
+		{
+			I2C_DELAY(I2C_DEFAULT_BUS_WAIT);
+			if (--retries == 0)
+			{
+				io_input_pin(sda);	// Release HIGH
+				if (pull_up)
+					io_set_pin(sda);
+				
+				debug_log_ex("I2C:STRTCH ", false);
+				debug_log_hex(scl);
+				debug_blink_rev(2);
+				return false;
+			}
+		}
+#endif // I2C_ALLOW_CLOCK_STRETCH
+		if (pull_up)
+			io_clear_pin(scl);
+        io_output_pin(scl);	// Drive LOW
+        I2C_DELAY(I2C_DEFAULT_SCL_LOW_PERIOD);
+    }
+
+    io_input_pin(sda);	// Release HIGH
+	if (pull_up)
+		io_set_pin(sda);	// Assuming letting line float won't confuse slave when pulling line LOW for ACK
+    I2C_DELAY(I2C_DEFAULT_SCL_HIGH_PERIOD);
+
+    uint8_t retries = 0;
+    while ((_i2c_disable_ack_check == false) && (io_test_pin(sda)))
+    {
+        if (retries == I2C_DEFAULT_MAX_ACK_RETRIES)
+		{
+			debug_log_ex("I2C:ACK ", false);
+			debug_log_hex_ex(sda, false);
+			debug_log_hex(value);
+			debug_blink_rev(3);
+            return false;	// Will abort and not release bus - done by caller
+		}
+
+        ++retries;
+        I2C_DELAY(I2C_DEFAULT_RETRY_DELAY);
+    }
+
+    // Clock away acknowledge
+//	if (pull_up)
+//		io_set_pin(scl);
+    io_input_pin(scl);	// Release HIGH
+	if (pull_up)
+		io_set_pin(scl);
+    I2C_DELAY(I2C_DEFAULT_SCL_HIGH_PERIOD);
+
+	if (pull_up)
+		io_clear_pin(scl);
+    io_output_pin(scl);	// Drive LOW
+//	if (pull_up)
+//		io_clear_pin(scl);
+    I2C_DELAY(I2C_DEFAULT_SCL_LOW_PERIOD);
+
+    return true;
+}
+
+static bool _i2c_read_byte_ex(io_pin_t sda, io_pin_t scl, uint8_t* value, bool pull_up)
+{
+    // Assumes:
+    //  SDA output is LOW
+    //  SCL output is LOW
+	
+	io_input_pin(sda);
+	if (pull_up)
+		io_set_pin(sda);	// OK to leave line floating for a moment (better not to drive as slave will be pulling it to ground)
+
+    (*value) = 0x00;
+
+    for (uint8_t i = 0; i < 8; ++i)
+    {
+//		if (pull_up)
+//			io_set_pin(scl);	// [Not ideal with pull-up]
+        io_input_pin(scl);	// Release HIGH
+		if (pull_up)
+			io_set_pin(scl);
+        I2C_DELAY(I2C_DEFAULT_SCL_HIGH_PERIOD);
+#ifdef I2C_ALLOW_CLOCK_STRETCH
+		uint8_t retries = I2C_DEFAULT_MAX_BUS_RETRIES;
+		while (io_test_pin(scl) == false)	// Clock stretch requested?
+		{
+			I2C_DELAY(I2C_DEFAULT_BUS_WAIT);
+			if (--retries == 0)
+			{
+				debug_log_ex("I2C:R ");
+				debug_log_hex(scl);
+				debug_blink_rev(5);
+				return false;
+			}				
+		}
+#endif // I2C_ALLOW_CLOCK_STRETCH
+        (*value) |= ((io_test_pin(sda) ? 0x1 : 0x0) << (7 - i));   // MSB first
+
+		if (pull_up)
+			io_clear_pin(scl);
+        io_output_pin(scl);	// Drive LOW (not ideal with pull-up)
+//		if (pull_up)
+//			io_clear_pin(scl);
+        I2C_DELAY(I2C_DEFAULT_SCL_LOW_PERIOD);
+    }
+
+    // Not necessary to ACK since it's only this one byte
+
+    return true;
+}
+
+bool i2c_read2_ex(io_pin_t sda, io_pin_t scl, uint8_t addr, uint8_t subaddr, uint8_t* value, bool pull_up)
+{
+	if (_i2c_start_ex(sda, scl, pull_up) == false)
+		return false;
+
+	if (_i2c_write_byte_ex(sda, scl, addr & ~0x01, pull_up) == false)
+	{
+#ifdef I2C_EXTRA_DEBUGGING
+		//debug_log_ex("R21:", false);
+		debug_log("R21");
+		//debug_log_hex(addr);
+#endif // I2C_EXTRA_DEBUGGING
+		goto i2c_read2_fail;
+	}
+
+	if (_i2c_write_byte_ex(sda, scl, subaddr, pull_up) == false)
+	{
+#ifdef I2C_EXTRA_DEBUGGING
+		//debug_log_ex("R22:", false);
+		debug_log("R22");
+		//debug_log_hex(subaddr);
+#endif // I2C_EXTRA_DEBUGGING
+		goto i2c_read2_fail;
+	}
+	
+	io_input_pin(scl);
+	if (pull_up)
+		io_set_pin(scl);
+	I2C_DELAY(I2C_DEFAULT_BUS_WAIT);
+	
+	if (_i2c_start_ex(sda, scl, pull_up) == false)
+	{
+		return false;
+	}
+	
+	if (_i2c_write_byte_ex(sda, scl, addr | 0x01, pull_up) == false)
+	{
+#ifdef I2C_EXTRA_DEBUGGING
+		//debug_log_ex("R23:", false);
+		debug_log("R23");
+		//debug_log_hex(addr);
+#endif // I2C_EXTRA_DEBUGGING
+		goto i2c_read2_fail;
+	}
+
+	if (_i2c_read_byte_ex(sda, scl, value, pull_up) == false)
+	{
+#ifdef I2C_EXTRA_DEBUGGING
+		//debug_log_ex("R24:", false);
+		debug_log("R24");
+		//debug_log_hex(*value);
+#endif // I2C_EXTRA_DEBUGGING
+		goto i2c_read2_fail;
+	}
+	
+	if (_i2c_stop_ex(sda, scl, pull_up) == false)
+	{
+#ifdef I2C_EXTRA_DEBUGGING
+		debug_log("R25");
+#endif // I2C_EXTRA_DEBUGGING
+	}
+
+	return true;
+i2c_read2_fail:
+	_i2c_abort_ex(sda, scl, pull_up);
+	return false;
+}
+
+bool i2c_write_ex(io_pin_t sda, io_pin_t scl, uint8_t addr, uint8_t subaddr, uint8_t value, bool pull_up)
+{
+	if (_i2c_start_ex(sda, scl, pull_up) == false)
+		return false;
+
+    if (_i2c_write_byte_ex(sda, scl, addr, pull_up) == false)
+        goto i2c_write_fail;
+
+    if (_i2c_write_byte_ex(sda, scl, subaddr, pull_up) == false)
+        goto i2c_write_fail;
+
+    if (_i2c_write_byte_ex(sda, scl, value, pull_up) == false)
+        goto i2c_write_fail;
+
+    _i2c_stop_ex(sda, scl, pull_up);
+
+    return true;
+i2c_write_fail:
+	_i2c_abort_ex(sda, scl, pull_up);
+	return false;
+}
+
+bool i2c_write(io_pin_t sda, io_pin_t scl, uint8_t addr, uint8_t subaddr, uint8_t value)
+{
+	return i2c_write_ex(sda, scl, addr, subaddr, value, false);
+}
+
+bool i2c_read_ex(io_pin_t sda, io_pin_t scl, uint8_t addr, uint8_t subaddr, uint8_t* value, bool pull_up)
+{
+    if (_i2c_start_ex(sda, scl, pull_up) == false)
+		return false;
+
+    if (_i2c_write_byte_ex(sda, scl, addr, pull_up) == false)
+        goto i2c_read_fail;
+
+    if (_i2c_write_byte_ex(sda, scl, subaddr, pull_up) == false)
+        goto i2c_read_fail;
+
+    if (_i2c_read_byte_ex(sda, scl, value, pull_up) == false)
+        goto i2c_read_fail;
+
+    _i2c_stop_ex(sda, scl, pull_up);
+
+    return true;
+i2c_read_fail:
+	_i2c_abort_ex(sda, scl, pull_up);
+	return false;
+}
+
+bool i2c_read(io_pin_t sda, io_pin_t scl, uint8_t addr, uint8_t subaddr, uint8_t* value)
+{
+	return i2c_read_ex(sda, scl, addr, subaddr, value, false);
+}
+
+void i2c_init_ex(io_pin_t sda, io_pin_t scl, bool pull_up)
+{
+	_i2c_abort_ex(sda, scl, pull_up);
+}
+
+void i2c_init(io_pin_t sda, io_pin_t scl)
+{
+	i2c_init_ex(sda, scl, false);
+}
diff --git a/firmware/e300/rev_b/i2c.h b/firmware/e300/rev_b/i2c.h
new file mode 100644
index 000000000..5898e7e43
--- /dev/null
+++ b/firmware/e300/rev_b/i2c.h
@@ -0,0 +1,17 @@
+#ifndef I2C_H
+#define I2C_H
+
+#include "io.h"
+
+void i2c_init(io_pin_t sda, io_pin_t scl);
+bool i2c_read(io_pin_t sda, io_pin_t scl, uint8_t addr, uint8_t subaddr, uint8_t* value);
+bool i2c_write(io_pin_t sda, io_pin_t scl, uint8_t addr, uint8_t subaddr, uint8_t value);
+
+void i2c_init_ex(io_pin_t sda, io_pin_t scl, bool pull_up);
+bool i2c_read_ex(io_pin_t sda, io_pin_t scl, uint8_t addr, uint8_t subaddr, uint8_t* value, bool pull_up);
+bool i2c_read2_ex(io_pin_t sda, io_pin_t scl, uint8_t addr, uint8_t subaddr, uint8_t* value, bool pull_up);
+bool i2c_write_ex(io_pin_t sda, io_pin_t scl, uint8_t addr, uint8_t subaddr, uint8_t value, bool pull_up);
+
+extern volatile bool _i2c_disable_ack_check;
+
+#endif // I2C_H
diff --git a/firmware/e300/rev_b/io.c b/firmware/e300/rev_b/io.c
new file mode 100644
index 000000000..0256181c6
--- /dev/null
+++ b/firmware/e300/rev_b/io.c
@@ -0,0 +1,75 @@
+/*
+ * Copyright 2009-2012 Ettus Research LLC
+ */
+
+#include "io.h"
+#include <avr/io.h>
+
+#define _GET_PIN(pin)           ((pin) & 0xf)
+#define _GET_MASK(pin)          (_BV(_GET_PIN(pin)))
+#define _GET_REG(pin, reg_x)    (*reg_x[pin >> 4])
+
+#ifndef IO_DEBUG
+static volatile uint8_t *ddr_x[] = {&DDRA, &DDRB, &DDRC, &DDRD};		// 0: input, 1: output
+static volatile uint8_t *port_x[] = {&PORTA, &PORTB, &PORTC, &PORTD};	// Port contents (will appear at output if direction is set to output. If input, '1' enables pull-ups, '0' set tri-state)
+static volatile uint8_t *pin_x[] = {&PINA, &PINB, &PINC, &PIND};		// Port contents (input) If output, will return value on PORT
+#endif
+
+void io_output_pin(io_pin_t pin){
+#ifndef IO_DEBUG
+	_GET_REG(pin, ddr_x) |= _GET_MASK(pin);
+#endif
+}
+
+void io_input_pin(io_pin_t pin){
+#ifndef IO_DEBUG
+	_GET_REG(pin, ddr_x) &= ~_GET_MASK(pin);
+#endif
+}
+
+bool io_is_output(io_pin_t pin){
+#ifndef IO_DEBUG
+	return bit_is_set(_GET_REG(pin, ddr_x), _GET_PIN(pin));
+#else
+	return 0;
+#endif
+}
+
+bool io_is_input(io_pin_t pin){
+	return !io_is_output(pin);
+}
+
+void io_set_pin(io_pin_t pin){	// In input mode, will enable pull-ups
+#ifndef IO_DEBUG
+	_GET_REG(pin, port_x) |= _GET_MASK(pin);
+#endif
+}
+
+void io_clear_pin(io_pin_t pin){	// In input mode, will disable pull-ups
+#ifndef IO_DEBUG
+	_GET_REG(pin, port_x) &= ~_GET_MASK(pin);
+#endif
+}
+
+bool io_is_pin_set(io_pin_t pin){
+#ifndef IO_DEBUG
+	return bit_is_set(_GET_REG(pin, port_x), _GET_PIN(pin));
+#else
+	return 0;
+#endif
+}
+
+void io_enable_pin(io_pin_t pin, bool enable){
+    if (enable)
+        io_set_pin(pin);
+    else
+        io_clear_pin(pin);
+}
+
+bool io_test_pin(io_pin_t pin){
+#ifndef IO_DEBUG
+	return bit_is_set(_GET_REG(pin, pin_x), _GET_PIN(pin));
+#else
+	return 0;
+#endif
+}
diff --git a/firmware/e300/rev_b/io.h b/firmware/e300/rev_b/io.h
new file mode 100644
index 000000000..7eea8f0a3
--- /dev/null
+++ b/firmware/e300/rev_b/io.h
@@ -0,0 +1,31 @@
+/*
+ * Copyright 2009 Ettus Research LLC
+ */
+
+#ifndef IO_H
+#define IO_H
+
+#include <stdint.h>
+#include <stdbool.h>
+
+#define IO_PX(port, pin) ((uint8_t)(((port - 'A') << 4) + pin))
+#define IO_PA(pin) IO_PX('A', pin)
+#define IO_PB(pin) IO_PX('B', pin)
+#define IO_PC(pin) IO_PX('C', pin)
+#define IO_PD(pin) IO_PX('D', pin)
+
+typedef const uint8_t io_pin_t;
+
+void io_output_pin(io_pin_t pin);
+void io_input_pin(io_pin_t pin);
+bool io_is_output(io_pin_t pin);
+bool io_is_input(io_pin_t pin);
+
+void io_set_pin(io_pin_t pin);
+void io_clear_pin(io_pin_t pin);
+void io_enable_pin(io_pin_t pin, bool enable);
+bool io_is_pin_set(io_pin_t pin);
+
+bool io_test_pin(io_pin_t pin);
+
+#endif /* IO_H */
diff --git a/firmware/e300/rev_b/ltc3675.c b/firmware/e300/rev_b/ltc3675.c
new file mode 100644
index 000000000..0f85ec7e5
--- /dev/null
+++ b/firmware/e300/rev_b/ltc3675.c
@@ -0,0 +1,525 @@
+/*
+ * Copyright 2012 Ettus Research LLC
+ */
+
+/*
+    ? STOP condition after writing address on read
+    - Default buck/boost register values are OK
+*/
+
+#include "config.h"
+#include "ltc3675.h"
+
+//#include <stdio.h>
+#include <util/delay.h>
+#include <avr/interrupt.h>
+
+#include "io.h"
+#include "i2c.h"
+#include "debug.h"
+#include "global.h"
+#include "error.h"
+
+#ifndef I2C_REWORK
+#include "power.h"
+#endif // I2C_REWORK
+
+const bool _ltc3675_pull_up =
+#ifdef I2C_REWORK
+	true
+#else
+	false
+#endif // I2C_REWORK
+;
+
+volatile ltc3675_reg_helper_fn _ltc3675_reg_helper;
+
+//#define HARDWIRE_ENABLE	// Use hardware enable pins instead of I2C on regulators that support it
+
+#ifdef ATTINY88_DIP
+
+#ifdef HARDWIRE_ENABLE
+static io_pin_t PWR_EN1     = IO_PC(7);	// Not routed by card
+static io_pin_t PWR_EN2     = IO_PA(0);	// Not available on DIP
+static io_pin_t PWR_EN3     = IO_PA(1);	// Not available on DIP
+static io_pin_t PWR_EN4     = IO_PB(6);	// Instead of FTDI_BCD
+static io_pin_t PWR_EN5     = IO_PB(7);	// Instead of FTDI_PWREN2
+#endif // HARDWIRE_ENABLE
+
+//static io_pin_t PWR_SDA     = IO_PC(4);
+//static io_pin_t PWR_SCL     = IO_PC(5);
+
+#else
+
+#ifdef HARDWIRE_ENABLE
+static io_pin_t PWR_EN1     = IO_PC(1);
+//static io_pin_t PWR_EN2     = IO_PC(2);	// Now used by I2C for charge controller
+//static io_pin_t PWR_EN3     = IO_PC(3);	// Now used by I2C for charge controller
+static io_pin_t PWR_EN4     = IO_PA(1);
+static io_pin_t PWR_EN5     = IO_PA(2);
+#endif // HARDWIRE_ENABLE
+
+#ifdef I2C_REWORK
+static io_pin_t PWR_SDA     = IO_PC(2);		// Instead of EN5
+static io_pin_t PWR_SCL     = IO_PA(2);		// Instead of EN2
+#endif // I2C_REWORK
+
+#endif // ATTINY88_DIP
+
+static io_pin_t PWR_IRQ     = IO_PD(0);
+static io_pin_t WAKEUP      = IO_PD(2);
+static io_pin_t ONSWITCH_DB = IO_PD(3);
+static io_pin_t PWR_RESET   = IO_PD(4);
+
+#define LTC3675_BASE_ADDRESS    0x12
+#define LTC3675_WRITE_ADDRESS   (LTC3675_BASE_ADDRESS + 0)
+#define LTC3675_READ_ADDRESS    (LTC3675_BASE_ADDRESS + 1)
+
+#define LTC3675_RETRY_DELAY     1   // us MAGIC
+#define LTC3675_MAX_ACK_RETRIES 10  // * LTC3675_RETRY_DELAY us
+
+#define LTC3675_SCL_LOW_PERIOD  2   // 1.3 us
+#define LTC3675_SCL_HIGH_PERIOD 1   // 0.6 us
+#define LTC3675_BUS_FREE_TIME   2   // 1.3 us
+#define LTC3675_STOP_TIME       1   // 0.6 us
+
+#define LTC3675_REGULATOR_ENABLE_DELAY	10	// 50	// ms (some arbitrary value so that the external power supply can settle)
+
+enum LTC3675Registers
+{
+	LTC3675_REG_NONE			= 0x00,
+	LTC3675_REG_BUCK1			= 0x01,
+	LTC3675_REG_BUCK2			= 0x02,
+	LTC3675_REG_BUCK3			= 0x03,
+	LTC3675_REG_BUCK4			= 0x04,
+	LTC3675_REG_BOOST			= 0x05,
+	LTC3675_REG_BUCK_BOOST		= 0x06,
+	LTC3675_REG_LED_CONFIG		= 0x07,
+	LTC3675_REG_LED_DAC			= 0x08,
+	LTC3675_REG_UVOT			= 0x09,
+	LTC3675_REG_RSTB			= 0xA0,
+	LTC3675_REG_IRQB_MASK		= 0x0B,
+	LTC3675_REG_REALTIME_STATUS	= 0x0C,
+	LTC3675_REG_LATCHED_STATUS	= 0x0D,
+	LTC3675_REG_CLEAR_IRQ		= 0x0F
+};
+
+enum LTC3675StatusBits
+{
+	LTC3675_UnderVoltage	= 1 << 7,
+	LTC3675_OverTemperature	= 1 << 6,
+	LTC3675_BuckBoost_PGood	= 1 << 5,
+	LTC3675_Boost_PGood		= 1 << 4,
+	LTC3675_Buck4_PGood		= 1 << 3,
+	LTC3675_Buck3_PGood		= 1 << 2,
+	LTC3675_Buck2_PGood		= 1 << 1,
+	LTC3675_Buck1_PGood		= 1 << 0
+};
+
+#define LTC3675_DEFAULT_BUCK_REG_VAL		0x6F
+#define LTC3675_DEFAULT_BOOST_REG_VAL		0x0F
+#define LTC3675_DEFAULT_BUCK_BOOST_REG_VAL	0x0F
+
+#define LTC3675_ENABLE_REGISTER_BIT			0x80
+
+// Max I2C rate = 400kHz
+
+static void _ltc3675_clear_irq()
+{
+	// Two-stage clear
+	i2c_write_ex(PWR_SDA, PWR_SCL, LTC3675_WRITE_ADDRESS, LTC3675_REG_CLEAR_IRQ, 0x00, _ltc3675_pull_up);
+	i2c_write_ex(PWR_SDA, PWR_SCL, LTC3675_WRITE_ADDRESS, LTC3675_REG_NONE, 0x00, _ltc3675_pull_up);
+}
+
+volatile uint8_t _ltc3675_last_status = 0x00;
+
+uint8_t ltc3675_get_last_status(void)
+{
+	return _ltc3675_last_status;
+}
+
+uint8_t ltc3675_reg_status_to_error(uint8_t val)
+{
+	if (((val & LTC3675_BuckBoost_PGood) == 0) && ((_ltc3675_reg_helper)(LTC3675_REG_6)))
+		return BlinkError_3_3V_Peripherals_Power;
+	
+	if (((val & LTC3675_Boost_PGood) == 0) && ((_ltc3675_reg_helper)(LTC3675_REG_5)))
+		return BlinkError_TX_Power;
+	
+	//if (((val & LTC3675_Buck4_PGood) == 0) && ((_ltc3675_reg_helper)(LTC3675_REG_4)))
+	
+	if (((val & LTC3675_Buck3_PGood) == 0) && ((_ltc3675_reg_helper)(LTC3675_REG_3)))
+		return BlinkError_1_8V_Peripherals_Power;
+	
+	//if (((val & LTC3675_Buck2_PGood) == 0) && ((_ltc3675_reg_helper)(LTC3675_REG_2)))
+	
+	if (((val & LTC3675_Buck1_PGood) == 0) && ((_ltc3675_reg_helper)(LTC3675_REG_1)))
+		return BlinkError_DRAM_Power;
+	
+	return BlinkError_None;
+}
+
+bool ltc3675_is_power_good(uint8_t val)
+{
+	return (ltc3675_reg_status_to_error(val) == BlinkError_None);
+}
+
+uint8_t ltc3675_status_to_error(uint8_t val)
+{
+	if (val & LTC3675_UnderVoltage)
+		return BlinkError_LTC3675_UnderVoltage;
+	
+	if (val & LTC3675_OverTemperature)
+		return BlinkError_LTC3675_OverTemperature;
+	
+	uint8_t reg_error = ltc3675_reg_status_to_error(val);
+	if (reg_error != BlinkError_None)
+		return reg_error;
+	
+	return BlinkError_None;
+}
+
+bool _ltc3675_handle_irq(void)
+{
+	uint8_t val = 0x00;
+	bool result = false;
+	
+	if (i2c_read2_ex(PWR_SDA, PWR_SCL, LTC3675_READ_ADDRESS, LTC3675_REG_LATCHED_STATUS, &val, _ltc3675_pull_up))
+	{
+		debug_log_ex("3675LTCH ", false);
+		debug_log_hex(val);
+	}
+	
+	if (i2c_read2_ex(PWR_SDA, PWR_SCL, LTC3675_READ_ADDRESS, /*LTC3675_REG_LATCHED_STATUS*/LTC3675_REG_REALTIME_STATUS, &val, _ltc3675_pull_up))	// No point acting on latched because could have been resolved
+	{
+		//debug_log_ex("3675LTCH ", false);
+		debug_log_ex("3675RT ", false);
+		debug_log_hex(val);
+		
+		_ltc3675_last_status = val;
+		
+		uint8_t error = ltc3675_status_to_error(val);
+		
+		/*if (val & LTC3675_UnderVoltage)
+		{
+			pmc_set_blink_error(BlinkError_LTC3675_UnderVoltage);
+			//_state.low_battery = true;
+		}*/
+		
+		if (error)
+		{
+			pmc_set_blink_error(error);
+			
+			/*_i2c_disable_ack_check = true;
+			uint8_t chk = 0x00;
+			chk |= (_ltc3675_reg_helper)(LTC3675_REG_6) << 0;
+			chk |= (_ltc3675_reg_helper)(LTC3675_REG_5) << 1;
+			chk |= (_ltc3675_reg_helper)(LTC3675_REG_3) << 2;
+			chk |= (_ltc3675_reg_helper)(LTC3675_REG_1) << 3;
+			i2c_write_ex(PWR_SDA, PWR_SCL, 0xFE, 0xFF, chk, _ltc3675_pull_up);
+			_i2c_disable_ack_check = false;*/
+		}			
+		
+		result = true;
+	}
+	
+	_ltc3675_clear_irq();
+	
+	return result;
+}
+
+static bool _ltc3675_get_realtime_status(uint8_t* val)
+{
+	//cli();
+	
+	if (i2c_read2_ex(PWR_SDA, PWR_SCL, LTC3675_READ_ADDRESS, LTC3675_REG_REALTIME_STATUS, val, _ltc3675_pull_up) == false)
+		return false;
+	
+	debug_log_ex("3675RT ", false);
+	debug_log_hex(*val);
+	
+	//sei();
+	
+	return true;
+}
+
+int8_t ltc3675_check_status(void)
+{
+	uint8_t val = 0x00;
+	
+	pmc_mask_irqs(true);
+	
+	bool result = _ltc3675_get_realtime_status(&val);
+	
+	pmc_mask_irqs(false);
+	
+	if (result == false)
+		return -1;
+	
+	//_ltc3675_last_status = val;
+	
+	/*if (val & LTC3675_UnderVoltage)
+		return BlinkError_LTC3675_UnderVoltage;
+	
+	if (val & LTC3675_OverTemperature)
+		return BlinkError_LTC3675_OverTemperature;
+	
+	return BlinkError_None;*/
+	
+	return ltc3675_status_to_error(val);
+}
+
+bool ltc3675_handle_irq(void)
+{
+	pmc_mask_irqs(true);
+	
+	/*uint8_t*/bool result = _ltc3675_handle_irq();
+	
+	pmc_mask_irqs(false);
+	
+	return result;
+}
+
+static bool _ltc3675_default_reg_helper(uint8_t address)
+{
+	uint8_t val = 0x00;
+	i2c_read2_ex(PWR_SDA, PWR_SCL, LTC3675_READ_ADDRESS, address, &val, _ltc3675_pull_up);
+	return ((val & LTC3675_ENABLE_REGISTER_BIT) == LTC3675_ENABLE_REGISTER_BIT);
+}
+
+bool ltc3675_init(ltc3675_reg_helper_fn helper)
+{
+	if (helper)
+		_ltc3675_reg_helper = helper;
+	else
+		_ltc3675_reg_helper = _ltc3675_default_reg_helper;
+#ifdef HARDWIRE_ENABLE
+    io_output_pin(PWR_EN1);
+    io_output_pin(PWR_EN2);
+    io_output_pin(PWR_EN3);
+    io_output_pin(PWR_EN4);
+    io_output_pin(PWR_EN5);
+#endif // HARDWIRE_ENABLE
+
+ /*	io_output_pin(PWR_SDA);
+    io_output_pin(PWR_SCL);
+
+    // Must remain HIGH when idle
+    io_set_pin(PWR_SDA);
+    io_set_pin(PWR_SCL);
+*/
+#ifdef I2C_REWORK
+	i2c_init_ex(PWR_SDA, PWR_SCL, _ltc3675_pull_up);
+#endif // I2C_REWORK
+    io_input_pin(PWR_IRQ);
+#if !defined(DEBUG) && !defined(ATTINY88_DIP)
+	io_set_pin(PWR_IRQ);	// Enable pull-up for Open Drain
+#endif // DEBUG
+	
+    io_input_pin(WAKEUP);
+	io_set_pin(WAKEUP);	// Enable pull-up for Open Drain
+	
+    io_input_pin(ONSWITCH_DB);
+	io_set_pin(ONSWITCH_DB);	// Enable pull-up for Open Drain
+	
+    io_input_pin(PWR_RESET);
+	io_set_pin(PWR_RESET);	// Enable pull-up for Open Drain
+	
+	_ltc3675_clear_irq();	// Clear old interrupt - state might have changed (e.g. undervoltage might have been resolved)
+
+    if (i2c_write_ex(PWR_SDA, PWR_SCL, LTC3675_WRITE_ADDRESS, LTC3675_REG_IRQB_MASK, 0xFF, _ltc3675_pull_up) == false)	// Any PGOOD fault will pull IRQB low
+		return false;
+	
+	if (i2c_write_ex(PWR_SDA, PWR_SCL, LTC3675_WRITE_ADDRESS, LTC3675_REG_UVOT, 0x70, _ltc3675_pull_up) == false)	// 3.4V UV
+		return false;
+	
+	if (ltc3675_has_interrupt())
+		_ltc3675_handle_irq();
+	
+	// Non-maskable:
+	//	UV warning threshold (default): 2.7V
+	//	Over temp warning threshold (default): 10 degrees below
+
+    return true;
+}
+
+bool ltc3675_is_waking_up(void)
+{
+	return io_test_pin(WAKEUP);
+}
+
+static bool _ltc3675_is_pgood(uint8_t reg)
+{
+	uint8_t val = 0x00;
+	if (_ltc3675_get_realtime_status(&val) == false)
+		return false;
+	return ((reg & val) == reg);
+}
+
+static bool _ltc3675_toggle_reg(uint8_t addr, uint8_t def_reg, bool on)
+{
+	bool result = true;
+	
+	//cli();
+	
+	uint8_t val = 0x00 | def_reg;
+	if (i2c_read2_ex(PWR_SDA, PWR_SCL, LTC3675_READ_ADDRESS, addr, &val, _ltc3675_pull_up) == false)
+		return false;
+	
+	val &= ~LTC3675_ENABLE_REGISTER_BIT;
+	
+	if (i2c_write_ex(PWR_SDA, PWR_SCL, LTC3675_WRITE_ADDRESS, addr, /*def_reg*/val | (on ? LTC3675_ENABLE_REGISTER_BIT : 0x00), _ltc3675_pull_up) == false)
+		//return true;
+		result = false;
+	
+	if (on)
+	{
+		_delay_ms(LTC3675_REGULATOR_ENABLE_DELAY);
+	}
+	
+	//sei();
+
+	return result;
+	//return true;
+}
+
+bool ltc3675_enable_reg(ltc3675_regulator_t reg, bool on)
+{
+	//debug_blink2(reg + 1);
+	debug_log_ex("3675 ", false);
+	debug_log_byte_ex(reg, true);
+	
+	// Sub-address: index of regulator
+	// Data: <default reg contents> | <enable>
+	
+	bool result = false;
+	
+    switch (reg)
+    {
+        case LTC3675_REG_1: // Master
+        case LTC3675_REG_2: // Slave
+#ifdef HARDWIRE_ENABLE
+            io_enable_pin(PWR_EN1, on);
+			//break;
+#else
+			//debug_blink2(reg + 1);
+			if (_ltc3675_toggle_reg(LTC3675_REG_BUCK1, LTC3675_DEFAULT_BUCK_REG_VAL, on) == false) {
+				//debug_blink2(reg + 1);
+				return false;
+			}
+			//debug_blink2(reg + 1);
+#endif // HARDWIRE_ENABLE
+			result = (_ltc3675_is_pgood(LTC3675_Buck1_PGood) == on);
+			break;
+        case LTC3675_REG_3: // Master
+        case LTC3675_REG_4: // Slave
+#ifdef HARDWIRE_ENABLE
+            io_enable_pin(PWR_EN3, on);
+            //break;
+#else
+			if (_ltc3675_toggle_reg(LTC3675_REG_BUCK3, LTC3675_DEFAULT_BUCK_REG_VAL, on) == false)
+				return false;
+#endif // HARDWIRE_ENABLE
+			result = (_ltc3675_is_pgood(LTC3675_Buck3_PGood) == on);
+			break;
+        case LTC3675_REG_5: // I2C only
+            if (_ltc3675_toggle_reg(LTC3675_REG_BOOST, LTC3675_DEFAULT_BOOST_REG_VAL, on) == false)    // (Boost address, Default reg contents | Enable)
+				return false;
+			result = (_ltc3675_is_pgood(LTC3675_Boost_PGood) == on);
+			break;
+        case LTC3675_REG_6: // Single
+#ifdef HARDWIRE_ENABLE
+            io_enable_pin(PWR_EN5, on);
+            //break;
+#else
+			if (_ltc3675_toggle_reg(LTC3675_REG_BUCK_BOOST, LTC3675_DEFAULT_BUCK_BOOST_REG_VAL, on) == false)
+				return false;
+#endif // HARDWIRE_ENABLE
+			result = (_ltc3675_is_pgood(LTC3675_BuckBoost_PGood) == on);
+			break;
+        //default:
+		//	return false;
+    }
+	
+	_debug_log((result ? "+" : "-"));
+
+    return result;
+}
+
+bool ltc3675_set_voltage(ltc3675_regulator_t reg, uint16_t voltage)
+{
+    // Not necessary due to R-bridges and default DAC registers
+
+    // VRAM will be 1.3579 - a little high? (re-program DAC reference)
+    //  No: minimum FB step will put Vout < 1.35
+	
+	uint16_t max_voltage = 0;
+	uint8_t reg_subaddr = 0;
+	
+	switch (reg)
+	{
+		case LTC3675_REG_1:	// 1A Buck
+		case LTC3675_REG_2:	// 1A Buck
+			max_voltage = 1500;
+			reg_subaddr = LTC3675_REG_BUCK1;
+			break;
+		case LTC3675_REG_3:	// 500mA Buck
+		case LTC3675_REG_4:	// 500mA Buck
+			max_voltage = 1800;
+			reg_subaddr = LTC3675_REG_BUCK3;
+			break;
+		case LTC3675_REG_5:	// 1A Boost
+			max_voltage = 5000;
+			reg_subaddr = LTC3675_REG_BOOST;
+			break;
+		case LTC3675_REG_6:	// 1A Buck-Boost
+			max_voltage = 3300;
+			reg_subaddr = LTC3675_REG_BUCK_BOOST;
+			break;
+	}
+	
+	if (voltage > max_voltage)
+		return false;
+	
+	//uint32_t rMax = ((uint32_t)voltage * 1000) / (uint32_t)max_voltage;
+	//uint32_t rFB = ((uint32_t)max_voltage * 1000) / (uint32_t)800;
+	uint32_t rFB = ((uint32_t)max_voltage * 1000) / (uint32_t)800;	// 800mV full-scale feedback voltage
+	uint32_t r = ((uint32_t)voltage * 1000) / (uint32_t)rFB;
+	if (r < 450)
+		return false;
+	
+	uint16_t rDAC = (16 * ((uint16_t)r - 450)) / (800 - 450);
+	
+	debug_log_ex("Vr ", false);
+	debug_log_byte_ex(reg, false);
+	debug_log_ex("=", false);
+	debug_log_byte_ex((uint8_t)rDAC, false);
+	
+	uint8_t val = 0x00;
+	if (i2c_read2_ex(PWR_SDA, PWR_SCL, LTC3675_READ_ADDRESS, reg_subaddr, &val, _ltc3675_pull_up) == false)
+	{
+		debug_log("-");
+		return false;
+	}		
+	
+	val = (val & 0xF0) | (uint8_t)rDAC;
+	if (i2c_write_ex(PWR_SDA, PWR_SCL, LTC3675_WRITE_ADDRESS, reg_subaddr, val, _ltc3675_pull_up) == false)
+	{
+		debug_log("-");
+		return false;
+	}
+	
+	debug_log("+");
+
+	return true;
+}
+
+bool ltc3675_is_power_button_depressed(void)
+{
+	return (io_test_pin(ONSWITCH_DB) == false);
+}
+
+bool ltc3675_has_interrupt(void)
+{
+	return (io_test_pin(PWR_IRQ) == false);
+}
diff --git a/firmware/e300/rev_b/ltc3675.h b/firmware/e300/rev_b/ltc3675.h
new file mode 100644
index 000000000..d7c4baa59
--- /dev/null
+++ b/firmware/e300/rev_b/ltc3675.h
@@ -0,0 +1,37 @@
+/*
+ * Copyright 2012 Ettus Research LLC
+ */
+
+#ifndef LTC3675_H
+#define LTC3675_H
+
+//#include "types.h"
+#include <stdbool.h>
+#include <stdint.h>
+
+typedef bool (*ltc3675_reg_helper_fn)(uint8_t address);
+
+bool ltc3675_init(ltc3675_reg_helper_fn helper);
+
+typedef enum ltc3675_regulators {
+    LTC3675_REG_1,  // 1A Buck
+    LTC3675_REG_2,  // 1A Buck
+    LTC3675_REG_3,  // 500mA Buck
+    LTC3675_REG_4,  // 500mA Buck
+    LTC3675_REG_5,  // 1A Boost
+    LTC3675_REG_6   // 1A Buck-Boost
+    // LED Boost
+} ltc3675_regulator_t;
+
+bool ltc3675_enable_reg(ltc3675_regulator_t reg, bool on);
+bool ltc3675_set_voltage(ltc3675_regulator_t reg, uint16_t voltage);
+bool ltc3675_is_power_button_depressed(void);
+bool ltc3675_has_interrupt(void);
+bool ltc3675_handle_irq(void);
+int8_t ltc3675_check_status(void);
+uint8_t ltc3675_get_last_status(void);
+uint8_t ltc3675_status_to_error(uint8_t val);
+bool ltc3675_is_power_good(uint8_t val);
+bool ltc3675_is_waking_up(void);
+
+#endif /* LTC3675_H */
diff --git a/firmware/e300/rev_b/ltc4155.c b/firmware/e300/rev_b/ltc4155.c
new file mode 100644
index 000000000..5f404e651
--- /dev/null
+++ b/firmware/e300/rev_b/ltc4155.c
@@ -0,0 +1,402 @@
+/*
+ * ltc4155.c
+ */ 
+
+#ifndef CHARGER_TI
+
+#include "config.h"
+#include "ltc4155.h"
+
+#include <util/delay.h>
+
+#include "io.h"
+#include "i2c.h"
+#include "power.h"
+#include "debug.h"
+#include "global.h"
+#include "error.h"
+
+static io_pin_t USBPM_IRQ	= IO_PB(1);
+
+#ifdef ATTINY88_DIP
+
+static io_pin_t CHRG_SDA     = IO_PC(2);
+static io_pin_t CHRG_SCL     = IO_PC(3);
+
+#else
+
+#ifdef I2C_REWORK
+
+static io_pin_t CHRG_SDA     = IO_PC(4);
+static io_pin_t CHRG_SCL     = IO_PC(5);
+
+#else
+
+#define CHRG_SDA	PWR_SDA
+#define CHRG_SCL	PWR_SCL
+
+#endif // I2C_REWORK
+
+#endif // ATTINY88_DIP
+
+const bool _ltc4155_pull_up = false;
+
+#define LTC4155_BASE_ADDRESS    0x12
+#define LTC4155_WRITE_ADDRESS   (LTC4155_BASE_ADDRESS + 0)
+#define LTC4155_READ_ADDRESS    (LTC4155_BASE_ADDRESS + 1)
+/*
+#define LTC4155_RETRY_DELAY     1   // us MAGIC
+#define LTC4155_MAX_ACK_RETRIES 10  // * LTC4155_RETRY_DELAY us
+
+#define LTC4155_SCL_LOW_PERIOD  2   // 1.3 us
+#define LTC4155_SCL_HIGH_PERIOD 1   // 0.6 us
+#define LTC4155_BUS_FREE_TIME   2   // 1.3 us
+#define LTC4155_STOP_TIME       1   // 0.6 us
+*/
+enum LTC4155Registers
+{
+	LTC4155_REG_USB			= 0x00,	// W/R
+	LTC4155_REG_WALL		= 0x01,	// W/R
+	LTC4155_REG_CHARGE		= 0x02,	// W/R
+	LTC4155_REG_STATUS		= 0x03,	// R
+	LTC4155_REG_GOOD		= 0x04,	// R
+	LTC4155_REG_THERMISTOR	= 0x05,	// R
+	LTC4155_REG_ENABLE		= 0x06,	// W/R
+	LTC4155_REG_ARM_AND_SHIP= 0x07	// W
+};
+
+enum LTC4155InterruptMasks	// LTC4155_REG_ENABLE
+{
+	LTC4155_ENABLE_USB_OTG	= 1 << 1,
+	
+	LTC4155_INT_UVCL	= 1 << 2,
+	LTC4155_INT_ILIMIT	= 1 << 3,
+	LTC4155_INT_USB_OTG	= 1 << 4,
+	LTC4155_INT_EXT_PWR	= 1 << 5,
+	LTC4155_INT_FAULT	= 1 << 6,
+	LTC4155_INT_CHARGER	= 1 << 7
+};
+
+enum LTC4155Options	// LTC4155_REG_USB
+{
+	LTC4155_USB_OTG_LOCKOUT				= 1 << 5,
+	LTC4155_ENABLE_BATTERY_CONDITIONER	= 1 << 6,
+	LTC4155_DISABLE_INPUT_UVCL			= 1 << 7
+};
+
+enum LTC4155Shifts
+{
+	LTC4155_SHIFTS_CHARGE_CURRENT_LIMIT	= 4,
+	LTC4155_SHIFTS_CHARGE_FLOAT_VOLTAGE	= 2,
+	LTC4155_SHIFTS_WALL_PRIORITY		= 7,
+	LTC4155_SHIFTS_WALL_SAFETY_TIMER	= 5
+};
+
+enum LTC4155Statuses	// LTC4155_REG_STATUS
+{
+	LTC4155_LOW_BATTERY		= 1 << 0,
+	LTC4155_BOOST_ENABLE	= 1 << 3,
+	LTC4155_ID_PIN_DETECT	= 1 << 4,
+};
+
+enum LTC4155Goods	// LTC4155_REG_GOOD
+{
+	LTC4155_BAD_CELL_FAULT		= 1 << 0,
+	LTC4155_OTG_FAULT			= 1 << 1,
+	LTC4155_OVP_ACTIVE			= 1 << 2,
+	LTC4155_INPUT_UVCL_ACTIVE	= 1 << 3,
+	LTC4155_INPUT_CURRENT_LIMIT_ACTIVE = 1 << 4,
+	LTC4155_WALLSNS_GOOD		= 1 << 5,
+	LTC4155_USBSNS_GOOD			= 1 << 6,
+	LTC4155_EXTERNAL_POWER_GOOD	= 1 << 7
+};
+
+enum LTC4155BatteryChargerStatues
+{
+	LTC4155_CHARGER_OFF,
+	LTC4155_CHARGER_LOW_BATTERY_VOLTAGE,
+	LTC4155_CHARGER_CONSTANT_CURRENT,
+	LTC4155_CHARGER_CONSTANT_VOLTAGE_VPROG_GT_VCX,
+	LTC4155_CHARGER_CONSTANT_VOLTAGE_VPROG_LT_VCX,
+	LTC4155_CHARGER_NTC_TOO_WARM,
+	LTC4155_CHARGER_NTC_TOO_COLD,
+	LTC4155_CHARGER_NTC_HOT
+};
+
+enum LTC4155ThermistorStatuses
+{
+	LTC4155_NTC_NORMAL,
+	LTC4155_NTC_TOO_COLD,
+	LTC4155_NTC_TOO_WARM,
+	LTC4155_NTC_FAULT
+};
+
+static const uint8_t _ltc4155_interrupt_mask =
+//	LTC4155_ENABLE_USB_OTG |// Enable +5V on USB connector	// Is this causing the chip to power off the output?!
+	LTC4155_INT_UVCL |
+	LTC4155_INT_ILIMIT |
+	LTC4155_INT_USB_OTG |
+	LTC4155_INT_EXT_PWR |	// Turn up current limit
+	LTC4155_INT_FAULT |		// Blink error
+	LTC4155_INT_CHARGER;	// Illuminate charge LED
+
+static bool _ltc4155_clear_irq(void)
+{
+	return i2c_write_ex(CHRG_SDA, CHRG_SCL, LTC4155_WRITE_ADDRESS, LTC4155_REG_ENABLE, _ltc4155_interrupt_mask, _ltc4155_pull_up);
+}
+
+bool ltc4155_clear_irq(void)
+{
+	pmc_mask_irqs(true);
+	
+	bool result = _ltc4155_clear_irq();
+	
+	pmc_mask_irqs(false);
+	
+	return result;
+}
+
+static uint8_t _ltc4155_last_good, _ltc4155_last_status;
+
+bool _ltc4155_handle_irq(void)
+{
+	_ltc4155_clear_irq();	// Clear frozen registers to get the real-time ones
+	
+	_delay_ms(50);	// Wait for registers to clear/update
+	
+	//////////////////
+	
+	uint8_t val = 0x00;
+	bool result = false;
+	
+	if (i2c_read2_ex(CHRG_SDA, CHRG_SCL, LTC4155_READ_ADDRESS, LTC4155_REG_GOOD, &val, _ltc4155_pull_up) == false)
+		goto _ltc4155_handle_fail;
+	
+	//if (i2c_read2_ex(CHRG_SDA, CHRG_SCL, LTC4155_READ_ADDRESS, LTC4155_REG_GOOD, &val, _ltc4155_pull_up) == false)
+	//	goto _ltc4155_handle_fail;
+	
+	debug_log_ex("4155GO ", false);
+	debug_log_hex(val);
+	
+	if (val & LTC4155_WALLSNS_GOOD)
+	{
+		uint8_t wall_state = 0;
+		if (i2c_read2_ex(CHRG_SDA, CHRG_SCL, LTC4155_READ_ADDRESS, LTC4155_REG_WALL, &wall_state, _ltc4155_pull_up) == false)
+			goto _ltc4155_handle_fail;
+		
+		wall_state &= ~0x1E;
+		wall_state |= 0x0E;
+		
+		if (i2c_write_ex(CHRG_SDA, CHRG_SCL, LTC4155_WRITE_ADDRESS, LTC4155_REG_WALL, wall_state, _ltc4155_pull_up) == false)
+			goto _ltc4155_handle_fail;
+		
+		debug_log("I+");
+	}
+	
+	_ltc4155_last_good = val;
+	
+	if (i2c_read2_ex(CHRG_SDA, CHRG_SCL, LTC4155_READ_ADDRESS, LTC4155_REG_STATUS, &val, _ltc4155_pull_up) == false)
+		goto _ltc4155_handle_fail;
+	
+	//if (i2c_read2_ex(CHRG_SDA, CHRG_SCL, LTC4155_READ_ADDRESS, LTC4155_REG_STATUS, &val, _ltc4155_pull_up) == false)
+	//	goto _ltc4155_handle_fail;
+	
+	debug_log_ex("4155ST ", false);
+	debug_log_hex(val);
+	
+	_ltc4155_last_status = val;
+	
+	val >>= 5;
+	
+	if (_state.blink_error == BlinkError_None)
+	{
+		switch (val)
+		{
+			case LTC4155_CHARGER_CONSTANT_CURRENT:
+			case LTC4155_CHARGER_CONSTANT_VOLTAGE_VPROG_GT_VCX:
+			case LTC4155_CHARGER_LOW_BATTERY_VOLTAGE:	// If this persists for more than 1/2hr, BAD_CELL_FAULT is enabled and FAULT interrupt is generated
+			{
+				if ((_state.battery_not_present == false) &&
+					(_ltc4155_last_good & (LTC4155_WALLSNS_GOOD | LTC4155_USBSNS_GOOD)))
+				{
+					//charge_set_led(true);
+					charge_notify(true);
+					break;
+				}						
+			}
+			case LTC4155_CHARGER_CONSTANT_VOLTAGE_VPROG_LT_VCX:	// Small amount of current still charging the battery but below Vc/x threshold
+			//case LTC4155_CHARGER_NTC_TOO_WARM:
+			//case LTC4155_CHARGER_NTC_TOO_COLD:
+			//case LTC4155_CHARGER_NTC_HOT:
+			//	break;
+			//case LTC4155_CHARGER_OFF:
+			default:
+				//charge_set_led(false);
+				charge_notify(false);
+		}
+	}
+	
+//	ltc4155_dump();
+	
+	result = true;
+_ltc4155_handle_fail:
+	_ltc4155_clear_irq();	// Even though it happens first above, this is necessary otherwise future IRQs won't be detected
+	
+	return result;
+}
+
+#define LTC4155_CHARGE_CURRENT_LIMIT	/*0xF*/0x7	// [100%] 50%
+
+bool ltc4155_set_charge_current_limit(uint8_t percentage)
+{
+	uint8_t val = 0;
+	uint8_t limit = 0;
+	
+	if (percentage > 100)
+		return false;
+	else if (percentage == 100)
+		percentage = 0xF;
+	else if (percentage > 12)	// 0..88 -> 0..8800
+	{
+		uint16_t l = (((uint16_t)percentage - 12) * 100) / 586;
+		limit = (uint8_t)l;
+	}
+	
+	if (i2c_read2_ex(CHRG_SDA, CHRG_SCL, LTC4155_WRITE_ADDRESS, LTC4155_REG_CHARGE, &val, _ltc4155_pull_up) == false)
+		return false;
+	
+	val &= ((0x1 << LTC4155_SHIFTS_CHARGE_CURRENT_LIMIT) - 1);
+	//val |= (LTC4155_CHARGE_CURRENT_LIMIT << LTC4155_SHIFTS_CHARGE_CURRENT_LIMIT);
+	val |= (limit << LTC4155_SHIFTS_CHARGE_CURRENT_LIMIT);
+	
+	if (i2c_write_ex(CHRG_SDA, CHRG_SCL, LTC4155_WRITE_ADDRESS, LTC4155_REG_CHARGE, val, _ltc4155_pull_up) == false)
+		return false;
+	
+//ltc4155_dump();
+	
+	return true;
+}
+
+bool ltc4155_init(bool disable_charger)
+{
+	io_input_pin(USBPM_IRQ);
+#if !defined(DEBUG) && !defined(ATTINY88_DIP)
+	io_set_pin(USBPM_IRQ);	// Enable pull-up for Open Drain
+#endif // DEBUG
+#ifdef I2C_REWORK
+	i2c_init_ex(CHRG_SDA, CHRG_SCL, _ltc4155_pull_up);
+#endif // I2C_REWORK
+	if (/*_ltc4155_clear_irq()*/_ltc4155_handle_irq() == false)	// Will set interrupt masks	// FIXME: Why does this cause instability?!
+		return false;
+
+	const uint8_t charge_state =
+		(disable_charger ? 0x0 : LTC4155_CHARGE_CURRENT_LIMIT) << LTC4155_SHIFTS_CHARGE_CURRENT_LIMIT |	// Battery charger I limit = 100%
+		0x3 << LTC4155_SHIFTS_CHARGE_FLOAT_VOLTAGE |	// FIXME: Vbatt float = 4.05V - 4.2V for LiPo (default 0x00)
+		0x0;	// Full capacity charge threshold = 10%
+	if (i2c_write_ex(CHRG_SDA, CHRG_SCL, LTC4155_WRITE_ADDRESS, LTC4155_REG_CHARGE, charge_state, _ltc4155_pull_up) == false)
+		return false;
+
+	const uint8_t wall_state =
+		0x0 << LTC4155_SHIFTS_WALL_PRIORITY |
+		0x0 << LTC4155_SHIFTS_WALL_SAFETY_TIMER |	// Charge safety timer = 4hr	// FIXME: 8hr or Vc/x
+		0xE;	// 3 amps, 0x1F - CLPROG1
+	if (i2c_write_ex(CHRG_SDA, CHRG_SCL, LTC4155_WRITE_ADDRESS, LTC4155_REG_WALL, wall_state, _ltc4155_pull_up) == false)
+		return false;
+
+	// FIXME:
+	// Disable ID pin detection & autonomous startup
+	// Enable OTG
+	//i2c_write_ex(CHRG_SDA, CHRG_SCL, LTC4155_WRITE_ADDRESS, LTC4155_REG_USB, LTC4155_USB_OTG_LOCKOUT, _ltc4155_pull_up);	// Disable autonomous startup
+	//i2c_write_ex(CHRG_SDA, CHRG_SCL, LTC4155_WRITE_ADDRESS, LTC4155_REG_ENABLE, LTC4155_ENABLE_USB_OTG, _ltc4155_pull_up);	// Enable OTG
+	
+	if (_ltc4155_handle_irq() == false)	// One more time (IRQ LED stays lit in dev setup)
+		return false;
+	
+	return true;
+}
+
+bool ltc4155_has_interrupt(void)
+{
+	//bool state = io_test_pin(USBPM_IRQ);
+	//debug_log_ex("4155IRQ", false);
+	//debug_log_byte(state);
+	//return (state != 1);
+	return (io_test_pin(USBPM_IRQ) == false);
+}
+
+bool ltc4155_handle_irq(void)
+{
+	pmc_mask_irqs(true);
+	
+	bool result = _ltc4155_handle_irq();
+	
+	pmc_mask_irqs(false);
+	
+	return result;
+}
+
+bool ltc4155_arm_ship_and_store(void)
+{
+	return true;
+}
+
+bool ltc4155_get_thermistor(uint8_t* val, bool* warning)
+{
+	bool result = false;
+	uint8_t _val = 0;
+	
+	pmc_mask_irqs(true);
+	
+	if (i2c_read2_ex(CHRG_SDA, CHRG_SCL, LTC4155_READ_ADDRESS, LTC4155_REG_THERMISTOR, &_val, _ltc4155_pull_up) == false)
+		goto ltc4155_get_thermistor_fail;
+	
+	if (val)
+		(*val) = _val >> 1;
+	
+	if (warning)
+		(*warning) = ((_val & 0x01) != 0x00);
+	
+	result = true;
+ltc4155_get_thermistor_fail:
+	pmc_mask_irqs(false);
+	return result;
+}
+
+void ltc4155_dump(void)
+{
+	pmc_mask_irqs(true);
+	
+	uint8_t val = 0x00;
+	bool warning = false;
+	
+	if (ltc4155_get_thermistor(&val, &warning) == false)
+		goto ltc4155_dump_fail;
+	
+	debug_log_ex("\tTHRM", false);
+	if (warning)
+		debug_log_ex("!", false);
+	debug_log_byte(val);
+	
+	if (i2c_read2_ex(CHRG_SDA, CHRG_SCL, LTC4155_READ_ADDRESS, LTC4155_REG_WALL, &val, _ltc4155_pull_up) == false)
+		goto ltc4155_dump_fail;
+	
+	debug_log_ex("\tWALL", false);
+	debug_log_hex(val);
+	
+	if (i2c_read2_ex(CHRG_SDA, CHRG_SCL, LTC4155_READ_ADDRESS, LTC4155_REG_GOOD, &val, _ltc4155_pull_up) == false)
+		goto ltc4155_dump_fail;
+	
+	debug_log_ex("\t4155GO ", false);
+	debug_log_hex(val);
+	
+	if (i2c_read2_ex(CHRG_SDA, CHRG_SCL, LTC4155_READ_ADDRESS, LTC4155_REG_STATUS, &val, _ltc4155_pull_up) == false)
+		goto ltc4155_dump_fail;
+	
+	debug_log_ex("\t4155ST ", false);
+	debug_log_hex(val);
+	
+ltc4155_dump_fail:
+	pmc_mask_irqs(false);
+}
+
+#endif // !CHARGER_TI
diff --git a/firmware/e300/rev_b/ltc4155.h b/firmware/e300/rev_b/ltc4155.h
new file mode 100644
index 000000000..7e8e3751d
--- /dev/null
+++ b/firmware/e300/rev_b/ltc4155.h
@@ -0,0 +1,25 @@
+/*
+ * ltc4155.h
+ *
+ * Created: 17/08/2012 8:09:43 PM
+ *  Author: Balint Seeber
+ */ 
+
+
+#ifndef LTC4155_H_
+#define LTC4155_H_
+
+#include <stdbool.h>
+#include <stdint.h>
+
+#ifndef CHARGER_TI
+
+bool ltc4155_init(bool disable_charger);
+bool ltc4155_has_interrupt(void);
+bool ltc4155_handle_irq(void);
+void ltc4155_dump(void);
+bool ltc4155_set_charge_current_limit(uint8_t percentage);
+
+#endif // !CHARGER_TI
+
+#endif /* LTC4155_H_ */
diff --git a/firmware/e300/rev_b/main.c b/firmware/e300/rev_b/main.c
new file mode 100644
index 000000000..1e065ffef
--- /dev/null
+++ b/firmware/e300/rev_b/main.c
@@ -0,0 +1,385 @@
+/*
+ * Copyright 2009 Ettus Research LLC
+ */
+
+#include "config.h"
+
+#include <stdlib.h>
+#include <string.h>
+#include <stdio.h>
+#include <avr/io.h>
+#include <util/delay.h>
+#include <avr/sleep.h>
+#include <avr/interrupt.h>
+
+#include "global.h"
+#include "power.h"
+#include "debug.h"
+#include "error.h"
+#include "ltc3675.h"
+#ifdef CHARGER_TI
+#include "bq24190.h"
+#else
+#include "ltc4155.h"
+#endif // CHARGER_TI
+
+#define AUTO_POWER_ON
+
+#define INITIAL_DELAY	250	// ms
+
+FUSES = {	// FIXME: & FUSE_CKSEL1 for low power 128 kHz clock
+	.low = (FUSE_CKSEL0 & FUSE_SUT0 & FUSE_CKDIV8),	// Internal 8MHz Oscillator, Slowly rising power (start-up time), Divide Clock by 8
+	.high = (FUSE_EESAVE & FUSE_SPIEN),	// Save EEPROM between flashes	// FIXME: Leave SPIEN for programming enabled?
+};	// Not using watchdog as it runs during sleep and consumes power
+
+volatile STATE _state;
+
+/*
+    - Main/shared variables must be volatile
+	- Port pins are tri-stated on reset
+	* AVR_IRQ PD(5)
+	- Enable pull-ups on all O.D. outputs from regulator chip
+	* PS_POR/SRST should be driven HIGH by ATTiny?
+	- AVR_RESET -> RESET pin - don't configure fuse (this would disable this functionality and prohibit serial programming)
+	* Ship-and-store mode for charge controller?
+	* cli before I2C calls
+	* PS_TX
+	- en5-clk, en2-data
+	* Instruction following SEI is executed before interrupts
+	* LTC3675 real-time status doesn't contain UV/OT
+	* LTC3675 PGOOD -> power down (no point in checking blink state)
+	* On WALL, use TX, on battery use OTG switcher
+	* PRR - Power Reduction Register (p40)
+	- 100% -> 50% battery charge limit
+	* Check latched status for UV/OT in 3675
+	* If blink error reset, get latest charge status from 4155
+	* Fix UV status check from 3675/4155 as they currently share the same error 
+	* Use charger termination at 8hr or Vc/x
+	* Check PGood on all regs after power on before setting powered=true
+	* Re-init 4155 on soft-power on
+	- Re-set 3A limit in 4155 after external power connection
+	- Removing power when running on battery, 4155GO 0xA0 - but WALL has been removed
+	- Why is charger reporting Constant Current when power is removed
+	* ltc3675_is_power_button_depressed: check if any reg is on, otherwise value will be invalid
+	* When e.g. 3.3V doesn't come up, blink code is correctly 4 but there's a very short blink before re-starting the sequence
+	- Vprog<Vc/x
+*/
+
+bool pmc_mask_irqs(bool mask)
+{
+	if (_state.interrupts_enabled == false)
+		return false;
+	
+	if (mask)
+	{
+		if (_state.interrupt_depth == 0)
+			cli();
+		++_state.interrupt_depth;
+	}		
+	else
+	{
+		if (_state.interrupt_depth == 0)
+			return false;
+		
+		--_state.interrupt_depth;
+		if (_state.interrupt_depth == 0)
+			sei();
+	}
+	
+	return true;
+}
+
+int main(void)
+{
+	_delay_ms(INITIAL_DELAY);
+	
+	///////////////////////////////////////////////////////////////////////////
+	
+	memset((void*)&_state, 0x00, sizeof(STATE));
+	
+	debug_init();
+	debug_blink(1);
+	
+	//debug_log("#");	// Will not boot if this is 21 chars long?!
+	debug_log("Hello world");
+	
+    set_sleep_mode(SLEEP_MODE_PWR_DOWN);    // SLEEP_MODE_PWR_SAVE combination is documented as Reserved
+	
+//ltc4155_dump();
+
+    // FIXME: Init as SPI slave (FPGA is master)
+	
+	// 8-bit timer for blinking errors on charge LED
+	TCCR0A = _BV(CTC0);		// CTC mode
+	OCR0A = 244;			// 250ms with 1024 prescale
+	TIMSK0 = _BV(OCIE0A);	// Enable CTC on Timer 0
+
+	bool init_result = power_init();
+	debug_log_ex("Init", false);
+	_debug_log(init_result ? "+" : "-");
+	debug_blink(2);
+	//debug_blink_rev(6);
+	
+	///////////////////////////////////
+#ifdef AUTO_POWER_ON
+	power_on(); // Turn on immediately. Need to de-press power button to turn off.
+	debug_log("Power");
+	debug_blink(3);
+	//debug_blink_rev(10);
+
+	//debug_wait();
+	
+//ltc4155_dump();
+#endif // AUTO_POWER_ON
+	_state.interrupts_enabled = true;
+	sei();	// Enable interrupts
+
+	asm("nop");
+
+	_state.wake_up = false;	// This will fire the first time the regs are turned on
+	
+	bool one_more = false;
+	
+	while (true)
+	{
+		one_more = false;
+#ifdef CHARGER_TI
+		if (_state.bq24190_irq)
+		{
+			bq24190_handle_irq();
+			
+			_state.bq24190_irq = false;
+		}
+#else
+		if ((_state.ltc4155_irq)/* || ltc4155_has_interrupt()*/)	// [Don't know why PCINT ISR misses LTC4155 IRQ on power up, so double-check state of line]
+		{
+			ltc4155_handle_irq();
+//ltc4155_dump();
+			_state.ltc4155_irq = false;
+		}
+#endif // !CHARGER_TI
+		if (_state.core_power_bad)	// FIXME: Check whether it's supposed to be on
+		{
+			if (power_is_subsys_on(PS_FPGA))
+			{
+				_delay_ms(1);	// Seeing weird 120us drop in PGOOD during boot from flash (no apparent drop in 1.0V though)
+				
+				if (tps54478_is_power_good() == false)
+				{
+					debug_log("ML:FPGA!");
+			
+					//power_off();
+					_state.power_off = true;
+			
+					/*while (_state.wake_up == false)
+					{
+						blink_error_sequence(1);
+					}*/
+					pmc_set_blink_error(BlinkError_FPGA_Power);	// [If a blink error was set in power_off, this will supercede it]
+				}
+			}			
+			
+			_state.core_power_bad = false;
+		}
+		
+		if ((_state.ltc3675_irq)/* || ltc3675_has_interrupt()*/)	// This is fired on initial power up
+		{
+			debug_log("ML:3675+");
+			
+			ltc3675_handle_irq();
+			
+			if (ltc3675_is_power_good(ltc3675_get_last_status()) == false)
+			{
+				debug_log("ML:3675!");
+				
+				//power_off();
+				_state.power_off = true;
+			}
+			
+			_state.ltc3675_irq = false;
+		}
+		
+		if (_state.power_off)
+		{
+			debug_log("ML:Off..");
+			
+			power_off();
+			
+			_state.power_off = false;
+			_state.wake_up = false;
+		}
+		else if (_state.wake_up)
+		{
+			_delay_ms(1);	// Tapping 3.1 ohm load ing 4155 in dev setup causes transient on this line and causes power on sequence to begin again
+			
+			//if (_state.powered == false)	// Don't check in case button is held long enough to force LTC3675 shutdown (will not change 'powered' value)
+			if (ltc3675_is_waking_up())
+			{
+				debug_log("ML:On..");
+				
+				power_on();
+			}
+			
+			_state.wake_up = false;
+		}
+		
+		// Check to see if the error state has resolved itself at the end of each sequence of the current blink error
+		
+		if ((_state.blink_error != BlinkError_None) && (_state.blink_last_loop != _state.blink_loops))
+		{
+			// [Check IRQs periodically]
+			
+			bool ltc3675_use_last_status = false;
+			/*if (ltc3675_has_interrupt())
+			{
+				//debug_set(IO_PB(6), ((_state.blink_loops % 2) == 0));
+				ltc3675_use_last_status = true;
+				ltc3675_handle_irq();
+			}*/
+			
+			///////////////////////////
+			
+			switch (_state.blink_error)
+			{
+				case BlinkError_LTC3675_UnderVoltage:
+				case BlinkError_LTC3675_OverTemperature:
+				case BlinkError_DRAM_Power:
+				case BlinkError_3_3V_Peripherals_Power:
+				case BlinkError_1_8V_Peripherals_Power:
+				case BlinkError_TX_Power:
+					if (((ltc3675_use_last_status) && (ltc3675_status_to_error(ltc3675_get_last_status()) != BlinkError_None)) || 
+						((ltc3675_use_last_status == false) && (ltc3675_check_status() != BlinkError_None)))
+						break;
+					debug_log("BE:3675-");
+					goto cancel_blink_error;
+				case BlinkError_FPGA_Power:
+					if (tps54478_is_power_good() == false)
+						break;
+					debug_log("BE:FPGA-");
+					goto cancel_blink_error;
+				default:
+cancel_blink_error:				
+					//debug_set(IO_PB(7), true);
+					pmc_set_blink_error(BlinkError_None);
+			}
+			
+			////////////////////////////////////
+			
+			// More periodic checks
+			// Need to do this has some interrupts are on PCINT, and while GIE is disabled, might change & change back
+			//	E.g. LTC3675 IRQ due to UV, reset IRQ, re-asserts UV
+#ifndef CHARGER_TI
+			if (ltc4155_has_interrupt())
+			{
+				debug_log("BE:4155");
+				
+				_state.ltc4155_irq = true;
+				one_more = true;
+			}
+#endif // !CHARGER_TI
+			if (ltc3675_has_interrupt())
+			{
+				debug_log("BE:3675");
+				
+				_state.ltc3675_irq = true;
+				one_more = true;
+			}
+			
+			if (power_is_subsys_on(PS_FPGA))
+			{
+				if (tps54478_is_power_good() == false)
+				{
+					debug_log("BE:FPGA!");
+				
+					_state.core_power_bad = true;
+					one_more = true;
+				}
+			}
+			
+			////////////////////////////////////
+			
+			_state.blink_last_loop = _state.blink_loops;
+		}
+		
+		//if (_state.timers_running == false)
+		if ((_state.active_timers == 0) && (one_more == false))
+		{
+			debug_log("^");
+			sleep_mode();
+			debug_log("$");
+		}			
+	}
+
+	return 0;
+}
+
+uint8_t pmc_get_blink_error(void)
+{
+	return _state.blink_error;
+}
+
+void pmc_set_blink_error(uint8_t count)
+{
+	if ((_state.blink_error != BlinkError_None) && (count /*> _state.blink_error*/!= BlinkError_None))	// [Prioritise] Always keep first sequence running
+		return;
+	else if (_state.blink_error == count)	// Don't restart if the same
+		return;
+	
+	if (count == BlinkError_None)
+	{
+		debug_log("BLNK-");
+		_state.blink_stop = true;
+		return;
+	}
+	
+	//char msg[25];
+	//sprintf(msg, "Blink code = %i\n", count);
+	//debug_log(msg);
+	debug_log_ex("BLNK ", false);
+	debug_log_byte(count);
+	
+	_state.blink_error = count;
+	_state.blink_loops = 0;
+	_state.blink_last_loop = 0;
+	_state.blinker_state = 0;
+	_state.blink_stop = false;
+
+	charge_set_led(false);
+	
+	TCNT0 = 0;
+	if ((TCCR0A & 0x07) == 0x00)	// Might already be active with existing error
+		_state.active_timers++;
+	TCCR0A |= 0x05;	// Start with 1024 prescale
+}
+
+ISR(TIMER0_COMPA_vect)	// Blink the sequence, and leave one slot at the beginning and end where the LED is off so one can get a sense of how many blinks occurred
+{
+	pmc_mask_irqs(true);
+	
+	if (_state.blinker_state < (2 * _state.blink_error + 1))
+		charge_set_led((_state.blinker_state % 2) == 1);
+	
+	_state.blinker_state++;
+	
+	if (_state.blinker_state == (2 * _state.blink_error + 1 + 1))
+	{
+		_state.blinker_state = 0;
+		
+		if (_state.blink_stop)
+		{
+			if ((TCCR0A & 0x07) != 0x00)
+				_state.active_timers--;
+			TCCR0A &= ~0x07;
+			
+			_state.blink_error = BlinkError_None;
+			
+			debug_log("BLNK.");
+		}
+		else
+		{
+			_state.blink_loops++;
+		}
+	}
+	
+	pmc_mask_irqs(false);
+}
diff --git a/firmware/e300/rev_b/power.c b/firmware/e300/rev_b/power.c
new file mode 100644
index 000000000..79864f817
--- /dev/null
+++ b/firmware/e300/rev_b/power.c
@@ -0,0 +1,909 @@
+/*
+	* Test battery voltage code
+	* Charger error blinking uses busy wait - will drain battery if encounters error while unattended? Surely rest of H/W will pull more current.
+*/
+#include "config.h"
+#include "power.h"
+
+#include <string.h>
+#include <util/delay.h>
+#include <avr/io.h>
+#include <avr/interrupt.h>
+#include <avr/sleep.h>
+
+#include "io.h"
+#include "i2c.h"
+#include "ltc3675.h"
+#include "ltc4155.h"
+#include "bq24190.h"
+#include "debug.h"
+#include "global.h"
+#include "error.h"
+
+#define BLINK_ERROR_DELAY		250  // ms
+
+#define POWER_DEFAULT_DELAY     50  // ms
+#define POWER_DEFAULT_RETRIES   10
+
+#define BATT_MIN_VOLTAGE		2000	// mV
+
+#define ARRAY_SIZE(a)			(sizeof(a)/sizeof(a[0]))
+#define ZERO_MEMORY(s)			memset(&s, 0x00, sizeof(s))
+
+#ifndef I2C_REWORK
+io_pin_t PWR_SDA     = IO_PC(4);
+io_pin_t PWR_SCL     = IO_PC(5);
+
+io_pin_t USBHUB_RESET= IO_PA(2);
+#endif // I2C_REWORK
+
+//volatile bool powered = false;
+
+#ifdef DDR3L
+#define DRAM_VOLTAGE	1350
+#else
+#define DRAM_VOLTAGE	0	// Hardware default
+#endif // DDR3
+
+struct reg_config {
+    int16_t voltage;    // mV
+	uint8_t device;
+    uint8_t address;    // Device specific
+    bool powered;
+} default_reg_config[] = {        // Index maps to 'power_subsystem_t', 0 volts means leave at hardware default
+	{ 0000, REG_UNKNOWN, 0/*, true*/ },				// PS_UNKNOWN
+	{ 1000, REG_TPS54478, 0/*, true*/ },			// PS_FPGA
+	{ DRAM_VOLTAGE, REG_LTC3675, LTC3675_REG_1 },	// PS_VDRAM
+	{ /*1800*/0, REG_LTC3675, LTC3675_REG_3 },		// PS_PERIPHERALS_1_8
+	{ /*3300*/0, REG_LTC3675, LTC3675_REG_6 },		// PS_PERIPHERALS_3_3
+	{ /*5000*/0, REG_LTC3675, LTC3675_REG_5 }		// PS_TX
+};
+/*
+int8_t power_get_regulator_index(uint8_t device, uint8_t address)
+{
+	for (int8_t i = 0; i < ARRAY_SIZE(default_reg_config); ++i)
+	{
+		struct reg_config* reg = default_reg_config + i;
+		if ((reg->device == device) && (reg->address == address))
+			return i;
+	}
+	
+	return -1;
+}
+*/
+bool power_is_subsys_on(power_subsystem_t index)
+{
+	if ((index <= PS_UNKNOWN) || (index >= PS_MAX))
+		return false;
+	
+	return default_reg_config[index].powered;
+}
+
+static bool ltc3675_reg_helper(uint8_t address)
+{
+	for (int8_t i = 0; i < ARRAY_SIZE(default_reg_config); ++i)
+	{
+		struct reg_config* reg = default_reg_config + i;
+		if ((reg->device == REG_LTC3675) && (reg->address == address))
+			return reg->powered;
+	}
+#ifdef DEBUG_SAFETY
+	debug_log_ex("!3675HLP ", false);
+	debug_log_hex(address);
+#endif // DEBUG_SAFETY
+	return false;
+	//return power_is_subsys_on(power_get_regulator_index(REG_LTC3675, address) - 1);
+}
+
+static io_pin_t AVR_CS      = IO_PB(2);
+static io_pin_t AVR_MOSI    = IO_PB(3);
+static io_pin_t AVR_MISO    = IO_PB(4);
+static io_pin_t AVR_SCK     = IO_PB(5);
+
+#ifndef ATTINY88_DIP
+static io_pin_t FTDI_BCD    = IO_PB(6);
+static io_pin_t FTDI_PWREN2 = IO_PB(7);
+#endif // ATTINY88_DIP
+
+static io_pin_t AVR_RESET   = IO_PC(6);
+static io_pin_t AVR_IRQ     = IO_PD(5);
+
+///////////////////////////////////////////////////////////////////////////////
+
+#define TPS54478_START_DELAY	10	// 50 (safety)	// 3 (per spec)	// ms (some arbitrary value so that the external power supply can settle)
+
+#ifdef ATTINY88_DIP
+static io_pin_t CORE_PWR_EN = IO_PC(1);	// IO_PC(7) not routed by card, using PWER_EN1 instead
+#else
+static io_pin_t CORE_PWR_EN = IO_PA(3);
+#endif // ATTINY88_DIP
+static io_pin_t CORE_PGOOD = IO_PB(0);
+
+void tps54478_init(bool enable)
+{
+	tps54478_set_power(enable);
+	io_clear_pin(CORE_PWR_EN);
+	
+    io_input_pin(CORE_PGOOD);
+#if !defined(DEBUG) && !defined(ATTINY88_DIP)	// Don't enable pull-up when connected to a pulled-up switch
+	io_set_pin(CORE_PGOOD);	// Enable pull-up for Open Drain
+#endif // DEBUG
+//#ifdef DEBUG
+//	io_enable_pin(CORE_PWR_EN, false);
+//#endif // DEBUG
+//_delay_ms(2500);
+}
+
+void tps54478_set_power(bool on)
+{
+	debug_log_ex("54478", false);
+	
+	// Assumes: Hi-Z input/LOW output
+	
+	if (on)
+	{
+		io_input_pin(CORE_PWR_EN);
+		_delay_ms(TPS54478_START_DELAY);
+		
+		debug_log("+");
+	}		
+	else
+	{
+		io_output_pin(CORE_PWR_EN);
+		// Don't delay here as we can't detect its state anyway
+		
+		debug_log("-");
+	}		
+	
+	//io_enable_pin(CORE_PWR_EN, on);
+}
+
+bool tps54478_is_power_good(void)
+{
+    return io_test_pin(CORE_PGOOD);	// This doesn't necessarily mean it's good - the chip might be malfunctioning (or switched off)
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+static io_pin_t CHARGE      = IO_PD(1);
+
+#if !defined(ATTINY88_DIP) && defined(LED_POLARITY)
+static io_pin_t POWER_LED	= IO_PC(7);
+
+void power_set_led_ex(bool on, bool swap)
+{
+	if (swap)
+	{
+		if ((on == false) && (/*io_is_pin_set(CHARGE)*/_state.battery_charging))	// If charging and turning off, don't change charge light
+		{
+			charge_set_led(true);	// Force it again just in case
+			return;
+		}
+	}		
+	
+	io_clear_pin(CHARGE);
+	io_enable_pin(POWER_LED, on);
+}
+
+void power_set_led(bool on)
+{
+	power_set_led_ex(on, true);
+}
+#endif // !ATTINY88_DIP && LED_POLARITY
+
+void charge_set_led_ex(bool on, bool swap)
+{
+#ifdef ATTINY88_DIP
+	//
+#else
+
+#ifdef LED_POLARITY
+	io_clear_pin(POWER_LED);
+#endif // LED_POLARITY
+
+#endif // ATTINY88_DIP
+
+#ifdef ATTINY88_DIP
+	io_enable_pin(CHARGE, !on);
+#else
+    io_enable_pin(CHARGE, on);
+
+#ifdef LED_POLARITY
+	if (swap)
+	{
+		if ((on == false) && (_state.powered))	// If no longer charging, turn power light back on
+			power_set_led(true);
+	}			
+#endif // LED_POLARITY
+
+#endif // ATTINY88_DIP
+}
+
+void charge_set_led(bool on)
+{
+	charge_set_led_ex(on, true);
+}
+
+void charge_notify(bool charging)
+{
+	_state.battery_charging = charging;
+	
+	charge_set_led(charging);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+void usbhub_reset(void)
+{
+#ifndef I2C_REWORK
+	io_clear_pin(USBHUB_RESET);
+	
+	_delay_us(1 * 10);	// Minimum active low pulse is 1us
+	
+	io_set_pin(USBHUB_RESET);
+#endif // I2C_REWORK
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+void power_signal_interrupt(void)
+{
+    io_set_pin(AVR_IRQ);	// FIXME: Active low?
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+#if !defined(DEBUG) && !(defined(ENABLE_SERIAL) && defined(ATTINY88_DIP))
+static io_pin_t PS_POR      = IO_PD(6);
+#define PS_POR_AVAILABLE
+#endif // DEBUG
+static io_pin_t PS_SRST     = IO_PD(7);
+
+#define FPGA_RESET_DELAY    10  // ms   // MAGIC
+
+void fpga_reset(bool delay)
+{
+#ifdef PS_POR_AVAILABLE
+    io_clear_pin(PS_POR);
+#endif // PS_POR_AVAILABLE
+    io_clear_pin(PS_SRST);
+
+    if (delay)
+        _delay_ms(FPGA_RESET_DELAY);
+#ifdef PS_POR_AVAILABLE
+    io_enable_pin(PS_POR, true);
+#endif // PS_POR_AVAILABLE
+    io_enable_pin(PS_SRST, true);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+static io_pin_t VBAT        = IO_PC(0);
+
+void battery_init(void)
+{
+    //io_input_pin(VBAT);
+    DIDR0 |= 0x1;           // Digital input disable PC0 (ADC0)
+
+    ADMUX = (1 << REFS0)    // AVcc reference
+          | (0 << ADLAR)    // Left-aligned result
+          | (0 << MUX0);    // ADC0
+
+    ADCSRA = (0x7 << ADPS0);// Prescale clock by 128
+}
+
+uint16_t battery_get_voltage(void)
+{
+    // Vout = (357k / (274k + 357k)) * Vbat
+    // Vbat = (Vout * (274k + 357k)) / 357k
+
+    // ADC = (Vin * 1024) / Vref
+    // Vin = (ADC * Vref) / 1024
+    // Vref = 3.3
+
+    // Vbat(mV) = 1000 * (((ADC * 3.3) / 1024) * (274k + 357k)) / 357k
+    // Vbat(mV) ~= ADC * 5.70
+
+    ADCSRA |= (1 << ADEN);        // FIXME: Turn on ADC (or leave on all the time?)
+
+    ADCSRA |= (1 << ADSC);  // Start conversion
+
+    while (ADCSRA & (1 << ADSC));   // Wait for End of Conversion
+
+    /*uint16_t*/uint32_t voltage = (ADCH << 8) | (ADCL << 0);
+#ifdef ATTINY88_DIP
+	voltage = (voltage * 32227) / 10000;	// ~3.22265625
+#else
+    voltage = (voltage * 56961) / 10000;	// ~5.69606748
+#endif // ATTINY88_DIP
+    ADCSRA &= ~(1 << ADEN);         // FIXME: Turn off ADC (or leave on all the time?)
+
+    return (uint16_t)voltage;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+void blink_error_sequence(uint8_t len)
+{
+    charge_set_led(false);
+    _delay_ms(BLINK_ERROR_DELAY * 2);
+
+    for (; len > 0; len--) {
+        charge_set_led(true);
+        _delay_ms(BLINK_ERROR_DELAY);
+        charge_set_led(false);
+        _delay_ms(BLINK_ERROR_DELAY);
+    }
+
+    //for (len = 2; len > 0; len--)   // Could have *2 on delay, but so as never to overflow 8-bit argument
+    //    _delay_ms(BLINK_ERROR_DELAY);
+}
+
+typedef struct power_params {
+    power_subsystem_t subsys;
+    bool enable;
+    uint8_t retry;
+    //uint16_t opaque;
+} power_params_t;
+
+static bool _power_up_fpga(power_params_t* params)
+{
+    if (params->subsys != PS_FPGA)
+        return false;
+
+    if (params->enable == false)
+    {
+        //if (tps54478_is_power_good() == false)  // Already off
+		//	return true;
+
+        if (params->retry == 0)
+		{
+			io_clear_pin(PS_SRST);	// FIXME: Hold it low to stop
+#ifdef PS_POR_AVAILABLE
+			io_clear_pin(PS_POR);	// Prepare it for shutdown, and then the potential next power cycle
+#endif // PS_POR_AVAILABLE			
+            tps54478_set_power(false);
+		}
+
+        //return (tps54478_is_power_good() == false);
+		return true;
+    }
+
+    //bool fpga_power_good = tps54478_is_power_good();  // TODO: Can it ever already be good?
+
+    if (params->retry == 0)
+        tps54478_set_power(true);
+
+    return tps54478_is_power_good();
+}
+
+static bool _power_up_reg(power_params_t* params)
+{
+    if ((params->subsys > PS_TX) || (params->subsys < PS_VDRAM))
+        return false;
+
+    struct reg_config* cfg = default_reg_config + params->subsys;
+
+    if (params->enable == false)
+        return ltc3675_enable_reg(cfg->address, false);
+
+	if (cfg->voltage > 0)
+	{
+		if (ltc3675_set_voltage(cfg->address, cfg->voltage) == false)
+			return false;
+	}	
+
+    return ltc3675_enable_reg(cfg->address, true);
+}
+
+static bool _power_enable_subsys(power_params_t* params)
+{
+    switch (params->subsys)
+    {
+        case PS_FPGA:
+            return _power_up_fpga(params);
+        //case PS_:
+        //    break;
+        default:
+            return _power_up_reg(params);
+    }
+
+    return false;   // Should never get here
+}
+
+bool power_enable(power_subsystem_t subsys, bool on)
+{
+    power_params_t params;
+    ZERO_MEMORY(params);
+    params.subsys = subsys;
+    params.enable = on;
+
+    return _power_enable_subsys(&params);
+}
+
+typedef bool (*boot_function_t)(power_params_t*);
+
+struct boot_step {
+    power_subsystem_t subsys;
+	//boot_function_t fn;
+	//uint8_t delay;
+	//uint8_t retries;
+    //uint16_t opaque;
+	//bool powered;
+} boot_steps[] = {  // MAGIC: Retries/delays
+	{ PS_FPGA,				/*NULL, POWER_DEFAULT_DELAY, POWER_DEFAULT_RETRIES*/ },	// 7..8						// 3..4
+	{ PS_VDRAM,				/*NULL, POWER_DEFAULT_DELAY, POWER_DEFAULT_RETRIES*/ },	// 9..10					// 5..6
+	{ PS_PERIPHERALS_1_8,	/*NULL, POWER_DEFAULT_DELAY, POWER_DEFAULT_RETRIES*/ },	// 11..12					// 7..8
+	{ PS_PERIPHERALS_3_3,	/*NULL, POWER_DEFAULT_DELAY, POWER_DEFAULT_RETRIES*/ },	// 13..14					// 9..10
+	{ PS_TX,				/*NULL, POWER_DEFAULT_DELAY, POWER_DEFAULT_RETRIES*/ }  // CHECK: Leaving TX off
+};
+/*
+bool power_is_subsys_on(int8_t index)
+{
+	if ((index < 0) || (index >= ARRAY_SIZE(boot_steps)))
+		return false;
+	
+	struct boot_step* step = boot_steps + index;
+	
+	return step->powered;
+}
+*/
+bool power_init(void)
+{
+	io_output_pin(CHARGE);
+#ifdef LED_POLARITY
+    io_output_pin(POWER_LED);
+#endif // LED_POLARITY
+
+	charge_set_led(true);
+	
+	battery_init();
+	
+    tps54478_init(true);	// Will keep EN float (keep power on)
+#ifndef I2C_REWORK
+	i2c_init(PWR_SDA, PWR_SCL);
+	
+	io_output_pin(USBHUB_RESET);
+#endif // I2C_REWORK
+#ifdef CHARGER_TI
+	if (bq24190_init(true) == false)
+		return false;
+#else
+	if (ltc4155_init(/*_state.battery_not_present*/true/*false*/) == false)
+		return false;
+#endif // CHARGER_TI
+#ifdef CHARGER_TI
+	_delay_ms(1000);	// Still at 1.4V on dev board
+#else
+	_delay_ms(25);	// Wait for charge current to stop (Vbatt to fall to 0V)
+#endif // CHARGER_TI
+	uint16_t batt_voltage = battery_get_voltage();
+	debug_log_ex("Vb ", false);
+	debug_log_byte((uint8_t)(batt_voltage / 100));
+	//debug_log_hex_ex(batt_voltage >> 8, false);
+	//debug_log_hex(batt_voltage & 0xFF);
+	if (batt_voltage < BATT_MIN_VOLTAGE)
+	{
+		_state.battery_not_present = true;
+		
+		//debug_log("NoBatt");
+	}
+	else
+	{
+#ifdef CHARGER_TI
+		bq24190_toggle_charger(true);
+#else
+		ltc4155_set_charge_current_limit(50);
+#endif // CHARGER_TI
+	}
+
+    if (ltc3675_init(ltc3675_reg_helper) == false)
+		return false;
+#ifdef PS_POR_AVAILABLE
+	io_output_pin(PS_POR);
+#endif // PS_POR_AVAILABLE
+    io_output_pin(PS_SRST);
+    // Hold low until power is stable
+#ifdef PS_POR_AVAILABLE
+    io_clear_pin(PS_POR);
+#endif // PS_POR_AVAILABLE
+    io_clear_pin(PS_SRST);
+/*
+    AVR_CS
+    AVR_MOSI
+    AVR_MISO
+    AVR_SCK
+
+    FTDI_BCD
+    FTDI_PWREN2
+*/
+	io_input_pin(AVR_RESET);	// Has external pull-up (won't do anything because this is configured at the hardware RESET pin)
+	
+	//io_output_pin(AVR_IRQ);		// Output here, input to FPGA
+    io_input_pin(AVR_IRQ);
+	//io_set_pin(AVR_IRQ);	// FIXME: Active low?
+	
+	///////////////
+	
+	EICRA = _BV(ISC01) | _BV(ISC00) | _BV(ISC10)/* | _BV(ISC11)*/;	// Rising edge for INT0 (WAKEUP). [Falling for INT1.] Any logical change INT1 (ONSWITCH_DB)
+	//EIMSK = _BV(INT0);	// [Turn on WAKEUP interrupt] Don't do this, as unit will turn on anyway
+	EIMSK = _BV(INT1) | _BV(INT0);	// Turn on ONSWITCH_DB and WAKEUP
+	
+	PCMSK0 = _BV(PCINT1) | _BV(PCINT0);	// USBPM_IRQ | CORE_PGOOD
+	PCMSK2 = _BV(PCINT16)/* | _BV(PCINT20)*/;	// PWR_IRQ/* | PWR_RESET*/
+	PCICR = _BV(PCIE2) | _BV(PCIE0);
+
+	///////////////
+/*
+	TCNT0;
+	OCR0A = 0x;
+	TCCR0A = _BV(CTC0);
+	TIFR0;
+	TIMSK0;
+	TCCR0A |= 0x05;	// Switch on with 1024 prescaler
+*/
+	TCCR1B = _BV(WGM12);	// CTC mode
+	OCR1A = 15624 * 2;		// Hold button for 2 seconds to switch off
+	TIMSK1 = _BV(OCIE1A);	// Enable CTC on Timer 1
+	
+	charge_set_led(false);
+	
+	return true;
+}
+
+bool power_on(void)
+{
+	pmc_mask_irqs(true);
+	
+    //charge_set_led(false);
+	
+	bool last_power_led_state = /*true*/false;
+	
+	//if ((ARRAY_SIZE(boot_steps) % 2) == 0)	// Should end with 'true'
+	//	last_power_led_state = false;
+	
+	power_set_led(last_power_led_state);
+	
+	uint8_t step_count, retry;
+	for (step_count = 0; step_count < ARRAY_SIZE(boot_steps); step_count++)
+	{
+		last_power_led_state = !last_power_led_state;
+		power_set_led(last_power_led_state);
+		
+//		debug_blink(step_count);
+//		debug_blink(3 + (step_count * 2) + 0);
+//		debug_blink_rev(7 + (step_count * 2) + 0);
+		
+	    struct boot_step* step = boot_steps + step_count;
+	    if (/*(step->fn == NULL) && */(step->subsys == PS_UNKNOWN))
+            continue;
+		
+		debug_log_ex("PWR ", false);
+		debug_log_byte_ex(step->subsys, true);
+
+        power_params_t params;
+
+	    for (retry = 0; retry < /*step->retries*/POWER_DEFAULT_RETRIES; retry++)
+		{
+	        ZERO_MEMORY(params);
+            params.subsys = step->subsys;
+            params.enable = true;
+	        params.retry = retry;
+
+	        if ((/*(step->fn != NULL) && (step->fn(&params))) ||
+				((step->fn == NULL) && */(_power_enable_subsys(&params))))
+			{
+				//step->powered = true;
+				default_reg_config[step->subsys].powered = true;
+				
+				debug_log("+");
+//				debug_blink(3 + (step_count * 2) + 1);
+//				debug_blink_rev(7 + (step_count * 2) + 1);
+
+//ltc4155_dump();
+
+                break;
+	        }
+			
+			debug_log("?");
+
+            if ((retry < /*step->retries*/POWER_DEFAULT_RETRIES)/* && (step->delay > 0)*/)
+                _delay_ms(/*step->delay*/POWER_DEFAULT_DELAY);
+	    }
+		
+//		debug_blink(step_count);
+
+	    if (retry == /*step->retries*/POWER_DEFAULT_RETRIES)
+	        break;
+    }
+
+    if (step_count != ARRAY_SIZE(boot_steps))
+	{
+		debug_log("x");
+		
+		//sei();	// For button press detection
+
+        /*while (_state.powered == false) {
+            blink_error_sequence(step_count + BlinkError_FPGA_Power);
+        }*/
+		pmc_set_blink_error(step_count + BlinkError_FPGA_Power);
+
+		pmc_mask_irqs(false);
+
+        return false;
+    }
+	
+	///////////////////////////////////
+	
+	//bool was_hub_in_reset = (io_is_pin_set(USBHUB_RESET) == false);
+	
+	usbhub_reset();
+	
+	/*if (was_hub_in_reset)
+	{
+		_delay_ms(10);
+		usbhub_reset();
+	}*/
+	
+	fpga_reset(false);  // Power has been brought up, so let FPGA run
+	
+	///////////////////////////////////
+	
+//	ltc4155_dump();
+	
+	// Turn off WAKEUP interrupt, enable ONSWITCH_DB
+	//EIMSK = _BV(INT1);
+	
+	_state.powered = true;
+//debug_blink_rev(1);
+//_delay_ms(1000);	// Wait for FPGA PGOOD to stabilise
+	pmc_mask_irqs(false);
+	
+	power_set_led(true);
+	
+	if (_state.battery_charging)
+	{
+		_delay_ms(500*2);
+		charge_set_led(true);
+	}		
+	
+    return true;
+}
+
+uint8_t power_off(void)
+{
+	pmc_mask_irqs(true);
+	
+	io_clear_pin(PS_SRST);	// FIXME: Hold it low to stop FPGA running
+	
+	bool last_power_led_state = /*false*/true;
+	
+	//if ((ARRAY_SIZE(boot_steps) % 2) == 0)	// Should end with 'false'
+	//	last_power_led_state = true;
+	
+	//power_set_led(last_power_led_state);
+	
+	///////////////////////////////////
+	
+	int8_t step_count, retry;
+	for (step_count = ARRAY_SIZE(boot_steps) - 1; step_count >= 0; step_count--)
+	{
+		last_power_led_state = !last_power_led_state;
+		power_set_led(last_power_led_state);
+		
+//		debug_blink(step_count);
+		
+	    struct boot_step* step = boot_steps + step_count;
+	    if (/*(step->fn == NULL) && */(step->subsys == PS_UNKNOWN))
+            continue;
+
+        power_params_t params;
+
+	    for (retry = 0; retry < /*step->retries*/POWER_DEFAULT_RETRIES; retry++)
+		{
+	        ZERO_MEMORY(params);
+            params.subsys = step->subsys;
+            params.enable = false;
+	        params.retry = retry;
+			
+			if ((/*(step->fn != NULL) && (step->fn(&params))) ||
+				((step->fn == NULL) && */(_power_enable_subsys(&params))))
+			{
+				//step->powered = false;
+				default_reg_config[step->subsys].powered = false;
+				break;
+			}
+			
+            if ((retry < /*step->retries*/POWER_DEFAULT_RETRIES)/* && (step->delay > 0)*/)
+                _delay_ms(/*step->delay*/POWER_DEFAULT_DELAY);
+	    }
+		
+//		debug_blink(step_count);
+
+	    if (retry == /*step->retries*/POWER_DEFAULT_RETRIES)
+	        break;
+    }
+
+    if (step_count != -1)
+	{
+		/*pmc_mask_irqs(false);
+		
+        while (_state.powered) {
+            blink_error_sequence(step_count + BlinkError_FPGA_Power);
+        }*/
+		if (pmc_get_blink_error() == BlinkError_None)	// Only set blink error if no existing error
+			pmc_set_blink_error(step_count + BlinkError_FPGA_Power);
+		
+		pmc_mask_irqs(false);
+
+        return (step_count + 1);
+    }
+	
+	///////////////////////////////////
+	
+	// Turn off WAKEUP interrupt, enable ONSWITCH_DB
+	//EIMSK = _BV(INT1);
+
+	_state.powered = false;
+	
+	pmc_mask_irqs(false);
+	
+	power_set_led_ex(false, false);
+	_delay_ms(500*2);
+	
+	power_set_led(false);	// Will turn on charger LED if battery is charging
+	
+	return 0;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+#ifdef DEBUG
+
+#ifdef ATTINY88_DIP
+static io_pin_t DEBUG_1 = IO_PB(6);
+static io_pin_t DEBUG_2	= IO_PB(7);
+#endif // ATTINY88_DIP
+
+#endif // DEBUG
+
+ISR(INT0_vect)	// PD(2) WAKEUP: Rising edge
+{
+	//cli();
+	pmc_mask_irqs(true);
+	
+	//power_on();
+	debug_log("\nINT0\n");
+	_state.wake_up = true;
+	
+	//sei();
+	pmc_mask_irqs(false);
+}
+
+ISR(INT1_vect)	// PD(3) ONSWITCH_DB (PB_STAT): Any change
+{
+	//cli();
+	pmc_mask_irqs(true);
+	
+	if (ltc3675_is_power_button_depressed())
+	{
+		debug_log("PWRBTN+");
+		
+		TCNT1 = 0;
+		if ((TCCR1B & 0x07) == 0x00)
+		{
+			_state.active_timers++;
+			debug_log("TIMER1+");
+		}
+		TCCR1B |= /*0x5*/0x3;	// [1024] 64 prescaler
+		//_state.timers_running = true;
+		
+		//debug_set(DEBUG_1, true);
+		//debug_set(DEBUG_2, false);
+	}
+	else
+	{
+		debug_log("PWRBTN-");
+		
+		//if (TIMSK1 & _BV(OCIE1A))	// If letting go of button and still running, stop timer
+		{
+			//TIMSK1 &= ~_BV(OCIE1A);
+			if ((TCCR1B & 0x07) != 0x00)
+			{
+				_state.active_timers--;
+				debug_log("TIMER1-");
+			}
+			TCCR1B &= ~0x7;	// Disable timer
+			//_state.timers_running = false;
+			
+			//debug_set(DEBUG_1, false);
+		}
+	}
+	
+	//sei();
+	pmc_mask_irqs(false);
+}
+
+ISR(TIMER1_COMPA_vect)
+{
+	//cli();
+	pmc_mask_irqs(true);
+	
+	debug_log("TIMER1");
+
+	//TIMSK1 &= ~_BV(OCIE1A);	// Turn off timer
+	TCCR1B &= ~0x7;	// Disable timer
+	//_state.timers_running = false;
+	_state.active_timers--;
+	
+	if (_state.powered)
+	{
+		debug_log("PWROFF");
+		
+		_state.power_off = true;
+	}		
+	
+	//debug_set(DEBUG_2, true);
+	
+	//power_off();
+	
+	//sei();
+	pmc_mask_irqs(false);
+	
+	//sleep_mode();
+}
+
+ISR(PCINT0_vect)
+{
+	//cli();
+	pmc_mask_irqs(true);
+	
+	//debug_log("PCINT0");
+	
+	// CORE_PGOOD
+	//	Assert low: power problem -> shutdown
+	// USBPM_IRQ
+	//	Charge status change? -> update LED
+	//	Power problem:	battery -> blink charge LED
+	//					major -> shutdown
+	
+	if (/*(_state.powered) && */(/*io_test_pin(CORE_PGOOD)*/tps54478_is_power_good() == false))
+	{
+		_state.core_power_bad = true;
+	}
+#ifdef CHARGER_TI
+	if (bq24190_has_interrupt())
+	{
+		_state.bq24190_irq = true;
+	}
+#else
+	if (ltc4155_has_interrupt())
+	{
+		_state.ltc4155_irq = true;
+	}
+#endif // CHARGER_TI
+	//sei();
+	pmc_mask_irqs(false);
+}
+
+ISR(PCINT2_vect)
+{
+	//cli();
+	pmc_mask_irqs(true);
+	
+	//debug_log("PCINT2");
+	
+	// PWR_IRQ
+	//	Regulator problem: shutdown
+	// PWR_RESET
+	//	Ignored
+	
+	if (ltc3675_has_interrupt())
+	{
+		//debug_set(IO_PB(6), true);
+		_state.ltc3675_irq = true;
+	}
+	
+	//sei();
+	pmc_mask_irqs(false);
+}
diff --git a/firmware/e300/rev_b/power.h b/firmware/e300/rev_b/power.h
new file mode 100644
index 000000000..453633414
--- /dev/null
+++ b/firmware/e300/rev_b/power.h
@@ -0,0 +1,58 @@
+#ifndef POWER_H
+#define POWER_H
+
+#include <stdbool.h>
+#include <stdint.h>
+
+void tps54478_init(bool enable);
+void tps54478_set_power(bool on);   // Zynq core power (1.0V for FPGA)
+bool tps54478_is_power_good(void);
+
+void charge_set_led(bool on);		// Here for error blink codes
+void charge_notify(bool charging);
+
+void power_signal_interrupt(void);
+
+void fpga_reset(bool delay);
+
+typedef enum power_subsystems {
+    PS_UNKNOWN,
+    PS_FPGA,
+    PS_VDRAM,
+    PS_PERIPHERALS_1_8,
+    PS_PERIPHERALS_3_3,
+    PS_TX,
+	PS_MAX
+} power_subsystem_t;
+
+enum Regulators
+{
+	REG_UNKNOWN,
+	REG_TPS54478,
+	REG_LTC3675
+};
+
+bool power_enable(power_subsystem_t subsys, bool on);
+
+void battery_init(void);
+uint16_t battery_get_voltage(void);  // mV
+
+bool power_init(void);
+bool power_on(void);
+uint8_t power_off(void);
+
+//bool power_is_subsys_on(int8_t index);
+bool power_is_subsys_on(power_subsystem_t index);
+//int8_t power_get_regulator_index(uint8_t device, uint8_t address);
+//bool ltc3675_reg_helper(uint8_t address);
+
+void usbhub_reset(void);
+
+#ifndef I2C_REWORK
+#include "io.h"
+
+extern io_pin_t PWR_SDA;
+extern io_pin_t PWR_SCL;
+#endif // I2C_REWORK
+
+#endif // POWER_H