diff options
Diffstat (limited to 'firmware/e300')
35 files changed, 4703 insertions, 0 deletions
diff --git a/firmware/e300/battery/E310-Firmware.atsln b/firmware/e300/battery/E310-Firmware.atsln new file mode 100644 index 000000000..c4a3a5561 --- /dev/null +++ b/firmware/e300/battery/E310-Firmware.atsln @@ -0,0 +1,20 @@ + +Microsoft Visual Studio Solution File, Format Version 11.00 +# Atmel Studio Solution File, Format Version 11.00 +Project("{54F91283-7BC4-4236-8FF9-10F437C3AD48}") = "E310-Firmware", "E310-Firmware.cproj", "{CB962C73-137F-46D4-A5F8-6286DB107987}" +EndProject +Global + GlobalSection(SolutionConfigurationPlatforms) = preSolution + Debug|AVR = Debug|AVR + Release|AVR = Release|AVR + EndGlobalSection + GlobalSection(ProjectConfigurationPlatforms) = postSolution + {CB962C73-137F-46D4-A5F8-6286DB107987}.Debug|AVR.ActiveCfg = Debug|AVR + {CB962C73-137F-46D4-A5F8-6286DB107987}.Debug|AVR.Build.0 = Debug|AVR + {CB962C73-137F-46D4-A5F8-6286DB107987}.Release|AVR.ActiveCfg = Release|AVR + {CB962C73-137F-46D4-A5F8-6286DB107987}.Release|AVR.Build.0 = Release|AVR + EndGlobalSection + GlobalSection(SolutionProperties) = preSolution + HideSolutionNode = FALSE + EndGlobalSection +EndGlobal diff --git a/firmware/e300/battery/E310-Firmware.cproj b/firmware/e300/battery/E310-Firmware.cproj new file mode 100644 index 000000000..2d71c0c46 --- /dev/null +++ b/firmware/e300/battery/E310-Firmware.cproj @@ -0,0 +1,227 @@ +<?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.2</ProjectVersion> + <ToolchainName>com.Atmel.AVRGCC8.C</ToolchainName> + <ProjectGuid>{cb962c73-137f-46d4-a5f8-6286db107987}</ProjectGuid> + <avrdevice>ATtiny88</avrdevice> + <avrdeviceseries>none</avrdeviceseries> + <OutputType>Executable</OutputType> + <Language>C</Language> + <OutputFileName>$(MSBuildProjectName)</OutputFileName> + <OutputFileExtension>.elf</OutputFileExtension> + <OutputDirectory>$(MSBuildProjectDirectory)\$(Configuration)</OutputDirectory> + <AssemblyName>E310-Firmware</AssemblyName> + <Name>E310-Firmware</Name> + <RootNamespace>E310-Firmware</RootNamespace> + <ToolchainFlavour>Native</ToolchainFlavour> + <KeepTimersRunning>true</KeepTimersRunning> + <OverrideVtor>false</OverrideVtor> + <CacheFlash>true</CacheFlash> + <ProgFlashFromRam>true</ProgFlashFromRam> + <RamSnippetAddress>0x20000000</RamSnippetAddress> + <UncachedRange /> + <preserveEEPROM>true</preserveEEPROM> + <OverrideVtorValue>exception_table</OverrideVtorValue> + <BootSegment>2</BootSegment> + <eraseonlaunchrule>1</eraseonlaunchrule> + <AsfFrameworkConfig> + <framework-data xmlns=""> + <options /> + <configurations /> + <files /> + <documentation help="" /> + <offline-documentation help="" /> + <dependencies> + <content-extension eid="atmel.asf" uuidref="Atmel.ASF" version="3.20.1" /> + </dependencies> + </framework-data> + </AsfFrameworkConfig> + <avrtool>com.atmel.avrdbg.tool.atmelice</avrtool> + <com_atmel_avrdbg_tool_atmelice> + <ToolOptions> + <InterfaceProperties> + </InterfaceProperties> + <InterfaceName>debugWIRE</InterfaceName> + </ToolOptions> + <ToolType>com.atmel.avrdbg.tool.atmelice</ToolType> + <ToolNumber>J41800001858</ToolNumber> + <ToolName>Atmel-ICE</ToolName> + </com_atmel_avrdbg_tool_atmelice> + <avrtoolinterface>debugWIRE</avrtoolinterface> + <UseGdb>True</UseGdb> + <com_atmel_avrdbg_tool_simulator> + <ToolOptions xmlns=""> + <InterfaceProperties> + </InterfaceProperties> + <InterfaceName> + </InterfaceName> + </ToolOptions> + <ToolType xmlns="">com.atmel.avrdbg.tool.simulator</ToolType> + <ToolNumber xmlns=""> + </ToolNumber> + <ToolName xmlns="">Simulator</ToolName> + </com_atmel_avrdbg_tool_simulator> + </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.common.outputfiles.srec>True</avrgcc.common.outputfiles.srec> + <avrgcc.common.outputfiles.usersignatures>False</avrgcc.common.outputfiles.usersignatures> + <avrgcc.compiler.general.ChangeDefaultCharTypeUnsigned>True</avrgcc.compiler.general.ChangeDefaultCharTypeUnsigned> + <avrgcc.compiler.general.ChangeDefaultBitFieldUnsigned>True</avrgcc.compiler.general.ChangeDefaultBitFieldUnsigned> + <avrgcc.compiler.symbols.DefSymbols> + <ListValues> + <Value>NDEBUG</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.linker.libraries.Libraries> + <ListValues> + <Value>libm</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.common.outputfiles.srec>True</avrgcc.common.outputfiles.srec> + <avrgcc.common.outputfiles.usersignatures>False</avrgcc.common.outputfiles.usersignatures> + <avrgcc.compiler.general.ChangeDefaultCharTypeUnsigned>True</avrgcc.compiler.general.ChangeDefaultCharTypeUnsigned> + <avrgcc.compiler.general.ChangeDefaultBitFieldUnsigned>True</avrgcc.compiler.general.ChangeDefaultBitFieldUnsigned> + <avrgcc.compiler.symbols.DefSymbols> + <ListValues> + <Value>DEBUG</Value> + </ListValues> + </avrgcc.compiler.symbols.DefSymbols> + <avrgcc.compiler.preprocessor.UndefSymbols> + <ListValues> + <Value>DDR3L</Value> + </ListValues> + </avrgcc.compiler.preprocessor.UndefSymbols> + <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>Maximum (-g3)</avrgcc.compiler.optimization.DebugLevel> + <avrgcc.compiler.warnings.AllWarnings>True</avrgcc.compiler.warnings.AllWarnings> + <avrgcc.compiler.warnings.ExtraWarnings>True</avrgcc.compiler.warnings.ExtraWarnings> + <avrgcc.compiler.warnings.Undefined>True</avrgcc.compiler.warnings.Undefined> + <avrgcc.compiler.warnings.Pedantic>True</avrgcc.compiler.warnings.Pedantic> + <avrgcc.linker.libraries.Libraries> + <ListValues> + <Value>libm</Value> + </ListValues> + </avrgcc.linker.libraries.Libraries> + <avrgcc.assembler.debugging.DebugLevel>Default (-Wa,-g)</avrgcc.assembler.debugging.DebugLevel> + </AvrGcc> + </ToolchainSettings> + </PropertyGroup> + <ItemGroup> + <Compile Include="adc.c"> + <SubType>compile</SubType> + </Compile> + <Compile Include="adc.h"> + <SubType>compile</SubType> + </Compile> + <Compile Include="bq2419x.c"> + <SubType>compile</SubType> + </Compile> + <Compile Include="bq2419x.h"> + <SubType>compile</SubType> + </Compile> + <Compile Include="eeprom.c"> + <SubType>compile</SubType> + </Compile> + <Compile Include="eeprom.h"> + <SubType>compile</SubType> + </Compile> + <Compile Include="fpga.c"> + <SubType>compile</SubType> + </Compile> + <Compile Include="fpga.h"> + <SubType>compile</SubType> + </Compile> + <Compile Include="i2c_twi.c"> + <SubType>compile</SubType> + </Compile> + <Compile Include="i2c_twi.h"> + <SubType>compile</SubType> + </Compile> + <Compile Include="interrupt.c"> + <SubType>compile</SubType> + </Compile> + <Compile Include="interrupt.h"> + <SubType>compile</SubType> + </Compile> + <Compile Include="io.c"> + <SubType>compile</SubType> + </Compile> + <Compile Include="io.h"> + <SubType>compile</SubType> + </Compile> + <Compile Include="led.c"> + <SubType>compile</SubType> + </Compile> + <Compile Include="led.h"> + <SubType>compile</SubType> + </Compile> + <Compile Include="ltc294x.c"> + <SubType>compile</SubType> + </Compile> + <Compile Include="ltc294x.h"> + <SubType>compile</SubType> + </Compile> + <Compile Include="ltc3675.c"> + <SubType>compile</SubType> + </Compile> + <Compile Include="ltc3675.h"> + <SubType>compile</SubType> + </Compile> + <Compile Include="main.c"> + <SubType>compile</SubType> + </Compile> + <Compile Include="mcu_settings.h"> + <SubType>compile</SubType> + </Compile> + <Compile Include="pmu.c"> + <SubType>compile</SubType> + </Compile> + <Compile Include="pmu.h"> + <SubType>compile</SubType> + </Compile> + <Compile Include="spi.c"> + <SubType>compile</SubType> + </Compile> + <Compile Include="spi.h"> + <SubType>compile</SubType> + </Compile> + <Compile Include="timer.c"> + <SubType>compile</SubType> + </Compile> + <Compile Include="timer.h"> + <SubType>compile</SubType> + </Compile> + <Compile Include="tps54478.c"> + <SubType>compile</SubType> + </Compile> + <Compile Include="tps54478.h"> + <SubType>compile</SubType> + </Compile> + <Compile Include="utils.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/battery/Makefile b/firmware/e300/battery/Makefile new file mode 100644 index 000000000..c2d530e36 --- /dev/null +++ b/firmware/e300/battery/Makefile @@ -0,0 +1,77 @@ +# USRP E310 Firmware +# Copyright (C) 2014-2015 Ettus Research +# This file is part of the USRP E310 Firmware +# The USRP E310 Firmware is free software: you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation, either version 2 of the License, or +# (at your option) any later version. +# The USRP E310 Firmware is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# You should have received a copy of the GNU General Public License +# along with the USRP E310 Firmware. If not, see <http://www.gnu.org/licenses/>. + +################################################## +# Compiler +################################################## +CC = avr-gcc +OBJCOPY = avr-objcopy +STRIP = avr-strip +SIZE = avr-size +OBJDUMP = avr-objdump +SREC = srec_cat +CFLAGS = -Os -std=c11 -Wall -fshort-enums -pedantic -Wl,--gc-sections \ + -Wstrict-prototypes -Wcast-align -Wshadow + +################################################## +# Files +################################################## +HDRS = +SRCS = main.c adc.c bq2419x.c fpga.c i2c_twi.c interrupt.c io.c ltc294x.c ltc3675.c \ + pmu.c spi.c timer.c tps54478.c eeprom.c led.c +TARGET = main + +################################################## +# Device +################################################## +MMCU = attiny88 +PROGRAMMER = jtag3isp +PORT = usb +AVRDUDE = avrdude -p $(MMCU) -c $(PROGRAMMER) -P $(PORT) -V + +################################################## +# Global Targets +################################################## +all: $(TARGET).hex size + +clean: + $(RM) *.o *.elf *.hex + +install: all + $(AVRDUDE) -U flash:w:$(TARGET).hex:i + +size: $(TARGET).hex + @$(SIZE) --format=SysV --mcu=$(MMCU) $(TARGET).elf + @$(SIZE) -C --mcu=$(MMCU) $(TARGET).elf + +################################################## +# 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/battery/README.md b/firmware/e300/battery/README.md new file mode 100644 index 000000000..fc4d504dd --- /dev/null +++ b/firmware/e300/battery/README.md @@ -0,0 +1,25 @@ +USRP E312 Firmware +================== + +Welcome to the NI Ettus Research USRP E310/E312 Firmware distribution. + +# Dependencies + +In order to build you'll *avr-gcc* and *avr-libc*. + +# Building + +The included Makefile specifies all the required flags. To build type: +``` +$ make +``` + +# Flashing + +In order to program the device with the firmware type: +``` +$ make install +``` + +Note: The Makefile will have to be modified depending on which programmer you use. +Known good programmers include 'Atmel AVR Dragon, Atmel JTAGICEIII, Atmel AtmelICE'. diff --git a/firmware/e300/battery/adc.c b/firmware/e300/battery/adc.c new file mode 100644 index 000000000..998408066 --- /dev/null +++ b/firmware/e300/battery/adc.c @@ -0,0 +1,58 @@ +/* USRP E310 Firmware Atmel AVR ADC driver + * Copyright (C) 2014 Ettus Research + * This file is part of the USRP E310 Firmware + * The USRP E310 Firmware is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 2 of the License, or + * (at your option) any later version. + * The USRP E310 Firmware is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * You should have received a copy of the GNU General Public License + * along with the USRP E310 Firmware. If not, see <http://www.gnu.org/licenses/>. + */ + +#include <avr/io.h> + +#include "adc.h" +#include "utils.h" + +void adc_init(void) +{ + /* disable digital input on PC0 (ADC0) */ + DIDR0 |= 0x1; + + /* set to AVcc reference, left aligned and ADC0 */ + ADMUX = (1 << REFS0) + | (0 << ADLAR) + | (0 << MUX0); + + /* prescale clock by 128 */ + ADCSRA = BIT(ADPS2) | BIT(ADPS1) | BIT(ADPS0); +} + +uint16_t adc_single_shot(void) +{ + uint16_t value; + + /* turn on ADC */ + ADCSRA |= (1 << ADEN); + + /* start conversion */ + ADCSRA |= (1 << ADSC); + + /* busy wait for conversion */ + while (ADCSRA & (1 << ADSC)) { + }; + + /* we need to first read the lower bits, + * which will lock the value until higher bits are read */ + value = (ADCL << 0); + value |= (ADCH << 8); + + /* turn adc of again */ + ADCSRA &= ~(1 << ADEN); + + return value; +} diff --git a/firmware/e300/battery/adc.h b/firmware/e300/battery/adc.h new file mode 100644 index 000000000..7aa3fc4b1 --- /dev/null +++ b/firmware/e300/battery/adc.h @@ -0,0 +1,38 @@ +/* USRP E310 Firmware Atmel AVR ADC driver + * Copyright (C) 2014 Ettus Research + * This file is part of the USRP E310 Firmware + * The USRP E310 Firmware is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 2 of the License, or + * (at your option) any later version. + * The USRP E310 Firmware is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * You should have received a copy of the GNU General Public License + * along with the USRP E310 Firmware. If not, see <http://www.gnu.org/licenses/>. + */ + +/** + * \file adc.h + * \brief Atmel AVR ADC driver + */ + +#ifndef ADC_H +#define ADC_H + +#include <stdint.h> + +/** + * \brief Initialize the ADC for conversion on PC0 (ADC0) + * with a prescaler of 128, and AVcc reference. + */ +void adc_init(void); + +/** + * \brief Do a single shot conversion on PC0 (ADC0) + * \return Value of ADC + */ +uint16_t adc_single_shot(void); + +#endif /* ADC_H */ diff --git a/firmware/e300/battery/bq2419x.c b/firmware/e300/battery/bq2419x.c new file mode 100644 index 000000000..11b393622 --- /dev/null +++ b/firmware/e300/battery/bq2419x.c @@ -0,0 +1,588 @@ +/* USRP E310 Firmware Texas Instruments BQ2419x driver + * Copyright (C) 2014 Ettus Research + * This file is part of the USRP E310 Firmware + * The USRP E310 Firmware is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 2 of the License, or + * (at your option) any later version. + * The USRP E310 Firmware is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * You should have received a copy of the GNU General Public License + * along with the USRP E310 Firmware. If not, see <http://www.gnu.org/licenses/>. + */ + +#include "bq2419x.h" +#include "io.h" +#include "i2c_twi.h" +#include "interrupt.h" +#include "pmu.h" +#include "mcu_settings.h" +#include "utils.h" + +#include <stdbool.h> +#include <string.h> + +#include <util/atomic.h> +#include <util/delay.h> + +static const uint8_t BQ2419X_I2C_ADDR = 0x6b; + +#define bq2419x_read(reg, val) \ + (i2c_twi_read(BQ2419X_I2C_ADDR, reg, val)) + +#define bq2419x_write(reg, val) \ + (i2c_twi_write(BQ2419X_I2C_ADDR, reg, val)) + +/* register addresses */ +static const uint8_t BQ2419X_REG_INPUT_SRC_CTL = 0x00; +static const uint8_t BQ2419X_REG_PWR_ON_CONFIG = 0x01; +static const uint8_t BQ2419X_REG_CHARGE_CURRENT = 0x02; +static const uint8_t BQ2419X_REG_PRE_TERM_CURRENT = 0x03; +static const uint8_t BQ2419X_REG_CHARGE_VOLTAGE = 0x04; +static const uint8_t BQ2419X_REG_TIMER_CONTROL = 0x05; +static const uint8_t BQ2419X_REG_THERMAL_REG_CTRL = 0x06; +static const uint8_t BQ2419X_REG_MISC_OPERATION = 0x07; +static const uint8_t BQ2419X_REG_SYSTEM_STATUS = 0x08; +static const uint8_t BQ2419X_REG_FAULT = 0x09; +static const uint8_t BQ2419X_REG_VENDOR_PART_REV = 0x0a; + +/* input source control register (REG00) */ +static const uint8_t BQ2419X_EN_HIZ_MASK = BIT(7); +static const uint8_t BQ2419X_EN_HIZ_SHIFT = 7; + +/* power on configuration register (REG01) */ +static const uint8_t BQ2419X_REGISTER_RESET_MASK = BIT(7); +static const uint8_t BQ2419X_REGISTER_RESET_SHIFT = 7; +static const uint8_t BQ2419X_I2C_TIMER_RESET = BIT(6); +static const uint8_t BQ2419X_I2C_TIMER_SHIFT = BIT(6); + +static const uint8_t BQ2419X_CHARGE_CFG_MASK = BIT(5) | BIT(4); +static const uint8_t BQ2419X_CHARGE_CFG_SHIFT = 4; +static const uint8_t BQ2419X_SYS_MIN_MASK = BIT(3) | BIT(2) | BIT(1); +static const uint8_t BQ2419X_SYS_MIN_SHIFT = 1; + +/* charge current control register (REG02) */ +static const uint8_t BQ2419X_ICHG_MASK = BIT(7) | BIT(6) \ + | BIT(5) | BIT(4) | BIT(3) | BIT(2); +static const uint8_t BQ2419X_ICHG_SHIFT = 2; +/* reserved */ +static const uint8_t BQ2419X_FORCE_20_PCT_MASK = BIT(0); +static const uint8_t BQ2419X_FORCE_20_PCT_SHIFT = 0; + +static const uint8_t BQ2419X_CHARGE_CFG_DISABLED = 0x00; +static const uint8_t BQ2419X_CHARGE_CFG_CHARGE = 0x01; +static const uint8_t BQ2419X_CHARGE_CFG_OTG = 0x03; + +/* pre charge / termination current control register (REG03) */ + +/* charge voltage control register (REG04) */ + +/* charge / termination register (REG05) */ +static const uint8_t BQ2419X_EN_TERM_MASK = BIT(7); +static const uint8_t BQ2419X_EN_TERM_SHIFT = BIT(7); +static const uint8_t BQ2419X_TERM_STAT_MASK = BIT(6); +static const uint8_t BQ2419X_TERM_STAT_SHIFT = 6; +static const uint8_t BQ2419X_WDT_MASK = BIT(5) | BIT(4); +static const uint8_t BQ2419X_WDT_SHIFT = 4; +static const uint8_t BQ2419X_EN_TIMER_MASK = BIT(3); +static const uint8_t BQ2419X_EN_TIMER_SHIFT = 3; + +/* ir compensation / thermal regulation control register (REG06) */ +static const uint8_t BQ2419X_BAT_COMP_MASK = BIT(7) | BIT(6) | BIT(5); +static const uint8_t BQ2419X_BAT_COMP_SHIFT = 5; +static const uint8_t BQ2419X_TREG_MASK = BIT(1) | BIT(0); +static const uint8_t BQ2419X_TREG_SHIFT = 0; + +/* misc operation register (REG07) */ +static const uint8_t BQ2419X_DPDM_EN_MASK = BIT(7); +static const uint8_t BQ2419X_DPDM_EN_SHIFT = 7; +static const uint8_t BQ2419X_TMR2X_EN_MASK = BIT(6); +static const uint8_t BQ2419X_TMR2X_EN_SHIFT = 6; +static const uint8_t BQ2419X_BATFET_DISABLE_MASK = BIT(5); +static const uint8_t BQ2419X_BATFET_DISABLE_SHIFT = 5; + +static const uint8_t BQ2419X_JEITA_VSET_MASK = BIT(4); +static const uint8_t BQ2419X_JEITA_VSET_SHIFT = BIT(4); +/* reserved bits */ +/* reserved bits */ +static const uint8_t BQ2419X_INT_MASK_MASK = BIT(1) | BIT(0); +static const uint8_t BQ2419X_INT_MASK_SHIFT = 0; + +/* system status register (REG08) */ +static const uint8_t BQ2419X_VBUS_STAT_MASK = BIT(7) | BIT(6); +static const uint8_t BQ2419X_VBUS_STAT_SHIFT = 6; +static const uint8_t BQ2419X_CHG_STAT_MASK = BIT(5) | BIT(4); +static const uint8_t BQ2419X_CHG_STAT_SHIFT = 4; +static const uint8_t BQ2419X_DPM_STAT_MASK = BIT(3); +static const uint8_t BQ2419X_DPM_STAT_SHIFT = 3; +static const uint8_t BQ2419X_PG_STAT_MASK = BIT(2); +static const uint8_t BQ2419X_PG_STAT_SHIFT = 2; +static const uint8_t BQ2419X_THERM_STAT_MASK = BIT(1); +static const uint8_t BQ2419X_THERM_STAT_SHIFT = 1; +static const uint8_t BQ2419X_VSYS_STAT_MASK = BIT(0); +static const uint8_t BQ2419X_VSYS_STAT_SHIFT = 0; + +static const uint8_t BQ2419X_CHARGE_STATUS_NOT_CHARGING = 0x00; +static const uint8_t BQ2419X_CHARGE_STATUS_PRE_CHARGE = 0x01; +static const uint8_t BQ2419X_CHARGE_STATUS_FAST_CHARGE = 0x02; +static const uint8_t BQ2419X_CHARGE_STATUS_DONE = 0x03; + +/* fault register (REG09) */ +static const uint8_t BQ2419X_WATCHDOG_FAULT_MASK = BIT(7); +static const uint8_t BQ2419X_WATCHDOG_FAULT_SHIFT = 7; +static const uint8_t BQ2419X_BOOST_FAULT_MASK = BIT(6); +static const uint8_t BQ2419X_BOOST_FAULT_SHIFT = 6; +static const uint8_t BQ2419X_CHG_FAULT_MASK = BIT(5) | BIT(4); +static const uint8_t BQ2419X_CHG_FAULT_SHIFT = 4; +static const uint8_t BQ2419X_BAT_FAULT_MASK = BIT(3); +static const uint8_t BQ2419X_BAT_FAULT_SHIFT = 3; +static const uint8_t BQ2419X_NTC_FAULT_MASK = BIT(2) | BIT(1) | BIT(0); +static const uint8_t BQ2419X_NTC_FAULT_SHIFT = 0; + +static io_pin_t CHG_IRQ = IO_PB(1); + +typedef struct bq2419x_pmu_charger +{ + pmu_charger_t pmu_charger; + uint8_t fault; + uint8_t status; + bool first_time; + + bool battery_status_valid; + bool battery_health_valid; + bool charger_health_valid; + + volatile bool event; +} bq2419x_pmu_charger_t; + +static bq2419x_pmu_charger_t charger; + +static volatile bool bq2419x_event = false; + +int8_t bq2419x_set_charger(bool on) +{ + uint8_t config; + int8_t ret; + + ret = bq2419x_read(BQ2419X_REG_PWR_ON_CONFIG, &config); + if (ret) + return ret; + + config &= ~BQ2419X_CHARGE_CFG_MASK; + if (on) + config |= 1 << BQ2419X_CHARGE_CFG_SHIFT; + + ret = bq2419x_write(BQ2419X_REG_PWR_ON_CONFIG, config); + if (ret) + return ret; + + return 0; +} + +static int8_t bq2419x_reset(void) +{ + uint8_t config; + int8_t ret; + uint8_t retry = 100; + + ret = bq2419x_read(BQ2419X_REG_PWR_ON_CONFIG, &config); + if (ret) + return ret; + + config |= BQ2419X_REGISTER_RESET_MASK; + ret = bq2419x_write(BQ2419X_REG_PWR_ON_CONFIG, config); + + do { + ret = bq2419x_read(BQ2419X_REG_PWR_ON_CONFIG, &config); + if (!(config & BQ2419X_REGISTER_RESET_MASK)) + return 0; + _delay_ms(10); + } while (retry--); + + return ret; +} + +static void bq2419x_set_host_mode(void) +{ + uint8_t timer_ctrl; + + /* to disable watchdog, we need to clear the WDT bits */ + bq2419x_read(BQ2419X_REG_TIMER_CONTROL, &timer_ctrl); + timer_ctrl &= ~BQ2419X_WDT_MASK; + bq2419x_write(BQ2419X_REG_TIMER_CONTROL, timer_ctrl); +} + + +static enum pmu_charge_type bq2419x_charger_get_charge_type(pmu_charger_t *pmu_charger) +{ + uint8_t val; + + (void) pmu_charger; + + bq2419x_read(BQ2419X_REG_PWR_ON_CONFIG, &val); + + val &= BQ2419X_CHARGE_CFG_MASK; + val >>= BQ2419X_CHARGE_CFG_SHIFT; + + /* if check if charging is disabled */ + if (!val) + return PMU_CHARGE_TYPE_NONE; + + bq2419x_read(BQ2419X_REG_CHARGE_CURRENT, &val); + + val &= BQ2419X_FORCE_20_PCT_MASK; + val >>= BQ2419X_FORCE_20_PCT_SHIFT; + + if (val) + return PMU_CHARGE_TYPE_TRICKLE; + else + return PMU_CHARGE_TYPE_FAST; +} + +static enum pmu_health bq2419x_charger_get_health(pmu_charger_t *pmu_charger) +{ + uint8_t fault; + int8_t ret; + struct bq2419x_pmu_charger *bq2419x_charger; + + bq2419x_charger = container_of( + pmu_charger, struct bq2419x_pmu_charger, pmu_charger); + + if (bq2419x_charger->charger_health_valid) { + fault = bq2419x_charger->fault; + bq2419x_charger->charger_health_valid = false; + } else { + ret = bq2419x_read(BQ2419X_REG_FAULT, &fault); + if (ret) + return PMU_HEALTH_UNKNOWN; + } + + /* if BOOST_FAULT then report overvoltage */ + if (fault & BQ2419X_BOOST_FAULT_MASK) { + return PMU_HEALTH_OVERVOLTAGE; + } else { + fault &= BQ2419X_CHG_FAULT_MASK; + fault >>= BQ2419X_CHG_FAULT_SHIFT; + switch (fault) { + case 0x0: + /* all is well */ + return PMU_HEALTH_GOOD; + case 0x1: + /* input fault, could be over- or under-voltage + * and we can't tell which, so we report unspec */ + return PMU_HEALTH_UNSPEC_FAIL; + case 0x2: + /* thermal shutdown */ + return PMU_HEALTH_OVERHEAT; + case 0x3: + /* the charge safety timer expired */ + return PMU_HEALTH_SAFETY_TIMER_EXPIRE; + default: + return PMU_HEALTH_UNKNOWN; + } + } +} + +static enum pmu_status bq2419x_battery_get_status(pmu_charger_t *pmu_charger) +{ + uint8_t fault, ss_reg; + int8_t ret; + struct bq2419x_pmu_charger *bq2419x_charger; + + bq2419x_charger = container_of( + pmu_charger, struct bq2419x_pmu_charger, pmu_charger); + + if (bq2419x_charger->battery_status_valid) { + fault = bq2419x_charger->fault; + ss_reg = bq2419x_charger->status; + bq2419x_charger->battery_status_valid = false; + } else { + ret = bq2419x_read(BQ2419X_REG_FAULT, &fault); + if (ret) + return ret; + + ret = bq2419x_read(BQ2419X_REG_SYSTEM_STATUS, &ss_reg); + if (ret) + return ret; + } + + fault &= BQ2419X_CHG_FAULT_MASK; + fault >>= BQ2419X_CHG_FAULT_SHIFT; + + /* the battery is discharging if either + * - we don't have a good power source + * - we have a charge fault */ + if (!(ss_reg & BQ2419X_PG_STAT_MASK) || fault) { + return PMU_STATUS_DISCHARGING; + } else { + ss_reg &= BQ2419X_CHG_STAT_MASK; + ss_reg >>= BQ2419X_CHG_STAT_SHIFT; + + switch(ss_reg) { + case 0x0: /* not charging */ + return PMU_STATUS_NOT_CHARGING; + case 0x1: /* pre charging */ + case 0x2: /* fast charging */ + return PMU_STATUS_CHARGING; + case 0x3: /* charge termination done */ + return PMU_STATUS_FULL; + } + } + return PMU_STATUS_NOT_CHARGING; +} + +static bool bq2419x_battery_get_online(pmu_charger_t *pmu_charger) +{ + uint8_t batfet_disable; + int8_t ret; + + (void) pmu_charger; + + ret = bq2419x_read(BQ2419X_REG_MISC_OPERATION, &batfet_disable); + if (ret) + return false; + + batfet_disable &= BQ2419X_BATFET_DISABLE_MASK; + batfet_disable >>= BQ2419X_BATFET_DISABLE_SHIFT; + + return !batfet_disable; +} + +static enum pmu_health bq2419x_battery_get_health(pmu_charger_t *pmu_charger) +{ + uint8_t fault; + int8_t ret; + struct bq2419x_pmu_charger *bq2419x_charger; + + bq2419x_charger = container_of( + pmu_charger, struct bq2419x_pmu_charger, pmu_charger); + + if (bq2419x_charger->battery_health_valid) { + fault = bq2419x_charger->fault; + bq2419x_charger->battery_health_valid = false; + } else { + ret = bq2419x_read(BQ2419X_REG_FAULT, &fault); + if (ret) + return ret; + } + + if (fault & BQ2419X_BAT_FAULT_MASK) + return PMU_HEALTH_OVERVOLTAGE; + else { + fault &= BQ2419X_NTC_FAULT_MASK; + fault >>= BQ2419X_NTC_FAULT_SHIFT; + switch (fault) { + case 0x0: + /* all is well */ + return PMU_HEALTH_GOOD; + case 0x1: + case 0x3: + case 0x5: + /* either TS1 cold, TS2 cold, or both cold */ + return PMU_HEALTH_COLD; + case 0x2: + case 0x4: + case 0x6: + /* either TS1 hot, TS2 hot, or both hot */ + return PMU_HEALTH_OVERHEAT; + default: + return PMU_HEALTH_UNKNOWN; + } + } +} + +static bool bq2419x_charger_get_online(pmu_charger_t *pmu_charger) +{ + uint8_t val; + int8_t ret; + + (void) pmu_charger; + + ret = bq2419x_read(BQ2419X_REG_SYSTEM_STATUS, &val); + if (ret) + return ret; + + /* check the power good bit */ + return !!(BQ2419X_PG_STAT_MASK & val); +} + +static inline bool bq2419x_get_irq(void) +{ + /* the CHG_IRQ line is low active */ + return !io_test_pin(CHG_IRQ); +} + +uint8_t bq2419x_pmu_charger_check_events(pmu_charger_t *pmu_charger) +{ + uint8_t flags; + int8_t ret; + uint8_t status; + uint8_t fault; + uint8_t isc; + volatile bool event; + bq2419x_pmu_charger_t *bq2419x_charger; + + bq2419x_charger = container_of( + pmu_charger, struct bq2419x_pmu_charger, pmu_charger); + + event = false; + flags = PMU_CHARGER_EVENT_NONE; + + ATOMIC_BLOCK(ATOMIC_RESTORESTATE) { + if (bq2419x_charger->event) { + bq2419x_charger->event = false; + event = true; + } + } + + if (event) { + + ret = bq2419x_read(BQ2419X_REG_SYSTEM_STATUS, &status); + if (ret) + return ret; + + if (status != bq2419x_charger->status) { + if ((bq2419x_charger->status & BQ2419X_PG_STAT_MASK) && + !(status & BQ2419X_PG_STAT_MASK)) { + /* we're in host mode and need to turn off HIZ + * when PG_STAT goes 1->0, in order to have the + * battery supply the juice */ + ret = bq2419x_read(BQ2419X_REG_INPUT_SRC_CTL, + &isc); + if (ret) + return 0; + + isc &= ~BQ2419X_EN_HIZ_MASK; + ret = bq2419x_write(BQ2419X_REG_INPUT_SRC_CTL, + isc); + if (ret) + return 0; + } + + if ((bq2419x_charger->status & BQ2419X_CHG_STAT_MASK) + != (status & BQ2419X_CHG_STAT_MASK)) { + if ((status & BQ2419X_CHG_STAT_MASK) >> BQ2419X_CHG_STAT_SHIFT == 0x3) + flags |= PMU_CHARGER_EVENT_CHARGE_DONE; + } + bq2419x_charger->status = status; + flags |= PMU_CHARGER_EVENT_STATUS_CHANGE; + } + + ret = bq2419x_read(BQ2419X_REG_FAULT, &fault); + if (ret) + return ret; + + if (fault != bq2419x_charger->fault) { + bq2419x_charger->fault = fault; + bq2419x_charger->battery_status_valid = true; + bq2419x_charger->battery_health_valid = true; + bq2419x_charger->charger_health_valid = true; + flags |= PMU_CHARGER_EVENT_FAULT_CHANGE; + } + + if (!bq2419x_charger->first_time) + bq2419x_charger->first_time = true; + } + return flags; +} + +irqreturn_t bq2419x_irq_handler(void) +{ + /* we check if the device indicates an event + * if so we are the source of the IRQ, + * so set the flag to deal with it later. + * Otherwise we indicate to check the other devices, + * by returning IRQ_NONE + */ + if (bq2419x_get_irq()) { + charger.event = true; + return IRQ_HANDLED; + } + (void) charger.event; + return IRQ_NONE; +} + +static const pmu_charger_ops_t bq2419x_pmu_charger_ops = { + .set_charger_voltage = NULL, + .set_charger_current = NULL, + + .get_charge_type = bq2419x_charger_get_charge_type, + .set_charge_type = NULL, + .get_charger_health = bq2419x_charger_get_health, + .get_charger_online = bq2419x_charger_get_online, + + .get_battery_health = bq2419x_battery_get_health, + .get_battery_status = bq2419x_battery_get_status, + .get_battery_online = bq2419x_battery_get_online, + + .check_events = bq2419x_pmu_charger_check_events, +}; + +int8_t bq2419x_init(void) +{ + uint8_t id, input_src_ctrl, ir_comp; + int8_t ret; + + /* initialize the state struct */ + memset(&charger, 0, sizeof(charger)); + charger.pmu_charger.ops = &bq2419x_pmu_charger_ops; + charger.first_time = true; + + /* check vendor register to verify we're looking at + * a TI BQ2419x chip */ + ret = bq2419x_read(BQ2419X_REG_VENDOR_PART_REV, &id); + if (ret) + goto fail_i2c_read; + + /* set charge IRQ pin as input */ + io_input_pin(CHG_IRQ); + io_set_pin(CHG_IRQ); + + bq2419x_reset(); + bq2419x_set_host_mode(); + + /* we leave the other registers at default values + * BQ2419X_REG_PWR_ON_CONFIG: + * - minimum system voltage limit (default) 101 3.5V + * BQ2419X_REG_CHARGE_VOLTAGE: + * - fast charge current limit (default) 011000 2048mA + * BQ2419X_REG_PRE_TERM_CURRENT: + * - pre-charge current limit (default) 0001 256mA + * - termination current limit (default) 0001 256mA + * BQ2419X_REG_CHARGE_VOLTAGE: + * - charge voltage limit (default) 101100 4.208V + */ + + bq2419x_read(BQ2419X_REG_INPUT_SRC_CTL, &input_src_ctrl); + + /* set a 3A limit */ + input_src_ctrl |= 0x7; + + ret = bq2419x_write(BQ2419X_REG_INPUT_SRC_CTL, input_src_ctrl); + if (ret) + return ret; + + /* compensate for 20m r_sense */ + ret = bq2419x_read(BQ2419X_REG_THERMAL_REG_CTRL, &ir_comp); + if (ret) + return ret; + ir_comp &= ~BQ2419X_BAT_COMP_MASK; + ir_comp |= (0x02 << BQ2419X_BAT_COMP_SHIFT); + + /* set thermal regulation to 60 C */ + ir_comp &= ~BQ2419X_TREG_MASK; + ir_comp |= (0x00 << BQ2419X_TREG_SHIFT); + + ret = bq2419x_write(BQ2419X_REG_THERMAL_REG_CTRL, ir_comp); + if (ret) + return ret; + + pmu_register_charger(&charger.pmu_charger); + + return 0; + +fail_i2c_read: + return 1; +} diff --git a/firmware/e300/battery/bq2419x.h b/firmware/e300/battery/bq2419x.h new file mode 100644 index 000000000..97e691e33 --- /dev/null +++ b/firmware/e300/battery/bq2419x.h @@ -0,0 +1,46 @@ +/* USRP E310 Firmware Texas Instruments BQ2419x driver + * Copyright (C) 2014 Ettus Research + * This file is part of the USRP E310 Firmware + * The USRP E310 Firmware is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 2 of the License, or + * (at your option) any later version. + * The USRP E310 Firmware is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * You should have received a copy of the GNU General Public License + * along with the USRP E310 Firmware. If not, see <http://www.gnu.org/licenses/>. + */ + +/** + * \file bq2419x.h + * \brief Texas Instruments BQ2419x driver + */ + +#ifndef BQ2419X_H +#define BQ2419X_H + +#include <stdbool.h> +#include <stdint.h> + +#include "pmu.h" +#include "interrupt.h" + +typedef enum { + BQ2419X_MODEL_24192 = 0x0, + BQ2419X_MODEL_24191 = 0x1, +} bq2491x_model_t; + +/** + * \brief Initializes the BQ2419X chip + */ +int8_t bq2419x_init(void); + +/** + * \brief The IRQ handler for the CHG_IRQ external pin change interrupt + * \return IRQ_HANDLED in case IRQ was handled, IRQ_NONE in case shared interrupt is not for us + */ +extern irqreturn_t bq2419x_irq_handler(void); + +#endif /* BQ2419X_H */ diff --git a/firmware/e300/battery/eeprom.c b/firmware/e300/battery/eeprom.c new file mode 100644 index 000000000..f8bc172d2 --- /dev/null +++ b/firmware/e300/battery/eeprom.c @@ -0,0 +1,43 @@ +/* USRP E310 Firmware EEPROM driver + * Copyright (C) 2014 Ettus Research + * This file is part of the USRP E310 Firmware + * The USRP E310 Firmware is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 2 of the License, or + * (at your option) any later version. + * The USRP E310 Firmware is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * You should have received a copy of the GNU General Public License + * along with the USRP E310 Firmware. If not, see <http://www.gnu.org/licenses/>. + */ + +#include "eeprom.h" +#include <avr/eeprom.h> + +/* the avr libc wants it this way ... */ +static uint8_t* EEPROM_AUTOBOOT_OFFSET = (uint8_t *) 0x00; +static uint16_t *EEPROM_LAST_FULL_OFFSET = (uint16_t *) 0x04; + +static const uint8_t EEPROM_AUTOBOOT_MAGIC = 0xa5; + +bool eeprom_get_autoboot(void) +{ + return EEPROM_AUTOBOOT_MAGIC == eeprom_read_byte(EEPROM_AUTOBOOT_OFFSET); +} + +void eeprom_set_autoboot(bool on) +{ + eeprom_update_byte(EEPROM_AUTOBOOT_OFFSET, on ? EEPROM_AUTOBOOT_MAGIC : 0x00); +} + +uint16_t eeprom_get_last_full(void) +{ + return eeprom_read_word(EEPROM_LAST_FULL_OFFSET); +} + +void eeprom_set_last_full_charge(uint16_t charge) +{ + eeprom_update_word(EEPROM_LAST_FULL_OFFSET, charge); +} diff --git a/firmware/e300/battery/eeprom.h b/firmware/e300/battery/eeprom.h new file mode 100644 index 000000000..79ae505b6 --- /dev/null +++ b/firmware/e300/battery/eeprom.h @@ -0,0 +1,55 @@ +/* USRP E310 Firmware EEPROM driver + * Copyright (C) 2014 Ettus Research + * This file is part of the USRP E310 Firmware + * The USRP E310 Firmware is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 2 of the License, or + * (at your option) any later version. + * The USRP E310 Firmware is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * You should have received a copy of the GNU General Public License + * along with the USRP E310 Firmware. If not, see <http://www.gnu.org/licenses/>. + */ + +/** + * \file eeprom.h + * \brief AVR EEPROM driver + */ + +#ifndef EEPROM_H +#define EEPROM_H + +#include <stdint.h> +#include <stdbool.h> +#include <avr/io.h> + +/** + * \brief Get the value for the autoboot flag set in the EEPROM + * + */ +bool eeprom_get_autoboot(void); + +/** + * \brief Set the value for the autoboot flag set in the EEPROM + * + * \param[in] on value to write to EEPROM. Use 'true' to turn on autoboot. + * + */ +void eeprom_set_autoboot(bool on); + +/** + * \brief Get last full charge from the EEPROM + * + */ +uint16_t eeprom_get_last_full(void); + +/** + * \brief Set last full charge in the EEPROM + * + * \param[in] charge value to write to EEPROM. + */ +void eeprom_set_last_full_charge(uint16_t charge); + +#endif /* EEPROM_H */ diff --git a/firmware/e300/battery/fpga.c b/firmware/e300/battery/fpga.c new file mode 100644 index 000000000..20404e5a1 --- /dev/null +++ b/firmware/e300/battery/fpga.c @@ -0,0 +1,296 @@ +/* USRP E310 FPGA driver + * Copyright (C) 2014 Ettus Research + * This file is part of the USRP E310 Firmware + * The USRP E310 Firmware is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 2 of the License, or + * (at your option) any later version. + * The USRP E310 Firmware is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * You should have received a copy of the GNU General Public License + * along with the USRP E310 Firmware. If not, see <http://www.gnu.org/licenses/>. + */ + +#include "eeprom.h" +#include "fpga.h" +#include "spi.h" +#include "mcu_settings.h" +#include "utils.h" +#include <util/delay.h> +#include <string.h> +#include <stdbool.h> + +typedef struct fpga_tx_mem_map0 { + uint16_t battery_voltage; + uint8_t battery_status; + uint8_t charger_status; + uint8_t unused[2]; + uint8_t version; + uint8_t type; +} fpga_tx_mem_map0_t; + +typedef struct fpga_tx_mem_map1 { + uint8_t status; + uint16_t voltage; + uint16_t temp; + uint16_t charge; + uint8_t type; +} fpga_tx_mem_map1_t; + +typedef struct fpga_tx_mem_map2 { + uint8_t unused[4]; + uint8_t settings; + uint16_t charge_last_full; + uint8_t type; +} fpga_tx_mem_map2_t; + +typedef struct fpga_rx_mem_map0 { + uint8_t unused[2]; + uint16_t value; + uint8_t reg; + uint8_t os_status; +} fpga_rx_mem_map0_t; + +typedef struct fpga_rx_mem_map1 { + uint8_t unused[3]; + uint16_t value; + uint8_t reg; +} fpga_rx_mem_map1_t; + +typedef struct fpga_rx_mem_map { + uint8_t valid; + union { + fpga_rx_mem_map0_t map0; + fpga_rx_mem_map1_t map1; + }; + uint8_t type; +} fpga_rx_mem_map_t; + +static bool shutdown = false; +static bool write_charge = false; +static bool write_settings = false; + +static volatile fpga_tx_mem_map0_t fpga_tx0; +static volatile fpga_tx_mem_map1_t fpga_tx1; +static volatile fpga_tx_mem_map2_t fpga_tx2; +static volatile fpga_rx_mem_map_t fpga_rx; + +/* battery status */ +static const uint8_t BATTERY_TEMP_ALERT_MASK = BIT(7) | BIT(6); +static const uint8_t BATTERY_TEMP_ALERT_SHIFT = 6; +static const uint8_t BATTERY_ONLINE_MASK = BIT(5); +static const uint8_t BATTERY_ONLINE_SHIFT = 5; +static const uint8_t BATTERY_HEALTH_MASK = BIT(4) | BIT(3) | BIT(2); +static const uint8_t BATTERY_HEALTH_SHIFT = 2; +static const uint8_t BATTERY_STATUS_MASK = BIT(1) | BIT(0); +static const uint8_t BATTERY_STATUS_SHIFT = 0; + +/* charger_status */ +static const uint8_t CHARGER_HEALTH_MASK = BIT(5) | BIT(4); +static const uint8_t CHARGER_HEALTH_SHIFT = 4; +static const uint8_t CHARGER_ONLINE_MASK = BIT(3); +static const uint8_t CHARGER_ONLINE_SHIFT = 3; +/* BIT(2) is unused */ +static const uint8_t CHARGER_CHARGE_TYPE_MASK = BIT(1) | BIT(0); +static const uint8_t CHARGER_CHARGE_TYPE_SHIFT = 0; + + +void fpga_set_battery_voltage(uint16_t voltage) +{ + fpga_tx0.battery_voltage = voltage; +} + +void fpga_set_battery_temp_alert(uint8_t alert) +{ + uint8_t status = fpga_tx0.battery_status; + + status &= ~BATTERY_TEMP_ALERT_MASK; + status |= alert << BATTERY_TEMP_ALERT_SHIFT; + + fpga_tx0.battery_status = status; +} + +void fpga_set_battery_online(bool online) +{ + uint8_t status = fpga_tx0.battery_status; + + status &= ~BATTERY_ONLINE_MASK; + status |= (online ? 1 : 0) << BATTERY_ONLINE_SHIFT; + + fpga_tx0.battery_status = status; +} + +void fpga_set_battery_health(uint8_t health) +{ + uint8_t status = fpga_tx0.battery_status; + + status &= ~BATTERY_HEALTH_MASK; + status |= health << BATTERY_HEALTH_SHIFT; + + fpga_tx0.battery_status = status; +} + +void fpga_set_battery_status(uint8_t st) +{ + uint8_t status = fpga_tx0.battery_status; + + status &= ~BATTERY_STATUS_MASK; + status |= st << BATTERY_STATUS_SHIFT; + + fpga_tx0.battery_status = status; +} + +void fpga_set_charger_health(uint8_t health) +{ + uint8_t status = fpga_tx0.charger_status; + + status &= ~CHARGER_HEALTH_MASK; + status |= health << CHARGER_HEALTH_SHIFT; + + fpga_tx0.charger_status = status; +} + +void fpga_set_charger_online(bool online) +{ + uint8_t status = fpga_tx0.charger_status; + + status &= ~CHARGER_ONLINE_MASK; + status |= (online ? 1 : 0) << CHARGER_ONLINE_SHIFT; + + fpga_tx0.charger_status = status; +} + +void fpga_set_charger_charge_type(uint8_t type) +{ + uint8_t status = fpga_tx0.charger_status; + + status &= ~CHARGER_CHARGE_TYPE_MASK; + status |= type << CHARGER_CHARGE_TYPE_SHIFT; + + fpga_tx0.charger_status = status; +} + +void fpga_set_gauge_charge(uint16_t charge) +{ + fpga_tx1.charge = charge; +} + +uint16_t fpga_get_gauge_charge(void) +{ + return fpga_tx1.charge; +} + +bool fpga_get_write_charge(void) +{ + bool ret = false; + + if (write_charge) { + ret = write_charge; + write_charge = false; + } + + return ret; +} + +uint8_t fpga_get_settings(void) +{ + return fpga_tx2.settings; +} + +bool fpga_get_write_settings(void) +{ + bool ret = false; + + if (write_settings) { + ret = write_settings; + write_settings = false; + } + + return ret; +} + +void fpga_set_gauge_charge_last_full(uint16_t charge) +{ + fpga_tx2.charge_last_full = charge; +} + +void fpga_set_gauge_temp(uint16_t temp) +{ + fpga_tx1.temp = temp; +} + +void fpga_set_gauge_voltage(uint16_t volt) +{ + fpga_tx1.voltage = volt; +} + +void fpga_set_gauge_status(uint8_t status) +{ + fpga_tx1.status = status; +} + +bool fpga_get_shutdown(void) +{ + return shutdown; +} + +void fpga_init(void) +{ + memset((void *) &fpga_tx0, 0, sizeof(fpga_tx0)); + memset((void *) &fpga_tx1, 0, sizeof(fpga_tx1)); + memset((void *) &fpga_tx2, 0, sizeof(fpga_tx2)); + fpga_tx0.type = 0; + fpga_tx0.version = VERSION_MAJ << 4 | VERSION_MIN; + + fpga_tx1.type = 1; + fpga_tx2.type = 2; + + /* get autoboot value from eeprom, keep TX reg on */ + fpga_tx2.settings = BIT(1) | eeprom_get_autoboot() ? 0x1 : 0x0; + + memset((void *) &fpga_rx, 0, sizeof(fpga_rx)); + + shutdown = false; +} + +void fpga_handle_write(uint8_t reg, uint16_t value) +{ + if (reg == 0x10) { + fpga_tx1.charge = value; + write_charge = true; + } else if (reg == 0x14) { + fpga_tx1.status = value; + } else if (reg == 0x1c) { + fpga_tx2.settings = (uint8_t) value; + write_settings = true; + } +} + +void fpga_sync(void) +{ + fpga_rx_mem_map_t rx; + + spi_transact_buf((uint8_t *) &fpga_tx0, (uint8_t *) &rx, 8); + if (rx.valid) { + if (rx.type == 0 && rx.map0.os_status == 0x7a) + shutdown = true; + else if (rx.type == 1) + fpga_handle_write(rx.map1.reg, rx.map1.value); + } + spi_transact_buf((uint8_t *) &fpga_tx1, (uint8_t *) &rx, 8); + if (rx.valid) { + if (rx.type == 0 && rx.map0.os_status == 0x7a) + shutdown = true; + else if (rx.type == 1) + fpga_handle_write(rx.map1.reg, rx.map1.value); + } + spi_transact_buf((uint8_t *) &fpga_tx2, (uint8_t *) &rx, 8); + if (rx.valid) { + if (rx.type == 0 && rx.map0.os_status == 0x7a) + shutdown = true; + else if (rx.type == 1) + fpga_handle_write(rx.map1.reg, rx.map1.value); + } +} diff --git a/firmware/e300/battery/fpga.h b/firmware/e300/battery/fpga.h new file mode 100644 index 000000000..869c130de --- /dev/null +++ b/firmware/e300/battery/fpga.h @@ -0,0 +1,180 @@ +/* USRP E310 Firmware FPGA driver + * Copyright (C) 2014 Ettus Research + * This file is part of the USRP E310 Firmware + * The USRP E310 Firmware is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 2 of the License, or + * (at your option) any later version. + * The USRP E310 Firmware is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * You should have received a copy of the GNU General Public License + * along with the USRP E310 Firmware. If not, see <http://www.gnu.org/licenses/>. + */ + +/** + * \file fpga.h + * \brief FPGA driver + */ + +#ifndef FPGA_H +#define FPGA_H + +#include <stdint.h> +#include <stdbool.h> + +/** + * \brief Initialize the fpga internal shadow registers + * + */ +void fpga_init(void); + +/* battery stuff */ + +/** + * \brief Initialize the fpga internal shadow registers + * + * \param[in] voltage The voltage that will be sent to the FPGA + * + */ +void fpga_set_battery_voltage(uint16_t voltage); + +/** + * \brief Trigger a battery temp alert in FPGA + * + * \param[in] alert The alert flags + * + */ +void fpga_set_battery_temp_alert(uint8_t alert); + +void fpga_set_battery_online(bool online); + +bool fpga_get_battery_online(void); + +/** + * \brief Set the battery health that will be sent to the FPGA with next fpga_sync() + * + * \param[in] health The battery health + * + */ +void fpga_set_battery_health(uint8_t health); + +/** + * \brief Set the battery status that will be sent to the FPGA with next fpga_sync() + * + * \param[in] status The battery status + * + */ +void fpga_set_battery_status(uint8_t status); + +/* charger stuff */ +/** + * \brief Set the charger status that will be sent to the FPGA with next fpga_sync() + * + * \param[in] status The charger status + * + */ +void fpga_set_charger_status(uint8_t status); + +void fpga_set_charger_online(bool online); + +void fpga_set_charger_charge_type(uint8_t type); + +/** + * \brief Set the charger health that will be sent to the FPGA with next fpga_sync() + * + * \param[in] health The charger health + * + */ +void fpga_set_charger_health(uint8_t health); + +/** + * \brief Set the gauge charge value that is sent to the FPGA with next fpga_sync() + * + * \param[in] charge The accumulated charge value + * + */ +void fpga_set_gauge_charge(uint16_t charge); + +/** + * \brief Get the gauge charge value that is stored in shadow register + * + * \return The accumulated charge value stored in shadow register + * + */ +uint16_t fpga_get_gauge_charge(void); + +/** + * \brief Set the gauge charge last full value that is sent to the FPGA with next fpga_sync() + * + * \param[in] charge The accumulated charge when last charge cycle terminated + * + */ +void fpga_set_gauge_charge_last_full(uint16_t charge); + +/** + * \brief Set the gauge temperature value that is sent to the FPGA with next fpga_sync() + * + * \param[in] temp The temperature as reported by fuel gauge + * + */ +void fpga_set_gauge_temp(uint16_t temp); + +/** + * \brief Set the gauge voltage value that is sent to the FPGA with next fpga_sync() + * + * \param[in] volt The voltage as reported by fuel gauge + * + */ +void fpga_set_gauge_voltage(uint16_t volt); + +/** + * \brief Set the gauge status value that is sent to the FPGA with next fpga_sync() + * + * \param[in] status The status as reported by fuel gauge + * + */ +void fpga_set_gauge_status(uint8_t status); + +/* misc stuff */ + +/** + * \brief Get the shutdown flag from the shadow registers + * + * \return true if shutdown was requested by FPGA + * + */ +bool fpga_get_shutdown(void); + +/** + * \brief Get the write charge flag from shadow register + * + * \return true if write to charge count was requested by FPGA + * + */ +bool fpga_get_write_charge(void); + +/** + * \brief Get the settings from shadow register + * + * \return value that was requested to be stored in settings reg + * + */ +uint8_t fpga_get_settings(void); + +/** + * \brief Get the settings write flag from shadow register + * + * \return true if write to settings reg was requested by FPGA + * + */ +bool fpga_get_write_settings(void); + +/** + * \brief Synchronize the shadow registers with the FPGA + * + */ +void fpga_sync(void); + +#endif /* FPGA_H */ diff --git a/firmware/e300/battery/i2c_twi.c b/firmware/e300/battery/i2c_twi.c new file mode 100644 index 000000000..f2c0491d3 --- /dev/null +++ b/firmware/e300/battery/i2c_twi.c @@ -0,0 +1,187 @@ +/* USRP E310 Firmware Atmel AVR TWI driver + * Copyright (C) 2014 Ettus Research + * This file is part of the USRP E310 Firmware + * The USRP E310 Firmware is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 2 of the License, or + * (at your option) any later version. + * The USRP E310 Firmware is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * You should have received a copy of the GNU General Public License + * along with the USRP E310 Firmware. If not, see <http://www.gnu.org/licenses/>. + */ + +#include "i2c_twi.h" +#include "mcu_settings.h" +#include "utils.h" + +#include <stdbool.h> +#include <avr/io.h> +#include <util/twi.h> +#include <util/delay.h> + +static const uint8_t I2C_TIMEOUT = 10; + +static inline uint8_t I2C_READ_ADDR(const uint8_t x) +{ + return (x << 1) | 0x1; +} + +static inline uint8_t I2C_WRITE_ADDR(const uint8_t x) +{ + return (x << 1) & 0xfe; +} + +void i2c_twi_init_calc(uint32_t rate) +{ + uint8_t twbr; + twbr = ((F_CPU/rate)-16)/2; + + TWBR = twbr; + + PRR &= ~BIT(PRTWI); + + /* www.mikrocontroller.net/articles/AVR_TWI says this might help ... */ + TWCR &= ~(BIT(TWSTO) | BIT(TWEN)); + TWCR |= BIT(TWEN); +} + +void i2c_twi_init(i2c_speed_t speed) +{ + switch (speed) { + case I2C_SPEED_400K: + TWBR = 16; + break; + case I2C_SPEED_100K: + TWBR = 32; + break; + default: + TWBR = 32; + break; + } + + /* reset potential prescalers */ + TWSR = 0; + + /* www.mikrocontroller.net/articles/AVR_TWI says this might help ... */ + TWCR &= ~(BIT(TWSTO) | BIT(TWEN)); + TWCR |= BIT(TWEN); +} + +static void i2c_twi_wait_for_complete(void) +{ + uint8_t timeout = 100; + + do { + _delay_us(10); + timeout--; + } while(timeout && !(TWCR & (1<<TWINT))); +} + +static void i2c_twi_start(void) +{ + TWCR = BIT(TWINT) | BIT(TWEN) | BIT(TWSTA); + i2c_twi_wait_for_complete(); +} + +static void i2c_twi_stop(void) +{ + TWCR = BIT(TWINT) | BIT(TWEN) | BIT(TWSTO); +} + + +static uint8_t i2c_twi_recv_byte(bool ack) +{ + TWCR = BIT(TWINT) | BIT(TWEN) | (ack ? BIT(TWEA) : 0); + i2c_twi_wait_for_complete(); + return TWDR; +} + +static void i2c_twi_send_byte(uint8_t data) +{ + TWDR = data; + TWCR = BIT(TWINT) | BIT(TWEN); + i2c_twi_wait_for_complete(); +} + +int8_t i2c_twi_read(uint8_t addr, uint8_t reg, uint8_t *value) +{ + /* start the write transaction to select the register */ + i2c_twi_start(); + i2c_twi_send_byte(I2C_WRITE_ADDR(addr)); + i2c_twi_send_byte(reg); + + /* (re)start for the actual read transaction to read back */ + i2c_twi_start(); + i2c_twi_send_byte(I2C_READ_ADDR(addr)); + *value = i2c_twi_recv_byte(false); + i2c_twi_stop(); + + return 0; +} + +int8_t i2c_twi_write(uint8_t addr, uint8_t reg, uint8_t value) +{ + i2c_twi_start(); + i2c_twi_send_byte(I2C_WRITE_ADDR(addr)); + i2c_twi_send_byte(reg); + i2c_twi_send_byte(value); + i2c_twi_stop(); + + return 0; +} + +int8_t i2c_twi_read16(uint8_t addr, uint8_t reg, uint16_t *value) +{ + uint8_t msb, lsb; + + /* start the write transaction to select the register */ + i2c_twi_start(); + i2c_twi_send_byte(I2C_WRITE_ADDR(addr)); + i2c_twi_send_byte(reg); + + /* (re)start for the actual read transaction to read back MSB + * then LSB, fortunately the datashit describes the opposite w.r.t ACKs*/ + i2c_twi_start(); + i2c_twi_send_byte(I2C_READ_ADDR(addr)); + msb = i2c_twi_recv_byte(true); + lsb = i2c_twi_recv_byte(false); + i2c_twi_stop(); + + *value = (msb << 8) | lsb; + + return 0; +} + +int8_t i2c_twi_write16(uint8_t addr, uint8_t reg, uint16_t value) +{ + uint8_t msb, lsb; + + msb = value >> 8; + lsb = value & 0xff; + + i2c_twi_start(); + i2c_twi_send_byte(I2C_WRITE_ADDR(addr)); + i2c_twi_send_byte(reg); + i2c_twi_send_byte(msb); + i2c_twi_send_byte(lsb); + i2c_twi_stop(); + + return 0; +} + +/* +static const uint8_t I2C_ARA_ADDR = 0x0c; +uint8_t i2c_twi_smbus_ara(void) +{ + volatile uint8_t addr;; + + i2c_twi_start(); + i2c_twi_send_byte(I2C_READ_ADDR(I2C_ARA_ADDR)); + addr = i2c_twi_recv_byte(false); + i2c_twi_stop(); + return addr; +} +*/ diff --git a/firmware/e300/battery/i2c_twi.h b/firmware/e300/battery/i2c_twi.h new file mode 100644 index 000000000..dd88a683d --- /dev/null +++ b/firmware/e300/battery/i2c_twi.h @@ -0,0 +1,95 @@ +/* USRP E310 Firmware Atmel AVR TWI driver + * Copyright (C) 2014 Ettus Research + * This file is part of the USRP E310 Firmware + * The USRP E310 Firmware is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 2 of the License, or + * (at your option) any later version. + * The USRP E310 Firmware is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * You should have received a copy of the GNU General Public License + * along with the USRP E310 Firmware. If not, see <http://www.gnu.org/licenses/>. + */ + +/** + * \file i2c_twi.h + * \brief Atmel AVR TWI driver + */ + +#ifndef I2C_TWI_H +#define I2C_TWI_H + +#include <stdlib.h> +#include <stdio.h> + +/** + * \brief Used for initializing the TWI/I2C module + */ +typedef enum i2c_speed_t { + I2C_SPEED_100K, + I2C_SPEED_400K, +} i2c_speed_t; + +/** + * \brief Initialize and calculate the TWBR value based on F_CPU and given rate + * + * \param[in] rate Target rate + */ +void i2c_twi_init_calc(uint32_t rate); + +/** + * \brief Initializes the AVR TWI/I2C module + * + * \param[in] speed Can be either 100KHz or 400Khz + */ +void i2c_twi_init(i2c_speed_t speed); + +/** + * \brief Read I2C register from I2C slave + * \param[in] addr I2C slave address + * \param[in] reg Register address in slave register map + * \param[out] value Output value + * \return 0 on success, negative error code otherwise + */ +int8_t i2c_twi_read(uint8_t addr, uint8_t reg, uint8_t *value); + +/** + * \brief Read 2 byte I2C register from I2C slave + * + * This is behaving a bit funny but is required for getting + * the 2 byte values from the LTC294x chip. + * + * \param[in] addr I2C slave address + * \param[in] reg Register address in slave register map + * \param[out] value Output value + * \return 0 on success, negative error code otherwise + */ +int8_t i2c_twi_read16(uint8_t addr, uint8_t reg, uint16_t *value); + +/** + * \brief Write I2C register in I2C slave + * \param[in] addr I2C slave address + * \param[in] reg Register address in slave register map + * \param[in] value Value to be written + * \return 0 on success, negative error code otherwise + */ +int8_t i2c_twi_write(uint8_t addr, uint8_t reg, uint8_t value); + +/** + * \brief Write 2 byte I2C register in I2C slave + * \param[in] addr I2C slave address + * \param[in] reg Register address in slave register map + * \param[in] value Value to be written + * \return 0 on success, negative error code otherwise + */ +int8_t i2c_twi_write16(uint8_t addr, uint8_t reg, uint16_t value); + +/** + * \brief Handle SMBus alert response + * \return 0 on success, negative error code otherwise + */ +uint8_t i2c_twi_smbus_ara(void); + +#endif /* I2C_TWI_H */ diff --git a/firmware/e300/battery/interrupt.c b/firmware/e300/battery/interrupt.c new file mode 100644 index 000000000..f0daeddcd --- /dev/null +++ b/firmware/e300/battery/interrupt.c @@ -0,0 +1,154 @@ +/* USRP E310 Firmware Interrupt Management + * Copyright (C) 2014 Ettus Research + * This file is part of the USRP E310 Firmware + * The USRP E310 Firmware is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 2 of the License, or + * (at your option) any later version. + * The USRP E310 Firmware is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * You should have received a copy of the GNU General Public License + * along with the USRP E310 Firmware. If not, see <http://www.gnu.org/licenses/>. + */ + +#include <stdint.h> +#include <avr/interrupt.h> + +#include "utils.h" +#include "interrupt.h" + +#include "bq2419x.h" +#include "tps54478.h" +#include "ltc3675.h" +#include "ltc294x.h" +#include "pmu.h" +#include "led.h" + +static const irq_handler_t pcint0_irqs[] = {bq2419x_irq_handler}; +static const irq_handler_t pcint1_irqs[] = {NULL}; +static const irq_handler_t pcint2_irqs[] = {NULL}; +static const irq_handler_t pcint3_irqs[] = {NULL}; +static const irq_handler_t int0_handler = ltc3675_button_wakeup_irq_handler; +static const irq_handler_t int1_handler = ltc3675_button_change_irq_handler; +//static const irq_handler_t timer0_comp_a_handler = pmu_led_timer_comp_a_irq_handler; +//static const irq_handler_t timer0_comp_b_handler = pmu_led_timer_comp_b_irq_handler; +static const irq_handler_t timer1_handler = ltc3675_button_timer_irq_handler; +static const irq_handler_t wdt_handler = {led_wdt_handler}; + +void interrupt_init(void) +{ + /* rising edge for WAKEUP and any change for ONSWITCH_DB */ + EICRA = BIT(ISC01) | BIT(ISC00) | BIT(ISC10); + + /* enable interrupt for WAKE */ + EIMSK = BIT(INT1) | BIT(INT0); + + /* enable interrupt for CORE_PGOOD and CHG_IRQ */ + PCMSK0 = /*BIT(PCINT0) | */ BIT(PCINT1); + + /* enable interrupts for PWR_IRQ and AVR_IRQ */ + PCMSK2 = BIT(PCINT16) | BIT(PCINT21); + + /* enable interrupts for FC_ALn_CC */ + //PCMSK3 = BIT(PCINT24); + + /* unmask IRQs for PC[23:16] and PC[7:0] */ + PCICR = BIT(PCIE3) | BIT(PCIE2) | BIT(PCIE0); +} + +ISR(PCINT0_vect) +{ + uint8_t i; + irqreturn_t ret; + + for (i = 0; i < ARRAY_SIZE(pcint0_irqs); i++) { + irq_handler_t handler = pcint0_irqs[i]; + if (handler != NULL) { + ret = handler(); + if (ret == IRQ_HANDLED) + break; + } + } +} + +ISR(PCINT1_vect) +{ + uint8_t i; + irqreturn_t ret; + + for (i = 0; i < ARRAY_SIZE(pcint1_irqs); i++) { + irq_handler_t handler = pcint1_irqs[i]; + if (handler != NULL) { + ret = handler(); + if (ret == IRQ_HANDLED) + break; + } + } +} + +ISR(PCINT2_vect) +{ + uint8_t i; + irqreturn_t ret; + + for (i = 0; i < ARRAY_SIZE(pcint2_irqs); i++) { + irq_handler_t handler = pcint2_irqs[i]; + if (handler != NULL) { + ret = handler(); + if (ret == IRQ_HANDLED) + break; + } + } +} + +ISR(PCINT3_vect) +{ + uint8_t i; + irqreturn_t ret; + + for (i = 0; i < ARRAY_SIZE(pcint3_irqs); i++) { + irq_handler_t handler = pcint3_irqs[i]; + if (handler != NULL) { + ret = handler(); + if (ret == IRQ_HANDLED) + break; + } + } +} + +ISR(INT0_vect) +{ + if (int0_handler) + int0_handler(); +} + +ISR(INT1_vect) +{ + if (int1_handler) { + int1_handler(); + } +} + +/* +ISR(TIMER0_COMPA_vect) +{ + timer0_comp_a_handler(); +} + +ISR(TIMER0_COMPB_vect) +{ + timer0_comp_b_handler(); +} +*/ + +ISR(TIMER1_COMPA_vect) +{ + timer1_handler(); +} + +ISR(WDT_vect) +{ + wdt_handler(); +} diff --git a/firmware/e300/battery/interrupt.h b/firmware/e300/battery/interrupt.h new file mode 100644 index 000000000..32cd3f174 --- /dev/null +++ b/firmware/e300/battery/interrupt.h @@ -0,0 +1,40 @@ +/* USRP E310 Firmware Interrupt Management + * Copyright (C) 2014 Ettus Research + * This file is part of the USRP E310 Firmware + * The USRP E310 Firmware is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 2 of the License, or + * (at your option) any later version. + * The USRP E310 Firmware is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * You should have received a copy of the GNU General Public License + * along with the USRP E310 Firmware. If not, see <http://www.gnu.org/licenses/>. + */ + +#ifndef INTERRUPT_H +#define INTERRUPT_H + +/** + * \brief Shared IRQ handlers return either of these values + * + * A shared IRQ handler will either 'claim' the IRQ and return IRQ_HANDLED, + * or indicate it is not sure whether it was the IRQ source and return IRQ_NONE. + */ +typedef enum { + IRQ_NONE, + IRQ_HANDLED +} irqreturn_t; + +/** + * \brief (Shared) IRQ handlers should use this type signature + */ +typedef irqreturn_t (*irq_handler_t)(void); + +/** + * \brief Initialize the IRQ subsystem + */ +void interrupt_init(void); + +#endif /* INTERRUPT_H */ diff --git a/firmware/e300/battery/io.c b/firmware/e300/battery/io.c new file mode 100644 index 000000000..8bb393705 --- /dev/null +++ b/firmware/e300/battery/io.c @@ -0,0 +1,67 @@ +/* USRP E310 IO helpers +* Copyright (C) 2014 Ettus Research +* This file is part of the USRP E310 Firmware +* The USRP E310 Firmware is free software: you can redistribute it and/or modify +* it under the terms of the GNU General Public License as published by +* the Free Software Foundation, either version 2 of the License, or +* (at your option) any later version. +* The USRP E310 Firmware is distributed in the hope that it will be useful, +* but WITHOUT ANY WARRANTY; without even the implied warranty of +* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +* GNU General Public License for more details. +* You should have received a copy of the GNU General Public License +* along with the USRP E310 Firmware. If not, see <http://www.gnu.org/licenses/>. +*/ + +#include <avr/io.h> + +#include "io.h" +#include "utils.h" + +#define _GET_PIN(pin) ((pin) & 0xf) +#define _GET_MASK(pin) (BIT(_GET_PIN(pin))) +#define _GET_REG(pin, reg_x) (*reg_x[pin >> 4]) + +static volatile uint8_t *ddr_x[] = {&DDRA, &DDRB, &DDRC, &DDRD}; +static volatile uint8_t *port_x[] = {&PORTA, &PORTB, &PORTC, &PORTD}; +static volatile uint8_t *pin_x[] = {&PINA, &PINB, &PINC, &PIND}; + +void io_output_pin(io_pin_t pin) +{ + _GET_REG(pin, ddr_x) |= _GET_MASK(pin); +} + +void io_input_pin(io_pin_t pin) +{ + _GET_REG(pin, ddr_x) &= ~_GET_MASK(pin); +} + +bool io_is_output(io_pin_t pin) +{ + return bit_is_set(_GET_REG(pin, ddr_x), _GET_PIN(pin)); +} + +bool io_is_input(io_pin_t pin) +{ + return !io_is_output(pin); +} + +void io_set_pin(io_pin_t pin) +{ + _GET_REG(pin, port_x) |= _GET_MASK(pin); +} + +void io_clear_pin(io_pin_t pin) +{ + _GET_REG(pin, port_x) &= ~_GET_MASK(pin); +} + +bool io_is_pin_set(io_pin_t pin) +{ + return bit_is_set(_GET_REG(pin, port_x), _GET_PIN(pin)); +} + +bool io_test_pin(io_pin_t pin) +{ + return bit_is_set(_GET_REG(pin, pin_x), _GET_PIN(pin)); +} diff --git a/firmware/e300/battery/io.h b/firmware/e300/battery/io.h new file mode 100644 index 000000000..81c007268 --- /dev/null +++ b/firmware/e300/battery/io.h @@ -0,0 +1,97 @@ +/* USRP E310 IO helpers + * Copyright (C) 2014 Ettus Research + * This file is part of the USRP E310 Firmware + * The USRP E310 Firmware is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 2 of the License, or + * (at your option) any later version. + * The USRP E310 Firmware is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * You should have received a copy of the GNU General Public License + * along with the USRP E310 Firmware. If not, see <http://www.gnu.org/licenses/>. + */ + +/** +* \file io.h +* \brief IO helper functions to manipulate the MCUs pins +*/ + +#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; + +/** + * \brief Make pin an output pin + * + * \param pin The pin to modify + */ +void io_output_pin(io_pin_t pin); + +/** + * \brief Make pin an input pin + * + * \param pin The pin to modify + */ +void io_input_pin(io_pin_t pin); + +/** + * \brief Check if pin is an output + * + * \param pin The pin to query + * \return Returns true if the pin is configured as output + */ +bool io_is_output(io_pin_t pin); + +/** + * \brief Check if pin is an input + * + * \param pin The pin to query + * \return Returns true if the pin is configured as input + */ +bool io_is_input(io_pin_t pin); + +/** + * \brief If the pin is in input mode, this will enable the pull-up, + * if the pin is in output mode, this will set a logic high level + * + * \param[in] pin The pin to modify + */ +void io_set_pin(io_pin_t pin); + +/** + * \brief If the pin is in input mode this will disable the pull-up + * if the pin is in output mode, this will set a logic low level + * + * \param[in] pin The pin to modify + */ +void io_clear_pin(io_pin_t pin); + +/** + * \brief If the pin is in input mode, this returns true if the pull-up is active, + * if the pin is in output mode, this returns true if a logic high is set + * \param[in] pin The pin to query + * \return True if pin is set, False otherwise + */ +bool io_is_pin_set(io_pin_t pin); + + +/** + * \brief If the pin is in input mode, this returns the logic input value + * \param[in] pin The pin to query + * \return Returns true if a logic high is observed on the input pin + */ +bool io_test_pin(io_pin_t pin); + +#endif /* IO_H */ diff --git a/firmware/e300/battery/led.c b/firmware/e300/battery/led.c new file mode 100644 index 000000000..0e7e992ba --- /dev/null +++ b/firmware/e300/battery/led.c @@ -0,0 +1,153 @@ +#include "led.h" +#include "io.h" + +/* hardware io */ +static io_pin_t POWER_LED = IO_PC(7); +static io_pin_t CHARGE = IO_PD(1); + +enum led_color { + LED_C_RED, + LED_C_GREEN, + LED_C_OFF +}; + +static enum led_color led_color; + +static inline void led_set(enum led_color color) +{ + switch (color) { + case LED_C_RED: + io_clear_pin(POWER_LED); + io_set_pin(CHARGE); + break; + case LED_C_GREEN: + io_clear_pin(CHARGE); + io_set_pin(POWER_LED); + break; + case LED_C_OFF: + default: + io_clear_pin(CHARGE); + io_clear_pin(POWER_LED); + break; + } + led_color = color; +} + +/* blinken lights */ +static uint8_t blink_cnt; +static uint8_t orange_cnt; + +/* state for sequence */ +static enum led_state state; +static enum led_state state_next; +static uint8_t seq_max; +static uint8_t seq_cnt; +static const uint8_t T_SEQ = 196; +static const uint8_t T_ON = 98; + +static bool counting; + +void led_set_blink_seq(uint8_t n_blinks, enum led_state color) +{ + if (color == state) + return; + + blink_cnt = 0; + seq_cnt = 0; + seq_max = 2 * n_blinks + 1; + + state = color; +} + +void led_set_solid(enum led_state color) +{ + if (state != LED_BLINK_RED_FAST) + state = color; + state_next = color; +} + +void led_set_blink(enum led_state color) +{ + if (state != LED_BLINK_RED_FAST) + state = color; + state_next = color; +} + +irqreturn_t led_wdt_handler(void) +{ + counting = false; + switch (state) { + case LED_BLINK_GREEN_SLOW: + if (blink_cnt < T_ON) + led_set(LED_C_GREEN); + else + led_set(LED_C_OFF); + blink_cnt += 1; + break; + + case LED_BLINK_GREEN_FAST: + if (blink_cnt < T_ON) + led_set(LED_C_GREEN); + else + led_set(LED_C_OFF); + blink_cnt += 4; + break; + + case LED_BLINK_RED_FAST: + counting = true; + if (!seq_cnt) { + led_set(LED_C_OFF); + } else if (blink_cnt < T_ON) + led_set(seq_cnt % 2 ? LED_C_OFF : LED_C_RED); + else + led_set(LED_C_OFF); + blink_cnt += 16; + break; + + case LED_BLINK_ORANGE: + if (blink_cnt < T_ON) + led_set(orange_cnt % 2 ? LED_C_GREEN : LED_C_RED); + else + led_set(LED_C_OFF); + + orange_cnt++; + blink_cnt += 4; + break; + + case LED_ORANGE: + led_set(orange_cnt % 2 ? LED_C_GREEN : LED_C_RED); + orange_cnt++; + blink_cnt+=4; + break; + + case LED_GREEN: + led_set(LED_C_GREEN); + break; + + case LED_RED: + led_set(LED_C_RED); + break; + + case LED_OFF: + default: + led_set(LED_C_OFF); + break; + } + + if (blink_cnt >= T_SEQ - 1) { + blink_cnt = 0; + if (counting) { + if (seq_cnt < seq_max) { + seq_cnt++; + } else { + state = state_next; + seq_cnt = 0; + counting = false; + } + } else { + state = state_next; + } + } + + return IRQ_HANDLED; +} diff --git a/firmware/e300/battery/led.h b/firmware/e300/battery/led.h new file mode 100644 index 000000000..0952dc3d2 --- /dev/null +++ b/firmware/e300/battery/led.h @@ -0,0 +1,27 @@ +#ifndef LED_H +#define LED_H + +#include <stdint.h> + +#include "interrupt.h" + +enum led_state { + LED_BLINK_GREEN_SLOW, + LED_BLINK_GREEN_FAST, + LED_BLINK_RED_FAST, + LED_BLINK_ORANGE, + LED_ORANGE, + LED_GREEN, + LED_RED, + LED_OFF +}; + +void led_set_blink_seq(uint8_t n_blinks, enum led_state state); + +void led_set_blink(enum led_state state); + +void led_set_solid(enum led_state state); + +extern irqreturn_t led_wdt_handler(void); + +#endif /* LED_H */ diff --git a/firmware/e300/battery/ltc294x.c b/firmware/e300/battery/ltc294x.c new file mode 100644 index 000000000..d62a5e57d --- /dev/null +++ b/firmware/e300/battery/ltc294x.c @@ -0,0 +1,281 @@ +/* USRP E310 Firmware Linear Technology LTC294X driver + * Copyright (C) 2014 Ettus Research + * This file is part of the USRP E310 Firmware + * The USRP E310 Firmware is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 2 of the License, or + * (at your option) any later version. + * The USRP E310 Firmware is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * You should have received a copy of the GNU General Public License + * along with the USRP E310 Firmware. If not, see <http://www.gnu.org/licenses/>. + */ + +#include <stdbool.h> +#include <string.h> +#include <util/atomic.h> +#include <avr/interrupt.h> + +#include "i2c_twi.h" +#include "io.h" +#include "ltc294x.h" +#include "utils.h" +#include "pmu.h" + +static const uint8_t LTC294X_I2C_ADDR = 0x64; + +#define ltc294x_read(reg, val) \ + (i2c_twi_read(LTC294X_I2C_ADDR, reg, val)) + +#define ltc294x_read16(reg, val) \ + (i2c_twi_read16(LTC294X_I2C_ADDR, reg, val)) + +#define ltc294x_write(reg, val) \ + (i2c_twi_write(LTC294X_I2C_ADDR, reg, val)) + +#define ltc294x_write16(reg, val) \ + (i2c_twi_write16(LTC294X_I2C_ADDR, reg, val)) + +static const uint8_t LTC294X_REG_STATUS = 0x00; +static const uint8_t LTC294X_REG_CONTROL = 0x01; +static const uint8_t LTC294X_REG_CHARGE_MSB = 0x2; +static const uint8_t LTC294X_REG_CHARGE_LSB = 0x3; +static const uint8_t LTC294X_REG_HIGH_TRESH_MSB = 0x4; +static const uint8_t LTC294X_REG_HIGH_THRESH_LSB = 0x5; +static const uint8_t LTC294X_REG_LOW_THRESH_MSB = 0x6; +static const uint8_t LTC294X_REG_LOW_THRESH_LSB = 0x7; +static const uint8_t LTC294X_REG_VOLTAGE_MSB = 0x8; +static const uint8_t LTC294X_REG_VOLTAGE_LSB = 0x9; +static const uint8_t LTC294X_REG_VOLTAGE_THRESH_HI = 0xa; +static const uint8_t LTC294X_REG_VOLTAGE_THRESH_LO = 0xb; +static const uint8_t LTC294X_REG_TEMP_MSB = 0xc; +static const uint8_t LTC294X_REG_TEMP_LSB = 0xd; +static const uint8_t LTC294X_REG_TEMP_THRESH_HI = 0xe; +static const uint8_t LTC294X_REG_TEMP_THRESH_LO = 0xf; + +/* status register */ +static const uint8_t LTC294X_CHIP_ID_MASK = BIT(7); +static const uint8_t LTC294X_CHIP_ID_SHIFT = 7; +static const uint8_t LTC294X_ACR_OVF_MASK = BIT(5); +static const uint8_t LTC294X_ACR_OVF_SHIFT = 5; +static const uint8_t LTC294X_TEMP_ALERT_MASK = BIT(4); +static const uint8_t LTC294X_TEMP_ALERT_SHIFT = 4; +static const uint8_t LTC294X_CH_ALERT_HIGH_MASK = BIT(3); +static const uint8_t LTC294X_CH_ALERT_HIGH_SHIFT = 3; +static const uint8_t LTC294X_CH_ALERT_LOW_MASK = BIT(2); +static const uint8_t LTC294X_CH_ALERT_LOW_SHIFT = 2; +static const uint8_t LTC294X_VOLT_ALERT_MASK = BIT(1); +static const uint8_t LTC294X_CH_VOLT_ALERT_SHIFT = 1; +static const uint8_t LTC294X_CH_UVOLT_MASK = BIT(0); +static const uint8_t LTC294X_CH_UVOLT_SHIFT = 0; + +/* control register */ +static const uint8_t LTC294X_ADC_MODE_MASK = BIT(7) | BIT(6); +static const uint8_t LTC294X_ADC_MODE_SHIFT = 6; +static const uint8_t LTC294X_PRESCALER_MASK = BIT(5) | BIT(4) | BIT(3); +static const uint8_t LTC294X_PRESCALER_SHIFT = 3; +static const uint8_t LTC294X_ALCC_CFG_MASK = BIT(2) | BIT(1); +static const uint8_t LTC294X_ALCC_CFG_SHIFT = 1; +static const uint8_t LTC294X_SHUTDOWN_MASK = BIT(0); +static const uint8_t LTC294X_SHUTDOWN_SHIFT = 0; + +/* acrh register */ + +/* acrl register */ + +struct ltc294x_gauge { + pmu_gauge_t pmu_gauge; + volatile uint8_t status; + uint16_t temp_thresh_high; + uint16_t temp_thresh_low; + uint16_t charge_lo_thesh; + bool first_time; +}; + +static struct ltc294x_gauge gauge; + +static io_pin_t FG_ALn_CC = IO_PA(0); + +static uint16_t ltc294x_get_charge(void) +{ + uint16_t val; + + (void) ltc294x_read16(LTC294X_REG_CHARGE_MSB, &val); + + return val; +} + +static void ltc294x_set_charge(uint16_t val) +{ + uint8_t ctrl_val; + + /* datasheet says to shutdown the analog part + * when writing the ACR */ + (void) ltc294x_read(LTC294X_REG_CONTROL, &ctrl_val); + + ctrl_val |= LTC294X_SHUTDOWN_MASK; + + (void) ltc294x_write(LTC294X_REG_CONTROL, ctrl_val); + + /* write the value ... */ + (void) ltc294x_write16(LTC294X_REG_CHARGE_MSB, val); + + ctrl_val &= ~LTC294X_SHUTDOWN_MASK; + + /* turn it on again ...*/ + (void) ltc294x_write(LTC294X_REG_CONTROL, ctrl_val); +} + +static uint16_t ltc294x_get_temp(void) +{ + uint16_t val; + + (void) ltc294x_read16(LTC294X_REG_TEMP_MSB, &val); + + return val; +} + +static uint16_t ltc294x_get_voltage(void) +{ + uint16_t val; + + (void) ltc294x_read16(LTC294X_REG_VOLTAGE_MSB, &val); + + return val; +} + +static int8_t ltc294x_set_charge_thresh(bool high, uint16_t val) +{ + int8_t ret; + + ret = ltc294x_write16( + high ? LTC294X_REG_HIGH_TRESH_MSB : LTC294X_REG_LOW_THRESH_MSB, val); + if (ret) + return ret; + return 0; +} + +static inline void ltc294x_pmu_set_charge_hi_thesh(uint16_t val) +{ + ltc294x_set_charge_thresh(true, val); +} + +static inline void ltc294x_pmu_set_charge_lo_thesh(uint16_t val) +{ + ltc294x_set_charge_thresh(false, val); +} + +uint8_t ltc294x_check_events(void) +{ + uint8_t status; + uint8_t flags = 0; + uint16_t value; + + ltc294x_read(LTC294X_REG_STATUS, &status); + + + if (status && (status != gauge.status)) { + + if (status & LTC294X_CH_ALERT_HIGH_MASK) + flags |= PMU_GAUGE_CHARGE_HI; + else if (status & LTC294X_CH_ALERT_LOW_MASK) + flags |= PMU_GAUGE_CHARGE_LO; + + if (status & LTC294X_VOLT_ALERT_MASK) { + /*flags |= PMU_GAUGE_VOLT_HI; + flags |= PMU_GAUGE_VOLT_LO; */ + /* TODO: Figure out which one */ + } + + if (status & LTC294X_ACR_OVF_MASK) { + value = ltc294x_get_charge(); + if (value <= gauge.charge_lo_thesh) + flags |= PMU_GAUGE_CHARGE_LO; + } + + if (status & LTC294X_TEMP_ALERT_MASK) { + value = ltc294x_get_temp(); + if (value > gauge.temp_thresh_high) + flags |= PMU_GAUGE_TEMP_HI; + else if (value <= gauge.temp_thresh_low) + flags |= PMU_GAUGE_TEMP_LO; + } + gauge.status = status; + } + + return flags; +} + +static const pmu_gauge_ops_t ltc294x_pmu_gauge_ops = { + .check_events = ltc294x_check_events, + .get_temperature = ltc294x_get_temp, + .get_charge = ltc294x_get_charge, + .set_charge = ltc294x_set_charge, + .set_low_threshold = ltc294x_pmu_set_charge_lo_thesh, + .get_voltage = ltc294x_get_voltage, +}; + +int8_t ltc294x_init(ltc294x_model_t model) +{ + uint8_t val; + int8_t ret; + + /* make input, set pullup */ + io_input_pin(FG_ALn_CC); + io_set_pin(FG_ALn_CC); + + gauge.pmu_gauge.ops = <c294x_pmu_gauge_ops; + + ret = ltc294x_read(LTC294X_REG_STATUS, &val); + if (ret) + goto fail_i2c_read; + val &= LTC294X_CHIP_ID_MASK; + val >>= LTC294X_CHIP_ID_SHIFT; + + if (val != model) + goto fail_id; + + /* set ACR to 0, this allows for calibrating by + * completely discharging the battery once */ + ltc294x_set_charge(0x0010); + + /* set low threshold to 10% assuming full is 0xeae4... */ + ltc294x_write16(LTC294X_REG_LOW_THRESH_MSB, 0x1794); + gauge.charge_lo_thesh = 0x1794; + + /* set high threshold for temperature to 85 C */ + ltc294x_write16(LTC294X_REG_TEMP_THRESH_HI, 0x98); + gauge.temp_thresh_high = 0x9800; + + /* set low threshold for temperature to -2 C */ + ltc294x_write16(LTC294X_REG_TEMP_THRESH_LO, 0x74); + gauge.temp_thresh_low = 0x7400; + + ret = ltc294x_read(LTC294X_REG_CONTROL, &val); + if (ret) + goto fail_i2c_read; + + /* enable automatic temp conversion */ + val &= ~LTC294X_ADC_MODE_MASK; + val |= 0x3 << LTC294X_ADC_MODE_SHIFT; + + /* set prescaler to 16 */ + val &= ~LTC294X_PRESCALER_MASK; + val |= 0x4 << LTC294X_PRESCALER_SHIFT; + + /* disable IRQ mode */ + val &= ~LTC294X_ALCC_CFG_MASK; + val |= 0x0 << LTC294X_ALCC_CFG_SHIFT; + + ret = ltc294x_write(LTC294X_REG_CONTROL, val); + + pmu_register_gauge(&gauge.pmu_gauge); + + return 0; + +fail_id: +fail_i2c_read: + return ret; +} diff --git a/firmware/e300/battery/ltc294x.h b/firmware/e300/battery/ltc294x.h new file mode 100644 index 000000000..be35c7ceb --- /dev/null +++ b/firmware/e300/battery/ltc294x.h @@ -0,0 +1,40 @@ +/* USRP E310 Firmware Linear Technology LTC294X driver + * Copyright (C) 2014 Ettus Research + * This file is part of the USRP E310 Firmware + * The USRP E310 Firmware is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 2 of the License, or + * (at your option) any later version. + * The USRP E310 Firmware is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * You should have received a copy of the GNU General Public License + * along with the USRP E310 Firmware. If not, see <http://www.gnu.org/licenses/>. + */ + +/** + * \file ltc294x.h + * \brief Linear Technology LTC294X driver + */ + +#ifndef LTC294X_H +#define LTC294X_H + +#include "pmu.h" + +typedef enum { + LTC294X_MODEL_2941 = 0x1, + LTC294X_MODEL_2942 = 0x0 +} ltc294x_model_t; + +/** + * \brief Initializes the LTC294X chip + * \param model What model we're looking we should probe for + * \return 0 on success, negative error code otherwise + */ +int8_t ltc294x_init(ltc294x_model_t model); + +extern irqreturn_t ltc294x_irq_handler(void); + +#endif /* LTC294X_H */ diff --git a/firmware/e300/battery/ltc3675.c b/firmware/e300/battery/ltc3675.c new file mode 100644 index 000000000..05490a5d6 --- /dev/null +++ b/firmware/e300/battery/ltc3675.c @@ -0,0 +1,382 @@ +/* USRP E310 Firmware Linear Technology LTC3765 driver + * Copyright (C) 2014 Ettus Research + * This file is part of the USRP E310 Firmware + * The USRP E310 Firmware is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 2 of the License, or + * (at your option) any later version. + * The USRP E310 Firmware is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * You should have received a copy of the GNU General Public License + * along with the USRP E310 Firmware. If not, see <http://www.gnu.org/licenses/>. + */ + +#include "fpga.h" +#include "i2c_twi.h" +#include "io.h" +#include "interrupt.h" +#include "ltc3675.h" +#include "mcu_settings.h" +#include "utils.h" +#include "timer.h" + +#include <avr/interrupt.h> +#include <util/delay.h> +#include <util/atomic.h> + +static const uint8_t LTC3675_I2C_ADDR = 0x09; + +#define ltc3675_read(reg, val) \ + (i2c_twi_read(LTC3675_I2C_ADDR, reg, val)) + +#define ltc3675_write(reg, val) \ + (i2c_twi_write(LTC3675_I2C_ADDR, reg, val)) + +/* registers */ +static const uint8_t LTC3675_REG_NONE = 0x00; +static const uint8_t LTC3675_REG_BUCK1 = 0x01; +static const uint8_t LTC3675_REG_BUCK2 = 0x02; +static const uint8_t LTC3675_REG_BUCK3 = 0x03; +static const uint8_t LTC3675_REG_BUCK4 = 0x04; +static const uint8_t LTC3675_REG_BOOST = 0x05; +static const uint8_t LTC3675_REG_BUCK_BOOST = 0x06; +static const uint8_t LTC3675_REG_LED_CONFIG = 0x07; +static const uint8_t LTC3675_REG_LED_DAC = 0x08; +static const uint8_t LTC3675_REG_UVOT = 0x09; +static const uint8_t LTC3675_REG_RSTB = 0x0a; +static const uint8_t LTC3675_REG_IRQB_MASK = 0x0b; +static const uint8_t LTC3675_REG_RT_STATUS = 0x0c; +static const uint8_t LTC3675_REG_LAT_STATUS = 0x0d; +static const uint8_t LTC3675_REG_CLEAR_IRQ = 0x0f; + +static const uint8_t LTC3675_UNDER_VOLTAGE_MASK = BIT(7); +static const uint8_t LTC3675_UNDER_VOLTAGE_SHIFT = 7; +static const uint8_t LTC3675_OVER_TEMPERATURE_MASK = BIT(6); +static const uint8_t LTC3675_OVER_TEMPERATURE_SHIFT = 6; +static const uint8_t LTC3675_BUCK_BOOST_PGOOD_MASK = BIT(5); +static const uint8_t LTC3675_BUCK_BOOST_PGOOD_SHIFT = 5; +static const uint8_t LTC3675_BOOST_PGOOD_MASK = BIT(4); +static const uint8_t LTC3675_BOOST_PGOOD_SHIFT = 4; +static const uint8_t LTC3675_BUCK4_PGOOD_MASK = BIT(3); +static const uint8_t LTC3675_BUCK4_PGOOD_SHIFT = 3; +static const uint8_t LTC3675_BUCK3_PGOOD_MASK = BIT(2); +static const uint8_t LTC3675_BUCK3_PGOOD_SHIFT = 2; +static const uint8_t LTC3675_BUCK2_PGOOD_MASK = BIT(1); +static const uint8_t LTC3675_BUCK2_PGOOD_SHIFT = 1; +static const uint8_t LTC3675_BUCK1_PGOOD_MASK = BIT(0); +static const uint8_t LTC3675_BUCK1_PGOOD_SHIFT = 0; + +static const uint8_t LTC3675_ENABLE_REGISTER_BIT = 0x80; + +struct ltc3675_button { + pmu_button_t pmu_button; + + volatile bool onswitch_press_event; + volatile bool onswitch_release_event; + volatile bool onswitch_last_state; + + volatile bool poweroff_event; + + volatile bool wakeup_event; +}; + +static struct ltc3675_button button; + +/** arbitrary wait to give the external supply can settle */ +static const uint8_t LTC3675_REG_ENABLE_DELAY = 10; + +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); + +static void ltc3675_clear_interrupts(void) +{ + ltc3675_write(LTC3675_REG_CLEAR_IRQ, 0x00); + ltc3675_write(LTC3675_REG_NONE, 0x00); +} + +static int8_t ltc3675_set_regulator_helper(uint8_t reg, bool on) +{ + int8_t ret; + uint8_t val; + ret = ltc3675_read(reg, &val); + if (ret) + goto fail_i2c_read; + if (on) + val |= LTC3675_ENABLE_REGISTER_BIT; + else + val &= ~LTC3675_ENABLE_REGISTER_BIT; + ret = ltc3675_write(reg, val); + if (ret) + goto fail_i2c_write; + + if (on) + _delay_ms(LTC3675_REG_ENABLE_DELAY); + + return 0; + +fail_i2c_write: +fail_i2c_read: + return ret; +} + +static inline int8_t ltc3675_get_realtime_status(uint8_t *val) +{ + int8_t ret; + + ret = ltc3675_read(LTC3675_REG_RT_STATUS, val); + if (ret) + return ret; + return 0; +} + +static bool ltc3675_get_power_good(uint8_t mask) +{ + uint8_t val; + int8_t ret; + + ret = ltc3675_get_realtime_status(&val); + if (ret) + return false; + + return !!(mask & val); +} + +static int8_t ltc3675_set_regulator(pmu_regulator_t *reg, bool on) +{ + int8_t ret; + bool status; + ltc3675_pmu_regulator_t *pmu; + + pmu = container_of(reg, ltc3675_pmu_regulator_t, pmu_reg); + + switch (pmu->ltc3675_reg) { + case LTC3675_REG_1: /* master */ + case LTC3675_REG_2: /* slave */ + ret = ltc3675_set_regulator_helper(LTC3675_REG_BUCK1, on); + if (ret) + return ret; + status = ltc3675_get_power_good(LTC3675_BUCK1_PGOOD_MASK); + return (status == on) ? 0 : -1; + case LTC3675_REG_3: /* master */ + case LTC3675_REG_4: /* slave */ + ret = ltc3675_set_regulator_helper(LTC3675_REG_BUCK3, on); + if (ret) + return ret; + status = ltc3675_get_power_good(LTC3675_BUCK3_PGOOD_MASK); + return (status == on) ? 0 : -1; + case LTC3675_REG_5: + ret = ltc3675_set_regulator_helper(LTC3675_REG_BOOST, on); + if (ret) + return ret; + status = ltc3675_get_power_good(LTC3675_BOOST_PGOOD_MASK); + return (status == on) ? 0 : -1; + case LTC3675_REG_6: /* single */ + ret = ltc3675_set_regulator_helper(LTC3675_REG_BUCK_BOOST, on); + if (ret) + return ret; + status = ltc3675_get_power_good(LTC3675_BUCK_BOOST_PGOOD_MASK); + return (status == on) ? 0 : -1; + default: + return -1; + } + + return 0; +} + +static int8_t ltc3675_set_voltage(pmu_regulator_t *reg, uint16_t v) +{ + uint32_t r_fb, r; + uint16_t vmax, r_dac; + uint8_t addr, val; + int8_t ret; + ltc3675_pmu_regulator_t *pmu; + + pmu = container_of(reg, ltc3675_pmu_regulator_t, pmu_reg); + + switch (pmu->ltc3675_reg) { + case LTC3675_REG_1: /* 1A Buck */ + case LTC3675_REG_2: /* 1A Buck */ + vmax = 1500; + addr = LTC3675_REG_BUCK1; + break; + case LTC3675_REG_3: /* 500mA Buck */ + case LTC3675_REG_4: /* 500mA Buck */ + vmax = 1800; + addr = LTC3675_REG_BUCK3; + break; + case LTC3675_REG_5: /* 1A Boost */ + vmax = 5000; + addr = LTC3675_REG_BOOST; + break; + case LTC3675_REG_6: /* 1 A Buck-Boost */ + vmax = 3300; + addr = LTC3675_REG_BUCK_BOOST; + break; + default: + return -1; /* TODO: Should return useful error code */ + } + + if (v > vmax) + return -1; /* TODO: Should return useful error code. */ + + r_fb = ((uint32_t) vmax * 1000) / (uint32_t) 800; /* 800mV full-scale feedback voltage */ + r = ((uint32_t) v * 1000) / r_fb ; + + if (r < 450) + return -1; + + r_dac = (16 * ((uint16_t) r - 450)) / (800 - 450); + + ret = ltc3675_read(addr, &val); + if (ret) + return ret; + + val = (val & 0xf0) | ((uint8_t) r_dac); + ret = ltc3675_write(addr, val); + if (ret) + return ret; + + return 0; +} + +static uint8_t ltc3675_button_check_events(pmu_button_t *pmu_button) +{ + uint8_t flags; + struct ltc3675_button *ltc3675_button; + flags = 0x00; + ltc3675_button = container_of( + pmu_button, struct ltc3675_button, pmu_button); + + ATOMIC_BLOCK(ATOMIC_RESTORESTATE) + { + if (ltc3675_button->onswitch_press_event) { + ltc3675_button->onswitch_press_event = false; + flags |= PMU_BUTTON_EVENT_MASK_PRESS; + } + } + + ATOMIC_BLOCK(ATOMIC_RESTORESTATE) + { + if (ltc3675_button->onswitch_release_event) { + ltc3675_button->onswitch_release_event = false; + flags |= PMU_BUTTON_EVENT_MASK_RELEASE; + } + } + + ATOMIC_BLOCK(ATOMIC_RESTORESTATE) + { + if (ltc3675_button->wakeup_event) { + ltc3675_button->wakeup_event = false; + flags |= PMU_BUTTON_EVENT_MASK_WAKEUP; + } + } + + ATOMIC_BLOCK(ATOMIC_RESTORESTATE) + { + if (ltc3675_button->poweroff_event) { + ltc3675_button->poweroff_event = false; + flags |= PMU_BUTTON_EVENT_MASK_POWERDOWN; + } + } + return flags; +} + +static const pmu_button_ops_t ltc3675_pmu_button_ops = { + .check_events = ltc3675_button_check_events, +}; + + +int8_t ltc3675_init(void) +{ + uint8_t id; + int8_t ret; + + ret = ltc3675_read(LTC3675_REG_LED_CONFIG, &id); + if (ret) + return ret; + + button.pmu_button.ops = <c3675_pmu_button_ops; + button.onswitch_last_state = io_test_pin(ONSWITCH_DB); + + /* setup the input pins with pull-up for open drain */ + io_input_pin(PWR_IRQ); + io_set_pin(PWR_IRQ); + io_input_pin(WAKEUP); + io_set_pin(WAKEUP); + io_input_pin(ONSWITCH_DB); + io_set_pin(ONSWITCH_DB); + io_input_pin(PWR_RESET); + io_set_pin(PWR_RESET); + + /* clear the old interrupts */ + ltc3675_clear_interrupts(); + + /* setup interrupt masks on chip to be notified of any faults */ + ret = ltc3675_write(LTC3675_REG_IRQB_MASK, 0xff); + if (ret) + goto fail_i2c_write_mask; + + /* program warning @ 3.4V */ + ret = ltc3675_write(LTC3675_REG_UVOT, 0x70); + if (ret) + goto fail_i2c_write_uvot; + + pmu_register_button(&button.pmu_button); + + return 0; + +fail_i2c_write_uvot: +fail_i2c_write_mask: + return ret; +} + +int8_t ltc3675_check_reg_events(pmu_regulator_t *reg) +{ + return 0; +} + +const pmu_regulator_ops_t ltc3675_ops = { + .set_voltage = ltc3675_set_voltage, + .set_regulator = ltc3675_set_regulator, + .check_events = ltc3675_check_reg_events +}; + +/* PD(3) ONSWITCH_DB (PB_STAT), any change */ +irqreturn_t ltc3675_button_change_irq_handler(void) +{ + bool pin_state; + + pin_state = io_test_pin(ONSWITCH_DB); + + /* the pushbutton is active low, therefore backwards logic */ + if (pin_state && !button.onswitch_last_state) { + button.onswitch_release_event = true; + timer1_stop(); + } else if (!pin_state && button.onswitch_last_state) { + button.onswitch_press_event = true; + timer1_start(); + } + button.onswitch_last_state = pin_state; + + return IRQ_HANDLED; +} + +irqreturn_t ltc3675_button_wakeup_irq_handler(void) +{ + button.wakeup_event = true; + + return IRQ_HANDLED; +} + +irqreturn_t ltc3675_button_timer_irq_handler(void) +{ + /* if we got here, the timer overflowed, + * meaning the user pressed the button long enough */ + button.poweroff_event = true; + + return IRQ_HANDLED; +} diff --git a/firmware/e300/battery/ltc3675.h b/firmware/e300/battery/ltc3675.h new file mode 100644 index 000000000..f06fc4fc2 --- /dev/null +++ b/firmware/e300/battery/ltc3675.h @@ -0,0 +1,67 @@ +/* USRP E310 Firmware Linear Technology LTC3765 driver + * Copyright (C) 2014 Ettus Research + * This file is part of the USRP E310 Firmware + * The USRP E310 Firmware is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 2 of the License, or + * (at your option) any later version. + * The USRP E310 Firmware is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * You should have received a copy of the GNU General Public License + * along with the USRP E310 Firmware. If not, see <http://www.gnu.org/licenses/>. + */ + +/** + * \file ltc3675.h + * \brief Linear Technology LTC3675 driver + */ + +#ifndef LTC3675_H +#define LTC3675_H + +#include "pmu.h" + +typedef enum ltc3675_regulator { + /** 1A Buck */ + LTC3675_REG_1, + /** 1A Buck */ + LTC3675_REG_2, + /** 500mA Buck */ + LTC3675_REG_3, + /** 500mA Buck */ + LTC3675_REG_4, + /** 1A Boost */ + LTC3675_REG_5, + /** 1A Buck-Boost */ + LTC3675_REG_6, +} ltc3675_regulator_t; + +typedef struct ltc3675_pmu_regulator { + pmu_regulator_t pmu_reg; + ltc3675_regulator_t ltc3675_reg; +} ltc3675_pmu_regulator_t; + +extern const pmu_regulator_ops_t ltc3675_ops; + +/** + * \brief Initializes the LTC3675 chip + * + * This function will setup the internal pull-up resistors for the open drain + * input pins, clear old interrupts, unmask all warnings and set the warning + * level to 3.4V + */ +int8_t ltc3675_init(void); + +/** + * \brief Event handler that gets called periodically + * \return returns 0 on success, negative error code in case of fault + */ +int8_t ltc3675_handle_events(void); + +extern irqreturn_t ltc3675_button_wakeup_irq_handler(void); +extern irqreturn_t ltc3675_button_change_irq_handler(void); +extern irqreturn_t ltc3675_button_timer_irq_handler(void); + +#endif /* LTC3675_H */ diff --git a/firmware/e300/battery/main.c b/firmware/e300/battery/main.c new file mode 100644 index 000000000..eec9e8293 --- /dev/null +++ b/firmware/e300/battery/main.c @@ -0,0 +1,65 @@ +/* USRP E310 Firmware + * Copyright (C) 2014 Ettus Research + * This file is part of the USRP E310 Firmware + * The USRP E310 Firmware is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 2 of the License, or + * (at your option) any later version. + * The USRP E310 Firmware is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * You should have received a copy of the GNU General Public License + * along with the USRP E310 Firmware. If not, see <http://www.gnu.org/licenses/>. + */ + +#include <avr/io.h> +#include <errno.h> +#include <avr/interrupt.h> +#include <avr/sleep.h> + +#include "i2c_twi.h" +#include "spi.h" +#include "pmu.h" +#include "interrupt.h" +#include "io.h" +#include "fpga.h" +#include "eeprom.h" +#include "utils.h" + +/* setup the fuses for compilation with avr-gcc + * - use the internal 8 MHz oscillator + * - slowly rising power (startup time) + * - save the eeprom between flashes, leave SPI enabled for flashing + */ +FUSES = { + .low = (FUSE_CKSEL0 & FUSE_SUT0), + .high = (FUSE_EESAVE & FUSE_SPIEN), +}; + + +int main(void) +{ + /* if a reset was caused by watchdog, clear flag, enable wd change bit, disable */ + if (MCUSR & BIT(WDRF)) { + MCUSR &= ~BIT(WDRF); + WDTCSR |= BIT(WDCE) | BIT(WDE); + WDTCSR = 0x00; + } + + i2c_twi_init(I2C_SPEED_100K); + spi_init(SPI_TYPE_MASTER, SPI_MSB_FIRST, SPI_MODE_0, SPI_SPEED_2M); + + pmu_init(); + + if (eeprom_get_autoboot()) + pmu_power_on(); + + sei(); + + while (1) { + pmu_handle_events(); + } + + return 0; +} diff --git a/firmware/e300/battery/mcu_settings.h b/firmware/e300/battery/mcu_settings.h new file mode 100644 index 000000000..175cb8f44 --- /dev/null +++ b/firmware/e300/battery/mcu_settings.h @@ -0,0 +1,28 @@ +/* USRP E310 Firmware MCU specific settings + * Copyright (C) 2014 Ettus Research + * This file is part of the USRP E310 Firmware + * The USRP E310 Firmware is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 2 of the License, or + * (at your option) any later version. + * The USRP E310 Firmware is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * You should have received a copy of the GNU General Public License + * along with the USRP E310 Firmware. If not, see <http://www.gnu.org/licenses/>. + */ + +/** + * \file mcu_settings.h + * \brief MCU specific settings + */ +#ifndef MCU_SETTINGS_H +#define MCU_SETTINGS_H + +#define F_CPU 8000000UL + +#define VERSION_MAJ 2 +#define VERSION_MIN 0 + +#endif /* MCU_SETTINGS_H */ diff --git a/firmware/e300/battery/pmu.c b/firmware/e300/battery/pmu.c new file mode 100644 index 000000000..bd337783f --- /dev/null +++ b/firmware/e300/battery/pmu.c @@ -0,0 +1,686 @@ +/* USRP E310 Firmware PMU + * Copyright (C) 2014 Ettus Research + * This file is part of the USRP E310 Firmware + * The USRP E310 Firmware is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 2 of the License, or + * (at your option) any later version. + * The USRP E310 Firmware is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * You should have received a copy of the GNU General Public License + * along with the USRP E310 Firmware. If not, see <http://www.gnu.org/licenses/>. + */ + +#include "adc.h" +#include "bq2419x.h" +#include "eeprom.h" +#include "fpga.h" +#include "mcu_settings.h" +#include "io.h" +#include "led.h" +#include "ltc3675.h" +#include "ltc294x.h" +#include "tps54478.h" +#include "timer.h" +#include "utils.h" + +#include <stdlib.h> + +#include <avr/interrupt.h> +#include <avr/wdt.h> +#include <util/delay.h> +#include <util/atomic.h> + +void pmu_power_on(void); +void pmu_power_down(void); + +/* if we sense less than 2000 mV we assume battery is not there */ +static const uint16_t PMU_BAT_MIN_VOLTAGE = 2000; + +/* wait 10 ms, such random, so magic, wow */ +static const uint8_t PMU_FPGA_RESET_DELAY = 10; + +/* more magic wait constants */ +static const uint8_t PMU_USB_CLK_WAIT = 200; +static const uint8_t PMU_FTDI_WAIT = 100; + +static io_pin_t VBAT = IO_PC(0); +static io_pin_t POWER_LED = IO_PC(7); +static io_pin_t CHARGE = IO_PD(1); +static io_pin_t USB_RESETn = IO_PA(2); +static io_pin_t FTDI_RESETn = IO_PB(6); +static io_pin_t FTDI_CBUS3 = IO_PB(7); +static io_pin_t USB_CLK_EN = IO_PA(1); +static io_pin_t AVR_RESET = IO_PC(6); +static io_pin_t AVR_IRQ = IO_PD(5); +static io_pin_t PS_POR = IO_PD(6); +static io_pin_t PS_SRST = IO_PD(7); +static io_pin_t OVERTEMP = IO_PC(2); + +static uint16_t last_full_charge; +static uint16_t charge_on_last_unplug; +static bool battery_present_last; + +static const uint8_t PMU_BLINK_ERROR_DELAY_MS = 250; +static const uint8_t PMU_BLINK_ERROR_TICKS_PER_BLINK = 10; + +typedef enum pmu_state { + OFF, + BOOT, + SHUTDOWN, + ON +} pmu_state_t; + +static pmu_state_t state; +static volatile bool pmu_fpga_event; + +typedef enum pmu_error { + PMU_ERROR_NONE = 0x00, + PMU_ERROR_LOW_VOLTAGE = 0x01, + PMU_ERROR_REG_LOW_VOLTAGE = 0x02, + PMU_ERROR_FPGA_POWER = 0x03, + PMU_ERROR_DRAM_POWER = 0x04, + PMU_ERROR_1_8V = 0x05, + PMU_ERROR_3_3V = 0x06, + PMU_ERROR_TX_POWER = 0x07, + PMU_ERROR_CHARGER_TEMP = 0x08, + PMU_ERROR_CHARGER_ERROR = 0x09, + PMU_ERROR_BATTERY_LOW = 0x0a, + PMU_ERROR_GAUGE_TEMP = 0x0b, + PMU_ERROR_GLOBAL_TEMP = 0x0c, +} pmu_error_t; + +static volatile pmu_error_t pmu_error; + +/* this cannot be static const because + * 'All the expressions in an initializer for an object + * that has static storage duration shall be constant expressions + * or string literals.' [section 6.7.8/4, C standard */ +#ifdef DDR3L +#define DRAM_VOLTAGE 1350 +#else +#define DRAM_VOLTAGE 0 +#endif /* DDR3L */ + +static ltc3675_pmu_regulator_t PS_VDRAM = { + .pmu_reg = { + .ops = <c3675_ops, + .powered = false, + .voltage = DRAM_VOLTAGE /* DRAM_VOLTAGE */, + .error_code = PMU_ERROR_DRAM_POWER, + }, + .ltc3675_reg = LTC3675_REG_1, +}; + +static ltc3675_pmu_regulator_t PS_PERIPHERALS_1_8 = { + .pmu_reg = { + .ops = <c3675_ops, + .powered = false, + .voltage = 0 /*1800 hardware default? */, + .error_code = PMU_ERROR_1_8V, + }, + .ltc3675_reg = LTC3675_REG_3, +}; + +static ltc3675_pmu_regulator_t PS_PERIPHERALS_3_3 = { + .pmu_reg = { + .ops = <c3675_ops, + .powered = false, + .voltage = 0 /*3300 hardware default */, + .error_code = PMU_ERROR_3_3V, + }, + .ltc3675_reg = LTC3675_REG_6, +}; + +static ltc3675_pmu_regulator_t PS_TX = { + .pmu_reg = { + .ops = <c3675_ops, + .powered = false, + .voltage = 0 /*5000 hardware default? */, + .error_code = PMU_ERROR_TX_POWER, + }, + .ltc3675_reg = LTC3675_REG_5, +}; + +static tps54478_pmu_regulator_t PS_FPGA = { + .pmu_reg = { + .ops = &tps54478_ops, + .powered = false, + .voltage = 1000, + .error_code = PMU_ERROR_FPGA_POWER, + }, +}; + +static pmu_regulator_t *boot_order[] = { + &PS_FPGA.pmu_reg, + &PS_VDRAM.pmu_reg, + &PS_PERIPHERALS_1_8.pmu_reg, + &PS_TX.pmu_reg, + &PS_PERIPHERALS_3_3.pmu_reg, +}; + +static pmu_button_t *button; +void pmu_register_button(pmu_button_t *pmu_button) +{ + button = pmu_button; +} + +static pmu_charger_t *charger; +void pmu_register_charger(pmu_charger_t *pmu_charger) +{ + charger = pmu_charger; +} + +static pmu_gauge_t *gauge; +void pmu_register_gauge(pmu_gauge_t *pmu_gauge) +{ + gauge = pmu_gauge; +} + +/** + * \brief Reads the battery voltage from ADC0 + * + * Vout = (375k / (274k + 357k)) * Vbat + * Vbat = (Vout * (274k + 357k)) / 357k + * + * ADC = (Vin * 1024) / Vref + * Vin = (ADC * Vref) / 1024 + * Vref = 3.3V + * Vbat(mV) = 100 * (((ADC * 3.3) / 1024) * (274k + 357k)) / 357k + * Vbat(mV) ~= ADC * 5.7 + */ +static uint16_t pmu_battery_voltage(void) +{ + uint16_t tmp; + + tmp = adc_single_shot(); + tmp *= 5.6961f; + return (uint16_t) tmp; +} + +static inline bool pmu_battery_present(void) +{ + return (pmu_battery_voltage() > PMU_BAT_MIN_VOLTAGE); +} + +static void pmu_reset_fpga(bool delay) +{ + io_clear_pin(PS_POR); + io_clear_pin(PS_SRST); + + if (delay) + _delay_ms(PMU_FPGA_RESET_DELAY); + + io_set_pin(PS_POR); + io_set_pin(PS_SRST); +} + +int8_t pmu_init(void) +{ + int8_t ret; + bool battery_present; + + state = OFF; + + /* make the LED outputs */ + io_output_pin(CHARGE); + io_output_pin(POWER_LED); + + /* initialize the ADC, so we can sense the battery */ + adc_init(); + + /* initialize TPS54478 for core power */ + tps54478_init(true); + + /* wiggle USB and FTDI pins */ + io_input_pin(USB_RESETn); + io_output_pin(FTDI_RESETn); + io_output_pin(USB_CLK_EN); + io_input_pin(FTDI_CBUS3); + + /* make OVERTEMP input pin */ + io_input_pin(OVERTEMP); + + /* initialize the charger */ + ret = bq2419x_init(); + if (ret) + goto fail_bq2419x; + + /* wait a sec */ + _delay_ms(1000); + + /* wdt setup */ + cli(); + WDTCSR |= BIT(WDCE) | BIT(WDE); + WDTCSR = BIT(WDIE); + sei(); + + /* see if we got a battery */ + battery_present = pmu_battery_present(); + battery_present_last = battery_present; + + if (battery_present) { + last_full_charge = eeprom_get_last_full(); + ret = ltc294x_init(LTC294X_MODEL_2942); + } + if (ret) + return ret; + + ret = ltc3675_init(); + if (ret) + goto fail_ltc3675; + + + /* need to hold them low until power is stable */ + io_output_pin(PS_POR); + io_output_pin(PS_SRST); + io_clear_pin(PS_POR); + io_clear_pin(PS_SRST); + + /* TODO: Not sure if needed */ + io_input_pin(AVR_RESET); + + /* TODO: This will probably need to change */ + io_input_pin(AVR_IRQ); + io_set_pin(AVR_IRQ); // enable pull-up ? + + /* configure and enable interrupts */ + interrupt_init(); + + /* initialize the timers */ + timer0_init(); + timer1_init(); + + state = OFF; + + return 0; + +fail_ltc3675: +fail_bq2419x: + return -1; +} + +#define is_off (OFF == state) +#define is_on (ON == state) +#define is_booting (BOOT == state) + +static inline int8_t pmu_set_regulator(pmu_regulator_t *reg, bool on) +{ + return reg->ops->set_regulator(reg, on); +} + +void pmu_power_on(void) +{ + uint8_t i; + int8_t ret; + pmu_regulator_t *reg; + + /* if somehow this gets called twice, bail early on */ + if (is_booting) + return; + else if (is_on) + return; + else + state = BOOT; + + /* reset the fpga */ + pmu_reset_fpga(true); + fpga_init(); + + for (i = 0; i < ARRAY_SIZE(boot_order); i++) { + reg = boot_order[i]; + /* if regulator set a on/off function, call it */ + if (reg->ops->set_regulator) { + ret = pmu_set_regulator(reg, true); + if (ret) { + pmu_error = reg->error_code; + goto fail_regulators; + } + } + + /* if regulator set a set_voltage function, call it */ + if (reg->ops->set_voltage && reg->voltage) { + ret = reg->ops->set_voltage(reg, reg->voltage); + if (ret) { + pmu_error = reg->error_code; + goto fail_regulators; + } + } + + /* if we got here, this means all is well */ + reg->powered = true; + } + + /* enable the usb clock */ + io_set_pin(USB_CLK_EN); + _delay_ms(PMU_USB_CLK_WAIT); + io_set_pin(FTDI_RESETn); + _delay_ms(PMU_FTDI_WAIT); + + /* power for the fpga should be up now, let it run */ + pmu_reset_fpga(false); + + state = ON; + + return; + +fail_regulators: + /* TODO: Turn of stuff again in reverse order */ + return; +} + +static inline enum pmu_status pmu_battery_get_status(pmu_charger_t *pmu_charger) +{ + return pmu_charger->ops->get_battery_status + ? pmu_charger->ops->get_battery_status(pmu_charger) : 0; +} + +void pmu_power_down(void) +{ + int8_t i; + int8_t ret; + pmu_regulator_t *reg; + + state = SHUTDOWN; + + /* keep zynq in reset, + * TODO: do we need to also clear PS_POR? */ + io_clear_pin(PS_SRST); + + /* turn off usb clock */ + io_clear_pin(USB_CLK_EN); + + for (i = ARRAY_SIZE(boot_order) - 1; i >= 0; i--) { + reg = boot_order[i]; + if (reg->ops->set_regulator) { + ret = pmu_set_regulator(reg, false); + if (ret) + goto fail_regulators; + } + + /* if we got here, this means regulator is off */ + reg->powered = false; + } + + state = OFF; + + _delay_ms(1000); + + return; + +fail_regulators: + /* for now set solid red */ + pmu_error = reg->error_code; +} + +static inline int8_t pmu_charger_check_events(pmu_charger_t *ch) +{ + return ch->ops->check_events + ? ch->ops->check_events(ch) : 0; +} + +static inline int8_t pmu_regulator_check_events(pmu_regulator_t *reg) +{ + return reg->ops->check_events + ? reg->ops->check_events(reg) : 0; +} + +static inline uint8_t pmu_button_check_events(pmu_button_t *pmu_button) +{ + return pmu_button->ops->check_events + ? pmu_button->ops->check_events(pmu_button) : 0; +} + +static inline uint8_t pmu_charger_get_charge_type(pmu_charger_t *pmu_charger) +{ + return pmu_charger->ops->get_charge_type + ? pmu_charger->ops->get_charge_type(pmu_charger) : 0; +} + +static inline uint8_t pmu_charger_get_health(pmu_charger_t *pmu_charger) +{ + return pmu_charger->ops->get_charger_health + ? pmu_charger->ops->get_charger_health(pmu_charger) : 0; +} + +static inline uint8_t pmu_battery_get_health(pmu_charger_t *pmu_charger) +{ + return charger->ops->get_battery_health(pmu_charger); +} + +static inline uint8_t pmu_battery_get_temp_alert(pmu_charger_t *pmu_charger) +{ + return pmu_charger->ops->get_temp_alert + ? pmu_charger->ops->get_temp_alert(pmu_charger) : 0; +} + +static inline bool pmu_charger_get_online(pmu_charger_t *pmu_charger) +{ + return pmu_charger->ops->get_charger_online + ? pmu_charger->ops->get_charger_online(pmu_charger) : 0; +} + +static inline bool pmu_battery_get_online(pmu_charger_t *pmu_charger) +{ + return pmu_charger->ops->get_battery_online + ? pmu_charger->ops->get_battery_online(pmu_charger) : 0; +} + +static inline uint8_t pmu_gauge_check_events(void) +{ + return gauge->ops->check_events + ? gauge->ops->check_events() : 0; +} + +static inline uint16_t pmu_gauge_get_temperature(void) +{ + return gauge->ops->get_temperature + ? gauge->ops->get_temperature() : 0; +} + +static inline uint16_t pmu_gauge_get_charge(void) +{ + return gauge->ops->get_charge(); +} + +static inline void pmu_gauge_set_charge(uint16_t val) +{ + gauge->ops->set_charge(val); +} + +static inline uint16_t pmu_gauge_get_voltage(void) +{ + return gauge->ops->get_voltage(); +} + +static inline void pmu_gauge_set_low_threshold(uint16_t val) +{ + if (gauge->ops->set_low_threshold) + gauge->ops->set_low_threshold(val); +} + +static inline bool pmu_is_charging(void) +{ + if (charger) + return PMU_STATUS_CHARGING == pmu_battery_get_status(charger); + + return false; +} + +static inline bool pmu_is_full(void) +{ + if (charger) + return PMU_STATUS_FULL == pmu_battery_get_status(charger); + + return false; +} + +void pmu_handle_events(void) +{ + uint8_t flags; + uint16_t val; + bool battery_present = pmu_battery_present(); + bool is_charging = false; + bool is_full = false; + bool overtemp = io_test_pin(OVERTEMP); + + /* check if someone plugged the battery late, + * if so init gauge */ + if (battery_present && !battery_present_last) { + ltc294x_init(LTC294X_MODEL_2942); + pmu_gauge_set_charge(charge_on_last_unplug); + } else if (!battery_present && battery_present_last) { + gauge = NULL; + charge_on_last_unplug = pmu_gauge_get_charge(); + } + battery_present_last = battery_present; + + if (overtemp) { + fpga_set_gauge_status(BIT(6)); + pmu_error = PMU_ERROR_GLOBAL_TEMP; + } + + if (battery_present) { + is_charging = pmu_is_charging(); + is_full = pmu_is_full(); + } + + /* resolve errors if we can */ + if (pmu_error != PMU_ERROR_NONE) { + switch (pmu_error) { + case PMU_ERROR_BATTERY_LOW: + if (is_off || is_charging) + pmu_error = PMU_ERROR_NONE; + break; + case PMU_ERROR_CHARGER_TEMP: + if (!is_charging) + pmu_error = PMU_ERROR_NONE; + break; + case PMU_ERROR_GLOBAL_TEMP: + if (!overtemp) + pmu_error = PMU_ERROR_NONE; + break; + default: + break; + } + } + + (void) pmu_regulator_check_events(&PS_FPGA.pmu_reg); + + (void) pmu_regulator_check_events(&PS_VDRAM.pmu_reg); + + flags = pmu_button_check_events(button); + if (is_off && (flags & PMU_BUTTON_EVENT_MASK_WAKEUP)) + pmu_power_on(); + + else if (is_on && (flags & PMU_BUTTON_EVENT_MASK_POWERDOWN)) + pmu_power_down(); + + /* if no battery present, no point ... */ + if (battery_present) { + flags = pmu_charger_check_events(charger); + + if (flags != PMU_CHARGER_EVENT_NONE) { + if ((flags & PMU_CHARGER_EVENT_FAULT_CHANGE) + || (flags & PMU_CHARGER_EVENT_STATUS_CHANGE)) { + uint8_t health = pmu_battery_get_health(charger); + switch (health) { + case PMU_HEALTH_OVERHEAT: + pmu_power_down(); + pmu_error = PMU_ERROR_CHARGER_TEMP; + break; + default: + break; + } + } + + if ((flags & PMU_CHARGER_EVENT_CHARGE_DONE)) { + last_full_charge = pmu_gauge_get_charge(); + pmu_gauge_set_low_threshold(last_full_charge / 10); + eeprom_set_last_full_charge(last_full_charge); + } + } + + flags = pmu_gauge_check_events(); + if (flags != PMU_GAUGE_EVENT_NONE) { + if (flags & PMU_GAUGE_CHARGE_LO) { + if (!is_charging) { + fpga_set_gauge_status(BIT(7)); + pmu_error = PMU_ERROR_BATTERY_LOW; + } + } + + if (flags & PMU_GAUGE_TEMP_HI) { + fpga_set_gauge_status(BIT(6)); + pmu_error = PMU_ERROR_GAUGE_TEMP; + } + + if (flags & PMU_GAUGE_TEMP_LO) { + fpga_set_gauge_status(BIT(6)); + pmu_error = PMU_ERROR_GAUGE_TEMP; + } + } + } + + /* blink error codes ... */ + switch (pmu_error) { + case PMU_ERROR_NONE: + if (is_off) { + if (is_charging) + led_set_blink(LED_BLINK_GREEN_SLOW); + else + led_set_solid(LED_OFF); + } else if (is_on) { + if (is_charging) + led_set_blink(LED_BLINK_GREEN_FAST); + else if (is_full || !battery_present) + led_set_solid(LED_GREEN); + else if (battery_present) + led_set_solid(LED_ORANGE); + else + led_set_solid(LED_GREEN); + } + break; + case PMU_ERROR_BATTERY_LOW: + if (!is_charging && is_on) + led_set_blink(LED_BLINK_ORANGE); + break; + default: + led_set_blink_seq(pmu_error, LED_BLINK_RED_FAST); + break; + }; + + fpga_set_charger_health(pmu_charger_get_health(charger)); + fpga_set_charger_online(pmu_charger_get_online(charger)); + if (battery_present) { + fpga_set_charger_charge_type(pmu_charger_get_charge_type(charger)); + fpga_set_battery_voltage(pmu_battery_voltage()); + fpga_set_battery_temp_alert(pmu_battery_get_temp_alert(charger)); + fpga_set_battery_status(pmu_battery_get_status(charger)); + fpga_set_battery_health(pmu_battery_get_health(charger)); + fpga_set_battery_online(pmu_battery_get_online(charger)); + fpga_set_gauge_charge(pmu_gauge_get_charge()); + fpga_set_gauge_charge_last_full(last_full_charge); + fpga_set_gauge_temp(pmu_gauge_get_temperature()); + fpga_set_gauge_voltage(pmu_gauge_get_voltage()); + } + if (state != OFF) { + fpga_sync(); + if (fpga_get_write_charge()) { + val = fpga_get_gauge_charge(); + pmu_gauge_set_charge(val); + if (pmu_error == PMU_ERROR_BATTERY_LOW) + pmu_error = PMU_ERROR_NONE; + } + + if (fpga_get_shutdown()) + pmu_power_down(); + + if (fpga_get_write_settings()) { + eeprom_set_autoboot(fpga_get_settings() & BIT(0)); + pmu_set_regulator(&PS_TX.pmu_reg, !!(fpga_get_settings() & BIT(1))); + } + } +} diff --git a/firmware/e300/battery/pmu.h b/firmware/e300/battery/pmu.h new file mode 100644 index 000000000..5efaab8b1 --- /dev/null +++ b/firmware/e300/battery/pmu.h @@ -0,0 +1,177 @@ +/* USRP E310 Firmware PMU + * Copyright (C) 2014 Ettus Research + * This file is part of the USRP E310 Firmware + * The USRP E310 Firmware is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 2 of the License, or + * (at your option) any later version. + * The USRP E310 Firmware is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * You should have received a copy of the GNU General Public License + * along with the USRP E310 Firmware. If not, see <http://www.gnu.org/licenses/>. + */ + +/** + * \file pmu.h + * \brief Power Management Unit (PMU) functionality + */ +#ifndef PMU_H +#define PMU_H + +#include <stdbool.h> +#include "interrupt.h" +#include "utils.h" + +/** + * \brief Initialize the Power Management Unit + * \return 0 on success, negative error code on error + */ +int8_t pmu_init(void); + +typedef struct pmu_regulator pmu_regulator_t; + +typedef struct pmu_regulator_ops { + int8_t (*set_voltage)(pmu_regulator_t *, uint16_t); + int8_t (*set_regulator)(pmu_regulator_t *, bool); + int8_t (*check_events)(pmu_regulator_t *); +} pmu_regulator_ops_t; + +struct pmu_regulator { + const pmu_regulator_ops_t *ops; + const uint16_t voltage; + bool powered; + uint8_t error_code; +}; + +/** + * \brief Event loop that handles all the various events + */ +void pmu_handle_events(void); + +extern irqreturn_t pmu_fpga_irq_handler(void); +extern irqreturn_t pmu_led_timer_comp_a_irq_handler(void); +extern irqreturn_t pmu_led_timer_comp_b_irq_handler(void); +extern irqreturn_t pmu_wdt_handler(void); + +/** + * \brief Turn on the regulators and powerup ARM and FPGA + */ +void pmu_power_on(void); + +enum pmu_health { + PMU_HEALTH_GOOD, + PMU_HEALTH_UNSPEC_FAIL, + PMU_HEALTH_OVERVOLTAGE, + PMU_HEALTH_OVERHEAT, + PMU_HEALTH_COLD, + PMU_HEALTH_SAFETY_TIMER_EXPIRE, + PMU_HEALTH_UNKNOWN +}; + +enum pmu_charge_type { + PMU_CHARGE_TYPE_NONE, + PMU_CHARGE_TYPE_TRICKLE, + PMU_CHARGE_TYPE_FAST, +}; + +enum pmu_status { + PMU_STATUS_NOT_CHARGING, + PMU_STATUS_CHARGING, + PMU_STATUS_FULL, + PMU_STATUS_DISCHARGING +}; + +typedef struct pmu_charger pmu_charger_t; + +enum pmu_charger_event_mask { + PMU_CHARGER_EVENT_NONE = 0x00, + PMU_CHARGER_EVENT_STATUS_CHANGE = BIT(0), + PMU_CHARGER_EVENT_FAULT_CHANGE = BIT(1), + PMU_CHARGER_EVENT_CHARGE_DONE = BIT(2) +}; + +typedef struct pmu_charger_ops { + int8_t (*set_charger_voltage)(pmu_charger_t *, uint16_t); + int8_t (*set_charger_current)(pmu_charger_t *, uint16_t); + + uint8_t (*get_temp_alert)(pmu_charger_t *); + int8_t (*set_temp_alert)(pmu_charger_t *, uint8_t); + + enum pmu_charge_type (*get_charge_type)(pmu_charger_t *); + int8_t (*set_charge_type)(pmu_charger_t *, enum pmu_charge_type); + enum pmu_health (*get_charger_health)(pmu_charger_t *); + bool (*get_charger_online)(pmu_charger_t *); + + enum pmu_health (*get_battery_health)(pmu_charger_t *); + enum pmu_status (*get_battery_status)(pmu_charger_t *); + bool (*get_battery_online)(pmu_charger_t *); + + uint8_t (*check_events)(pmu_charger_t *); +} pmu_charger_ops_t; + +struct pmu_charger { + const pmu_charger_ops_t *ops; +}; + +/** + * \brief Set the PMU's charger to the given one + * \param[in] pmu_charger Pointer to the implementation's pmu_charger + */ +void pmu_register_charger(pmu_charger_t *pmu_charger); + +typedef struct pmu_button pmu_button_t; + +enum pmu_button_event_mask { + PMU_BUTTON_EVENT_MASK_PRESS = 0x01, + PMU_BUTTON_EVENT_MASK_RELEASE = 0x02, + PMU_BUTTON_EVENT_MASK_POWERDOWN = 0x04, + PMU_BUTTON_EVENT_MASK_WAKEUP = 0x08, +}; + +typedef struct pmu_button_ops { + uint8_t (*check_events)(pmu_button_t *); +} pmu_button_ops_t; + +struct pmu_button { + const pmu_button_ops_t *ops; +}; + +/** + * \brief Set the PMU's button to the given one + * \param[in] pmu_button Pointer to the implementation's pmu_button + */ +void pmu_register_button(pmu_button_t *pmu_button); + +typedef struct pmu_gauge pmu_gauge_t; + +enum pmu_gauge_event_mask { + PMU_GAUGE_EVENT_NONE = 0x00, + PMU_GAUGE_CHARGE_HI = 0x01, + PMU_GAUGE_CHARGE_LO = 0x02, + PMU_GAUGE_TEMP_HI = 0x04, + PMU_GAUGE_TEMP_LO = 0x08, + PMU_GAUGE_VOLT_LO = 0x10, + PMU_GAUGE_VOLT_HI = 0x20, +}; + +typedef struct pmu_gauge_ops { + uint8_t (*check_events)(void); + uint16_t (*get_charge)(void); + void (*set_charge)(uint16_t val); + void (*set_low_threshold)(uint16_t val); + uint16_t (*get_temperature)(void); + uint16_t (*get_voltage)(void); +} pmu_gauge_ops_t; + +struct pmu_gauge { + const pmu_gauge_ops_t *ops; +}; +/** + * \brief Set the PMU's power gauge to the given one + * \param[in] pmu_gauge Pointer to the implementation's pmu_gauge + */ +void pmu_register_gauge(pmu_gauge_t *pmu_gauge); + +#endif /* PMU_H */ diff --git a/firmware/e300/battery/spi.c b/firmware/e300/battery/spi.c new file mode 100644 index 000000000..ae42c6e40 --- /dev/null +++ b/firmware/e300/battery/spi.c @@ -0,0 +1,86 @@ +/* USRP E310 Firmware Atmel AVR SPI driver + * Copyright (C) 2014 Ettus Research + * This file is part of the USRP E310 Firmware + * The USRP E310 Firmware is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 2 of the License, or + * (at your option) any later version. + * The USRP E310 Firmware is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * You should have received a copy of the GNU General Public License + * along with the USRP E310 Firmware. If not, see <http://www.gnu.org/licenses/>. + */ + +#include "mcu_settings.h" +#include "io.h" +#include "spi.h" +#include "utils.h" + +#include <avr/io.h> +#include <stdlib.h> +#include <util/delay.h> + +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); + +void spi_init(spi_type_t type, spi_order_t order, spi_mode_t mode, spi_speed_t speed) +{ + uint8_t val; + + io_output_pin(AVR_CS); + io_output_pin(AVR_MOSI); + io_input_pin(AVR_MISO); + io_output_pin(AVR_SCK); + + /* slave select is low active */ + io_set_pin(AVR_CS); + + /* SPCR looks like this: [SPIE | SPE | DORD | MSTR | CPOL | CPHA | SPR1 | SPR0] */ + val = BIT(SPE); + val |= (order == SPI_LSB_FIRST) ? BIT(DORD) : 0; + val |= (type == SPI_TYPE_MASTER) ? BIT(MSTR) : 0; + val |= mode << CPHA; + val |= speed << SPR0; + + SPCR = val; +} + +uint8_t spi_transact(uint8_t data) +{ + uint8_t ret; + + io_clear_pin(AVR_CS); + SPDR = data; + ret = SPDR; + io_set_pin(AVR_CS); + return ret; +} + +void spi_transact_buf(uint8_t *in, uint8_t *out, uint8_t size) +{ + uint8_t i; + + io_clear_pin(AVR_CS); + + for (i = 0; i < size; i++) { + SPDR = in[i]; + spi_wait_till_done(); + out[i] = SPDR; + } + + io_set_pin(AVR_CS); +} + +void spi_wait_till_done(void) +{ + uint8_t timeout = 100; + + do { + _delay_us(10); + timeout--; + } while (timeout && !(SPSR & BIT(SPIF))); +} diff --git a/firmware/e300/battery/spi.h b/firmware/e300/battery/spi.h new file mode 100644 index 000000000..9a94dbc7c --- /dev/null +++ b/firmware/e300/battery/spi.h @@ -0,0 +1,74 @@ +/* USRP E310 Firmware Atmel AVR SPI driver + * Copyright (C) 2014 Ettus Research + * This file is part of the USRP E310 Firmware + * The USRP E310 Firmware is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 2 of the License, or + * (at your option) any later version. + * The USRP E310 Firmware is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * You should have received a copy of the GNU General Public License + * along with the USRP E310 Firmware. If not, see <http://www.gnu.org/licenses/>. + */ + +/** + * \file spi.h + * \brief Atmel AVR SPI driver + */ + +#ifndef SPI_H +#define SPI_H + +#include <stdlib.h> + +typedef enum spi_type { + SPI_TYPE_MASTER = 0x00, + SPI_TYPE_SLAVE = 0x01 +} spi_type_t; + +typedef enum spi_mode { + SPI_MODE_0 = 0x00, /** CPOL=0, CPHA=0 */ + SPI_MODE_1 = 0x01, /** CPOL=0, CPHA=1 */ + SPI_MODE_2 = 0x02, /** CPOL=1, CPHA=0 */ + SPI_MODE_3 = 0x03, /** CPOL=1, CPHA=1 */ +} spi_mode_t; + +/* note that this assumes a clock speed of 8MHz */ +typedef enum spi_speed { + SPI_SPEED_2M = 0x00, + SPI_SPEED_500K = 0x01, + SPI_SPEED_125K = 0x02, + SPI_SPEED_62_5K = 0x03, +} spi_speed_t; + +typedef enum spi_order { + SPI_MSB_FIRST = 0x00, + SPI_LSB_FIRST = 0x01, +} spi_order_t; + +/** + * \brief Initialize the AVR's SPI module + * \param[in] master Operate as master + * \param[in] order Whether to send the LSB first + * \param[in] mode Which clock / phase configuration to use + * \param[in] speed Which speed to use + */ +void spi_init(spi_type_t type, spi_order_t order, spi_mode_t mode, spi_speed_t speed); + +/** + * \brief Transact one byte to the slave and receive one byte + * \param[in] mode Whether we're using the SPI in MSB or LSB first mode + * \param[in] speed Which speed to use, note that these speeds are based on a prescaler, + and the values are correct for a FCLK of 8 MHz +*/ +uint8_t spi_transact(uint8_t data); + +void spi_transact_buf(uint8_t *in, uint8_t *out, uint8_t size); +/** + * \brief Wait till transaction is done + */ +void spi_wait_till_done(void); + +#endif /* SPI_H */ diff --git a/firmware/e300/battery/timer.c b/firmware/e300/battery/timer.c new file mode 100644 index 000000000..1e87e30bf --- /dev/null +++ b/firmware/e300/battery/timer.c @@ -0,0 +1,82 @@ +/* USRP E310 Firmware Timer driver + * Copyright (C) 2014 Ettus Research + * This file is part of the USRP E310 Firmware + * The USRP E310 Firmware is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 2 of the License, or + * (at your option) any later version. + * The USRP E310 Firmware is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * You should have received a copy of the GNU General Public License + * along with the USRP E310 Firmware. If not, see <http://www.gnu.org/licenses/>. + */ + +#include <avr/io.h> + +#include "timer.h" +#include "utils.h" + + +static const uint8_t TIMER0_OFF_MASK = 0xf8; +static const uint8_t TIMER1_OFF_MASK = 0xf8; + +void timer0_init(void) +{ + /* ctc mode */ + TCCR0A = BIT(CTC0); + + /* 250 ms with 1024 prescale @ 1 MHz */ + OCR0A = 244;//244; + + /* ctc mode */ + TIMSK0 = BIT(OCIE0A); +} + +void timer0_start(void) +{ + TCNT0 = 0x00; + /* set prescaler to 1024 */ + TCCR0A |= BIT(CS02) | BIT(CS00); +} + +void timer0_stop(void) +{ + /* mask out all the bits to stop */ + TCCR0A &= TIMER0_OFF_MASK; +} + +void timer1_init(void) +{ + /* set counter register to 0 */ + TCNT1 = 0x0; + + /* ctc mode */ + TCCR1B = BIT(WGM12); + + /* hold button for roughly 2 seconds + * value is calculated as follows: + * val = 2 * f_clk / (prescaler * f_irq) - 1 + */ + OCR1A = 7811 * 2; + + /* enable CTC on timer 1 */ + TIMSK1 = BIT(OCIE1A); +} + +void timer1_start(void) +{ + /* reset counter register */ + TCNT1 = 0x0000; + + /* set prescaler to 1024 */ + TCCR1B |= BIT(CS12) | BIT(CS10); +} + +void timer1_stop(void) +{ + /* mask out all the bits to stop */ + TCCR1B &= TIMER1_OFF_MASK; +} + diff --git a/firmware/e300/battery/timer.h b/firmware/e300/battery/timer.h new file mode 100644 index 000000000..58dc1842d --- /dev/null +++ b/firmware/e300/battery/timer.h @@ -0,0 +1,53 @@ +/* USRP E310 Firmware Timer driver + * Copyright (C) 2014 Ettus Research + * This file is part of the USRP E310 Firmware + * The USRP E310 Firmware is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 2 of the License, or + * (at your option) any later version. + * The USRP E310 Firmware is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * You should have received a copy of the GNU General Public License + * along with the USRP E310 Firmware. If not, see <http://www.gnu.org/licenses/>. + */ + +/** + * \file timer.h + * \brief Timer driver + */ +#ifndef TIMER_H +#define TIMER_H + +/** + * \brief Initialize Timer 0 + */ +void timer0_init(void); + +/** + * \brief Start Timer 0 + */ +void timer0_start(void); + +/** + * \brief Stop Timer 0 + */ +void timer0_stop(void); + +/** + * \brief Initialize Timer 1 + */ +void timer1_init(void); + +/** + * \brief Start Timer 1 + */ +void timer1_start(void); + +/** + * \brief Stop Timer 1 + */ +void timer1_stop(void); + +#endif /* TIMER_H */ diff --git a/firmware/e300/battery/tps54478.c b/firmware/e300/battery/tps54478.c new file mode 100644 index 000000000..3e8ab4f53 --- /dev/null +++ b/firmware/e300/battery/tps54478.c @@ -0,0 +1,110 @@ +/* USRP E310 TP54478 driver + * Copyright (C) 2014 Ettus Research + * This file is part of the USRP E310 Firmware + * The USRP E310 Firmware is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 2 of the License, or + * (at your option) any later version. + * The USRP E310 Firmware is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * You should have received a copy of the GNU General Public License + * along with the USRP E310 Firmware. If not, see <http://www.gnu.org/licenses/>. + */ + +#include "mcu_settings.h" +#include "io.h" +#include "tps54478.h" + +#include <stdlib.h> + +#include <util/delay.h> +#include <util/atomic.h> + +static io_pin_t CORE_PWR_EN = IO_PA(3); +static io_pin_t CORE_PGOOD = IO_PB(0); + +/* per spec we should wait 3 ms here, + * but 10 is better to give external PSU some time + * to settle down*/ +static const uint8_t TPS54478_START_DELAY = 10; + +/* we'll use this to check for events in the event handler */ +static volatile bool tps54478_event = false; + +bool tps54478_get_power_good(void) +{ + return io_test_pin(CORE_PGOOD); +} + +static int8_t tps54478_set_regulator(pmu_regulator_t *pmu_reg, bool on) +{ + (void) pmu_reg; + + if (on) { + io_input_pin(CORE_PWR_EN); + _delay_ms(TPS54478_START_DELAY); + } else { + io_output_pin(CORE_PWR_EN); + /* no delay here as we can't detect this state anyway */ + return 0; + } + /* return zero on success ... */ + return !(on == tps54478_get_power_good()); +} + +void tps54478_init(bool enable) +{ + /* enable pull-up for open drain */ + io_input_pin(CORE_PGOOD); + io_set_pin(CORE_PGOOD); + + tps54478_set_regulator(NULL, enable); + + io_clear_pin(CORE_PWR_EN); +} + +int8_t tps54478_check_events(pmu_regulator_t *reg) +{ + bool power_good; + bool event; + + event = false; + ATOMIC_BLOCK(ATOMIC_RESTORESTATE) { + if (tps54478_event) { + tps54478_event = false; + event = true; + } + } + + if (event) { + power_good = tps54478_get_power_good(); + if (!power_good) + return -1; + } + return 0; +} + +const pmu_regulator_ops_t tps54478_ops = { + .set_voltage = NULL, + .set_regulator = tps54478_set_regulator, + .check_events = tps54478_check_events, +}; + +irqreturn_t tps54478_irq_handler(void) +{ + bool power_good; + power_good = tps54478_get_power_good(); + + /* check if the device indicates power is good, + * if it is probably we're not the source of the IRQ, + * if it is *not* set the event flag to deal with it later */ + if (power_good) { + return IRQ_NONE; + } else { + tps54478_event = true; + return IRQ_HANDLED; + } + return IRQ_HANDLED; +} diff --git a/firmware/e300/battery/tps54478.h b/firmware/e300/battery/tps54478.h new file mode 100644 index 000000000..c8cad1eff --- /dev/null +++ b/firmware/e300/battery/tps54478.h @@ -0,0 +1,46 @@ +/* USRP E310 Firmware Texas Instruments TPS54478 driver + * Copyright (C) 2014 Ettus Research + * This file is part of the USRP E310 Firmware + * The USRP E310 Firmware is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 2 of the License, or + * (at your option) any later version. + * The USRP E310 Firmware is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * You should have received a copy of the GNU General Public License + * along with the USRP E310 Firmware. If not, see <http://www.gnu.org/licenses/>. + */ + +/** + * \file tps54478.h + * \brief Texas Instruments TPS54478 driver + */ + +#ifndef TPS54478_H +#define TPS54478_H + +#include <stdbool.h> +#include "pmu.h" +#include "interrupt.h" + +/** + * \brief Initializes the TPS54478 controlling the core power supply + * \param[in] enabled Controls whether the core power gets turned on + */ +void tps54478_init(bool enabled); + +/** + * \brief The IRQ handler for the CHG_IRQ external pin change interrupt + * \return IRQ_HANDLED in case IRQ was handled, IRQ_NONE in case shared interrupt is not for us + */ +extern irqreturn_t tps54478_irq_handler(void); + +typedef struct tps54478_pmu_regulator { + pmu_regulator_t pmu_reg; +} tps54478_pmu_regulator_t; + +extern const pmu_regulator_ops_t tps54478_ops; + +#endif /* TPS54478_H */ diff --git a/firmware/e300/battery/utils.h b/firmware/e300/battery/utils.h new file mode 100644 index 000000000..65cc2c5d9 --- /dev/null +++ b/firmware/e300/battery/utils.h @@ -0,0 +1,53 @@ +/* USRP E310 Firmware Misc utility macros + * Copyright (C) 2014 Ettus Research + * This file is part of the USRP E310 Firmware + * The USRP E310 Firmware is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 2 of the License, or + * (at your option) any later version. + * The USRP E310 Firmware is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * You should have received a copy of the GNU General Public License + * along with the USRP E310 Firmware. If not, see <http://www.gnu.org/licenses/>. + */ + +/** + * \file utils.h + * \brief Misc utility macros + */ + +#ifndef UTILS_H +#define UTILS_H + +#include <stddef.h> + +/** + * \brief Returns the size of a (static) array + * + * \param x Array + * \warning Do NOT use on pointers + */ +#define ARRAY_SIZE(x) (sizeof(x)/sizeof(x[0])) + + +/** + * \brief A ISO compliant version of the linux kernel's container_of macro. + * This allows implementing multiple interfaces in a struct. + */ +#ifdef __GNUC__ +#define member_type(type, member) __typeof__ (((type *)0)->member) +#else +#define member_type(type, member) const void +#endif + +#define container_of(ptr, type, member) ((type *)( \ + (char *)(member_type(type, member) *){ ptr } - offsetof(type, member))) + +/** + * \brief Convenience macro to make bitmasks more readable + */ +#define BIT(bit) (1 << (bit)) + +#endif /* UTILS_H */ |