SFBPower.h

Go to the documentation of this file.

/*
  SFBPower.h Power control and monitoring routines for the SFB.
  Copyright (C) 2009 The Regents of the University of New Mexico.  All rights reserved.

  This library is free software; you can redistribute it and/or
  modify it under the terms of the GNU Lesser General Public
  License as published by the Free Software Foundation; either
  version 2.1 of the License, or (at your option) any later version.

  This library 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
  Lesser General Public License for more details.

  You should have received a copy of the GNU General Public License
  along with this library; if not, write to the Free Software
  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301
  USA

  $Id$
*/

#ifndef SFBPOWER_H
#define SFBPOWER_H

#include "SFBTypes.h"     /* For u8 */
#include "SFBConstants.h" /* For FACE_COUNT */
#include "SFBAssert.h"    /* For API_ASSERT_MAX */

extern int powerDraw();

extern int powerDraw(u32 face);

extern int rawPower(u32 face);

extern s32 faceVoltage(u32 face, bool smoothed = true) ; 

extern s32 railVoltage(bool smoothed = true) ;

extern int rawVoltage();

extern void powerOut(u32 face, int on);  

extern bool isPowerOut(u32 face);  

extern void powerIn(u32 face, int on);

/* Set all outbound power ON */
extern void initPowerOuts();

extern void invalidateCalibrationData();

enum ADCSampleIndices {
  NORTH_VSENSE_ADC_IDX,
  SOUTH_VSENSE_ADC_IDX,
  EAST_VSENSE_ADC_IDX,
  WEST_VSENSE_ADC_IDX,
  VEE_VSENSE_ADC_IDX,
  VSENSE_IDX_COUNT,

  VCC_VSENSE_ADC_IDX = VSENSE_IDX_COUNT,
  
  NORTH_ISENSE_ADC_IDX,
  SOUTH_ISENSE_ADC_IDX,
  EAST_ISENSE_ADC_IDX,
  WEST_ISENSE_ADC_IDX,
  ADC_IDX_COUNT
};

#define ADC_NOMINAL_MV_PER_COUNT 3.22581
#define ADC_FACE_RATIO 10.0
#define ADC_VCC_RATIO 2.0

#define NOMINAL_COUNTS_FOR_MV_FACE(mv) ((u32) (0.5+((mv)/ADC_NOMINAL_MV_PER_COUNT/ADC_FACE_RATIO)))
#define NOMINAL_COUNTS_FOR_MV_VCC(mv) ((u32) (0.5+((mv)/ADC_NOMINAL_MV_PER_COUNT/ADC_VCC_RATIO)))
#define NOMINAL_MV_FOR_COUNT_FACE(count) ((u32) (0.5+((count)*ADC_NOMINAL_MV_PER_COUNT*ADC_FACE_RATIO)))

#define EXTRA_SLOPE_BITS 6
#define UNCALIBRATED_SLOPE_FACE ((u32) ((ADC_NOMINAL_MV_PER_COUNT*ADC_FACE_RATIO)*(1<<EXTRA_SLOPE_BITS)))
#define UNCALIBRATED_CUTOFF 300
#define UNCALIBRATED_INTERCEPT_FACE (UNCALIBRATED_CUTOFF*UNCALIBRATED_SLOPE_FACE)

#define CUTOFF_INDEX 0
#define CUTOFF_BITS 5
#define CUTOFF_CENTER 16
#define CUTOFF_CT_PER_VALUE 10
#define CUTOFF_OFFSET 300

#define INTERCEPT_INDEX (CUTOFF_INDEX+CUTOFF_BITS)
#define INTERCEPT_BITS 5
#define INTERCEPT_CENTER 16
#define INTERCEPT_MV_PER_VALUE 25
#define INTERCEPT_OFFSET -300

#define SLOPE0_INDEX (INTERCEPT_INDEX+INTERCEPT_BITS)
#define SLOPE0_BITS 7
#define SLOPE0_CENTER 64
#define SLOPE0_SCALED_MV_PER_CT_PER_VALUE 10
#define SLOPE0_OFFSET (UNCALIBRATED_SLOPE_FACE+SLOPE0_CENTER*SLOPE0_SCALED_MV_PER_CT_PER_VALUE)

#define SLOPE1_INDEX (SLOPE0_INDEX+SLOPE0_BITS)
#define SLOPE1_BITS 7
#define SLOPE1_CENTER 64
#define SLOPE1_SCALED_MV_PER_CT_PER_VALUE 10
#define SLOPE1_OFFSET (UNCALIBRATED_SLOPE_FACE+SLOPE1_CENTER*SLOPE1_SCALED_MV_PER_CT_PER_VALUE)

struct xcalib {
  u32 cutoff;
  s32 slope[2];
  s32 intercept[2];

  /* Here for 'default datasheet' behavior */
  void init() {
    init(0, UNCALIBRATED_SLOPE_FACE, UNCALIBRATED_SLOPE_FACE, 0);
  }

  void init(u32 c, s32 m0, s32 m1, s32 b) {
    cutoff = c;
    slope[0] = m0;
    intercept[0] = ((NOMINAL_MV_FOR_COUNT_FACE(c)+b)<<EXTRA_SLOPE_BITS)-m0*c;
    slope[1] = m1;
    intercept[1] = ((NOMINAL_MV_FOR_COUNT_FACE(c)+b)<<EXTRA_SLOPE_BITS)-m1*c;
  }
};
extern xcalib adcCalibs[VSENSE_IDX_COUNT];

struct calibData {

  u32 data;
  inline u32 getBits(u32 bitIdx, u32 bits) {
    return (data>>bitIdx)&((1<<bits)-1);
  }
  void putBits(u32 bitIdx, u32 bits,u32 value) {
    u32 nbits = ((1<<bits)-1); 
    data &= ~(nbits<<bitIdx);
    data |= (value&nbits)<<bitIdx;
  }
  void init(u32 cutoff, u32 intercept, u32 slope0, u32 slope1) {
    putBits(CUTOFF_INDEX,CUTOFF_BITS,cutoff);
    putBits(INTERCEPT_INDEX,INTERCEPT_BITS,intercept);
    putBits(SLOPE0_INDEX,SLOPE0_BITS,slope0);
    putBits(SLOPE1_INDEX,SLOPE1_BITS,slope1);
  }
  void getFields(u32 & cutoff, u32 & intercept, u32 & slope0, u32 & slope1) {
    cutoff = getBits(CUTOFF_INDEX,CUTOFF_BITS);
    intercept = getBits(INTERCEPT_INDEX,INTERCEPT_BITS);
    slope0 = getBits(SLOPE0_INDEX,SLOPE0_BITS);
    slope1 = getBits(SLOPE1_INDEX,SLOPE1_BITS);
  }
  inline s32 getValue(u32 bitIdx, u32 bits, s32 center, s32 amtPerValue, s32 offset) {
    s32 value = getBits(bitIdx,bits);
    return (value-center)*amtPerValue+offset;
  }
  s32 getCutoffCt() { 
    return getValue(CUTOFF_INDEX,CUTOFF_BITS,CUTOFF_CENTER,CUTOFF_CT_PER_VALUE,CUTOFF_OFFSET);
  }
  s32 getInterceptMv() { 
    return
      getValue(INTERCEPT_INDEX,INTERCEPT_BITS,INTERCEPT_CENTER,INTERCEPT_MV_PER_VALUE,INTERCEPT_OFFSET);
  }
  s32 getSlopeScaledMvPerCt(u32 which) ;

  void initXcalib(xcalib & x) ;
};

extern void initxcalibsFromGene(u32 gene[VSENSE_IDX_COUNT]) ;

#define VOLTAGE_CALIBRATION_SIZE_BYTES (VSENSE_IDX_COUNT*3)

#define ADC_SCALE_BITS 6   /* This is fixed by the AD0DRx hardware; can't be changed efficiently */
#define WEIGHT_BITS 5  /* Could be 5 for a ton of smoothing, or 3..1 for less (0 would be redundant) */
#define UPDATE_SMOOTHED_BUFFER(u16buf,adcScaledData) \
  ((u16buf) = (u16) (((((u32)(u16buf))<<WEIGHT_BITS)-(u16buf)+(adcScaledData))>>WEIGHT_BITS))

static inline s32 mapADCCounts(u16 scaledCount, s32 slope, s32 intercept) {
  return (((scaledCount*slope)>>ADC_SCALE_BITS)+intercept)>>EXTRA_SLOPE_BITS;
}

extern void unpackCalibrationData(u32 gene[VSENSE_IDX_COUNT], u8 bytes[VOLTAGE_CALIBRATION_SIZE_BYTES]) ;

extern void loadCalibrationData() ;

extern u16 adcLatestSample[ADC_IDX_COUNT];

extern u16 adcSmooth[ADC_IDX_COUNT];

static inline u16 getADCSample(u32 sampleIdx, bool smoothed) {
  API_ASSERT_MAX(sampleIdx,ADC_IDX_COUNT);
  return smoothed?adcSmooth[sampleIdx]:adcLatestSample[sampleIdx];
}

#define ADC_FLAG_CODE 0x000f /* Can't occur in nature: ADC always gives 6 LSBs==0 */
static inline bool isADCSensingEnabled() {
  return adcLatestSample[NORTH_ISENSE_ADC_IDX] != ADC_FLAG_CODE;
}
static inline bool isPowerSensingEnabled() {
  return adcLatestSample[SOUTH_ISENSE_ADC_IDX] != ADC_FLAG_CODE;
}
extern void setADCSensingEnabled(bool enable) ;
extern void setPowerSensingEnabled(bool enable) ;

extern void initADC();
extern void reinitADC();
#endif /* SFBPOWER_H */