hip9011.cpp File Reference

Detailed Description

HIP9011/TPIC8101 driver.

Jan 2017 status: 1) seems to be kind of working - reacts to parameter changes and does produce variable output 2) only one (first) channel is currently used 3) engine control does not yet react to knock since very little actual testing - no engine runs with proven knock yet

http://rusefi.com/forum/viewtopic.php?f=4&t=400 http://rusefi.com/forum/viewtopic.php?f=5&t=778

pin1 VDD pin2 GND

pin8 Chip Select - CS pin11 Slave Data Out - MISO pin12 Slave Data In - MOSI pin13 SPI clock - SCLK

http://www.ti.com/lit/ds/symlink/tpic8101.pdf http://www.intersil.com/content/dam/Intersil/documents/hip9/hip9011.pdf http://www.intersil.com/content/dam/Intersil/documents/an97/an9770.pdf http://e2e.ti.com/cfs-file/__key/telligent-evolution-components-attachments/00-26-01-00-00-42-36-40/TPIC8101-Training.pdf

max SPI frequency: 5MHz max

Date

Nov 27, 2013

Author

Andrey Belomutskiy, (c) 2012-2020 @Spilly

Definition in file hip9011.cpp.

Functions
static void	hip_addconsoleActions ()
static int	hip_wake_driver ()
static void	startIntegration (HIP9011 *hip)
static void	endIntegration (HIP9011 *hip)
void	onStartKnockSampling (uint8_t, float, uint8_t)
void	hip9011_onFireEvent (uint8_t cylinderNumber, efitick_t nowNt)
void	hipAdcCallback (float volts)
static int	hip_testAdvMode ()
static int	hip_init ()
static	THD_WORKING_AREA (hipThreadStack, UTILITY_THREAD_STACK_SIZE)
static msg_t	hipThread (void *arg)
void	stopHip9011_pins ()
void	startHip9011_pins ()
void	initHip9011 ()
static void	showHipInfo ()
static void	setPrescaler (int value)
static void	setHipGain (float value)

Variables
static NamedOutputPin	intHold (PROTOCOL_HIP_NAME)
static NamedOutputPin	Cs (PROTOCOL_HIP_NAME)
static semaphore_t	wake
static Hip9011Hardware	hardware
static float	normalizedValue [HIP_INPUT_CHANNELS]
static float	normalizedValueMax [HIP_INPUT_CHANNELS]
static SPIDriver *	spi
static SPIConfig	hipSpiCfg
static const char *	hip_state_names []

Function Documentation

endIntegration()

static void endIntegration ( HIP9011 *  hip )

static

isIntegrating could be 'false' if an SPI command was pending thus we did not integrate during this engine cycle

Definition at line 246 of file hip9011.cpp.

                                         {
    /**
     * isIntegrating could be 'false' if an SPI command was pending thus we did not integrate during this
     * engine cycle
     */
    if (hip->state == IS_INTEGRATING) {
        intHold.setLow();
 
        hip->knockSampleTimestamp = getTimeNowNt();
 
        if (instance.adv_mode) {
            /* read value over SPI in thread mode */
            hip->state = NOT_READY;
            hip_wake_driver();
        } else {
            /* wait for ADC samples */
            hip->state = WAITING_FOR_ADC_TO_SKIP;
        }
    }
}

Here is the call graph for this function:

hip9011_onFireEvent()

void hip9011_onFireEvent	(	uint8_t	cylinderNumber,
		efitick_t	nowNt
	)

Ignition callback used to start HIP integration and schedule finish

Definition at line 283 of file hip9011.cpp.

                                                                  {
    if (!engineConfiguration->isHip9011Enabled)
        return;
 
    /* We are not checking here for READY_TO_INTEGRATE state as
     * previous integration may be still in progress, while
     * we are scheduling next integration start only
     * knockDetectionWindowStart from now.
     * Check for correct state will be done at startIntegration () */
 
    if (cylinderNumber == instance.expectedCylinderNumber) {
        /* save currect cylinder */
        instance.cylinderNumber = cylinderNumber;
 
        /* smart books says we need to sence knock few degrees after TDC
         * currently I have no idea how to hook to cylinder TDC in correct way.
         * So schedule start of integration + knockDetectionWindowStart from fire event
         * Keep this is mind when setting knockDetectionWindowStart */
        scheduleByAngle(&hardware.startTimer, nowNt,
                engineConfiguration->knockDetectionWindowStart,
                { startIntegration, &instance });
 
        scheduleByAngle(&hardware.endTimer, nowNt,
                engineConfiguration->knockDetectionWindowStart + engineConfiguration->knockSamplingDuration,
                { endIntegration, &instance });
    } else {
        #if EFI_HIP_9011_DEBUG
            /* out of sync */
            if (instance.expectedCylinderNumber >= 0)
                instance.unsync++;
        #endif
        /* save currect cylinder */
        instance.cylinderNumber = cylinderNumber;
        /* Skip integration, call driver task to prepare for next cylinder */
        instance.state = NOT_READY;
        hip_wake_driver();
    }
}

Referenced by Engine::onSparkFireKnockSense().

Here is the call graph for this function:

Here is the caller graph for this function:

hip_addconsoleActions()

static void hip_addconsoleActions ( )

static

Definition at line 689 of file hip9011.cpp.

                                    {
    addConsoleAction("hipinfo", showHipInfo);
    addConsoleActionF("set_gain", setHipGain);
    addConsoleActionI("set_hip_prescaler", setPrescaler);
}

Referenced by initHip9011().

Here is the call graph for this function:

Here is the caller graph for this function:

hip_init()

static int hip_init ( )

static

Definition at line 374 of file hip9011.cpp.

                      {
    int ret;
 
    /* Just to enable SDO */
    ret = instance.hw->sendSyncCommand(SET_PRESCALER_CMD(instance.prescaler), NULL);
    if (ret) {
        /* NOTE: hip9011/tpic8101 can be in default or advanced mode at this point
         * If we supposed not to support advanced mode this is definitely error */
        if (!engineConfiguration->useTpicAdvancedMode)
            return ret;
    }
 
    /* ...othervice or when no error is reported lets try to switch to advanced mode */
    if (engineConfiguration->useTpicAdvancedMode) {
        uint8_t rx = 0x00;
        /* enable advanced mode */
        instance.hw->sendSyncCommand(SET_ADVANCED_MODE_CMD, NULL);
 
        /* send enable advanced mode again... */
        instance.hw->sendSyncCommand(SET_ADVANCED_MODE_CMD, NULL);
 
        /* to get reply on next command */
        instance.hw->sendSyncCommand(SET_ADVANCED_MODE_CMD, &rx);
        if (rx != SET_ADVANCED_MODE_REP) {
            /* this is really a communication problem */
            return -1;
        }
 
        /* now we should be in advanced mode... if chip supports...
         * set advanced mode flag now so checkResponse will switch to
         * advanced mode checkig (not implemented) */
        instance.adv_mode = true;
 
        ret = hip_testAdvMode();
        if (ret) {
            warning(ObdCode::CUSTOM_OBD_KNOCK_PROCESSOR, "TPIC/HIP does not support advanced mode");
            instance.adv_mode = false;
            return -1;
        }
    }
 
    #if EFI_HIP_9011_DEBUG
        /* reset counters now */
        instance.correctResponsesCount = 0;
        instance.invalidResponsesCount = 0;
        instance.samples = 0;
        instance.overrun = 0;
        instance.unsync = 0;
    #endif
 
    instance.state = READY_TO_INTEGRATE;
 
    return 0;
}

Referenced by hipThread().

Here is the call graph for this function:

Here is the caller graph for this function:

hip_testAdvMode()

static int hip_testAdvMode ( )

static

Definition at line 340 of file hip9011.cpp.

                             {
    int ret;
    uint8_t ret0, ret1, ret2;
 
    /* do not care about configuration values, we meed replyes only.
     * correct values will be uploaded later */
 
    /* A control byte is written to the SDI and shifted with the MSB
     * first. The response byte on the SDO is shifted out with the MSB
     * first. The response byte corresponds to the previous command.
     * Therefore, the SDI shifts in a control byte n and shifts out a
     * response command byte n − 1. */
    ret = instance.hw->sendSyncCommand(SET_BAND_PASS_CMD(0), NULL);
    if (ret)
        return ret;
    ret = instance.hw->sendSyncCommand(SET_GAIN_CMD(0), &ret0);
    if (ret)
        return ret;
    ret = instance.hw->sendSyncCommand(SET_INTEGRATOR_CMD(0), &ret1);
    if (ret)
        return ret;
    ret = instance.hw->sendSyncCommand(SET_INTEGRATOR_CMD(0), &ret2);
    if (ret)
        return ret;
 
    /* magic reply bytes from DS Table 2 */
    if ((ret0 == SET_BAND_PASS_REP) &&
        (ret1 == SET_GAIN_REP) &&
        (ret2 == SET_INTEGRATOR_REP))
        return 0;
 
    return -1;
}

Referenced by hip_init().

Here is the call graph for this function:

Here is the caller graph for this function:

hip_wake_driver()

static int hip_wake_driver ( )

static

chSemSignalI above requires rescheduling interrupt handlers have implicit rescheduling

Definition at line 213 of file hip9011.cpp.

{
    /* Entering a reentrant critical zone.*/
    syssts_t sts = chSysGetStatusAndLockX();
    chSemSignalI(&wake);
    if (!port_is_isr_context()) {
        /**
         * chSemSignalI above requires rescheduling
         * interrupt handlers have implicit rescheduling
         */
        chSchRescheduleS();
    }
    /* Leaving the critical zone.*/
    chSysRestoreStatusX(sts);
 
    return 0;
}

Referenced by endIntegration(), hip9011_onFireEvent(), and hipAdcCallback().

Here is the caller graph for this function:

hipAdcCallback()

void hipAdcCallback

(

float

volts

)

Definition at line 322 of file hip9011.cpp.

                                 {
    /* we read in digital mode */
    if (instance.adv_mode)
        return;
    if (instance.state == WAITING_FOR_ADC_TO_SKIP) {
        instance.state = WAITING_FOR_RESULT_ADC;
    } else if (instance.state == WAITING_FOR_RESULT_ADC) {
        /* offload calculations to driver thread */
        if (instance.channelIdx < HIP_INPUT_CHANNELS) {
            /* normalize to 0..HIP9011_DIGITAL_OUTPUT_MAX */
            instance.rawValue[instance.channelIdx] =
                volts * HIP9011_DIGITAL_OUTPUT_MAX / HIP9011_ANALOG_OUTPUT_MAX;
        }
        instance.state = NOT_READY;
        hip_wake_driver();
    }
}

Referenced by onFastAdcComplete().

Here is the call graph for this function:

Here is the caller graph for this function:

hipThread()

static msg_t hipThread ( void *  arg )

static

Definition at line 431 of file hip9011.cpp.

                                  {
    int ret;
    UNUSED(arg);
    chRegSetThreadName("hip9011 worker");
 
    /* This strange code was here before me.
     * Not sure why we need it */
#if 0
    /* Acquire ownership of the bus. */
    spiAcquireBus(spi);
    // some time to let the hardware start
    Cs.setValue(true);
    chThdSleepMilliseconds(100);
    Cs.setValue(false);
    chThdSleepMilliseconds(100);
    Cs.setValue(true);
    /* Ownership release. */
    spiReleaseBus(spi);
 
    chThdSleepMilliseconds(100);
#endif
 
    do {
        /* retry until success */
        ret = hip_init();
        if (ret) {
            warning(ObdCode::CUSTOM_OBD_KNOCK_PROCESSOR, "TPIC/HIP does not respond: %d", ret);
            chThdSleepMilliseconds(10 * 1000);
        }
    } while (ret);
 
    while (1) {
        msg_t msg;
 
        /* load new/updated settings */
        instance.handleSettings(Sensor::getOrZero(SensorType::Rpm) DEFINE_PARAM_SUFFIX(PASS_HIP_PARAMS));
        /* in advanced more driver will set channel while reading integrator value */
        if (!instance.adv_mode) {
            /* switch input channel */
            instance.handleChannel(DEFINE_PARAM_SUFFIX(PASS_HIP_PARAMS));
        }
        /* State */
        instance.state = READY_TO_INTEGRATE;
 
        msg = chSemWaitTimeout(&wake, TIME_INFINITE);
        if (msg == MSG_TIMEOUT) {
            /* ??? */
        } else {
            int rawValue;
            /* check now, before readValueAndHandleChannel did not overwrite expectedCylinderNumber */
            bool correctCylinder = (instance.cylinderNumber == instance.expectedCylinderNumber);
 
            /* this needs to be called in any case to set proper channel for next cycle */
            if (instance.adv_mode) {
                rawValue = instance.readValueAndHandleChannel(DEFINE_PARAM_SUFFIX(PASS_HIP_PARAMS));
 
                /* spi communication issue? */
                if (rawValue < 0)
                    continue;
            }
 
            /* check that we know channel for current measurement */
            int idx = instance.channelIdx;
            if (!(idx < HIP_INPUT_CHANNELS))
                continue;
 
            float knockNormalized = 0.0f;
            float knockVolts = 0.0f;
 
            /* calculations */
            if (instance.adv_mode) {
                instance.rawValue[idx] = rawValue;
            } else {
                /* get value stored by callback */
                rawValue = instance.rawValue[idx];
            }
            /* convert 10 bit integer value to 0.0 .. 1.0 float */
            knockNormalized = ((float)rawValue) / HIP9011_DIGITAL_OUTPUT_MAX;
            /* convert to magic volts
             * TODO: remove conversion to volts */
            knockVolts = knockNormalized * HIP9011_ANALOG_OUTPUT_MAX;
 
            /* Check for correct cylinder/input */
            if (correctCylinder) {
                // TODO: convert knock level to dBv
                engine->module<KnockController>()->onKnockSenseCompleted(instance.cylinderNumber, knockVolts, instance.knockSampleTimestamp);
 
                #if EFI_HIP_9011_DEBUG
                    /* debug */
                    normalizedValue[idx] = knockNormalized;
                    normalizedValueMax[idx] = std::max(knockNormalized, normalizedValueMax[idx]);
                    /* counters */
                    instance.samples++;
                #endif
            } else {
                /* out of sync event already calculated, nothing to do */
            }
        }
    }
 
    return -1;
}

Referenced by initHip9011().

Here is the call graph for this function:

Here is the caller graph for this function:

initHip9011()

void initHip9011

(

)

Definition at line 564 of file hip9011.cpp.

                   {
    if (!engineConfiguration->isHip9011Enabled)
        return;
 
    startHip9011_pins();
 
    /* load settings */
    instance.prescaler = engineConfiguration->hip9011Prescaler;
 
    efiPrintf("Starting HIP9011/TPIC8101 driver");
 
    /* init semaphore */
    chSemObjectInit(&wake, 10);
    chThdCreateStatic(hipThreadStack, sizeof(hipThreadStack), PRIO_HIP9011, (tfunc_t)(void*) hipThread, NULL);
 
    #if EFI_HIP_9011_DEBUG
        hip_addconsoleActions();
    #endif
}

Referenced by initHardware().

Here is the call graph for this function:

Here is the caller graph for this function:

onStartKnockSampling()

void onStartKnockSampling	(	uint8_t	,
		float	,
		uint8_t
	)

Definition at line 267 of file hip9011.cpp.

                                                         {
    /* TODO: @dron0gus: not sure if we need the expectedCylinderNumber logic at all
 
    Something like this might be right:
 
    startIntegration(&instance);
 
    efitick_t windowLength = USF2NT(1e6 * samplingTimeSeconds);
 
    engine->executor.scheduleByTimestampNt("knock", &hardware.endTimer, getTimeNowNt() + windowLength, { endIntegration, &instance });
    */
}

setHipGain()

static void setHipGain ( float  value )

static

Definition at line 684 of file hip9011.cpp.

                                    {
    engineConfiguration->hip9011Gain = value;
    showHipInfo();
}

Referenced by hip_addconsoleActions().

Here is the call graph for this function:

Here is the caller graph for this function:

setPrescaler()

static void setPrescaler ( int  value )

static

Definition at line 680 of file hip9011.cpp.

                                    {
    engineConfiguration->hip9011Prescaler = value;
}

Referenced by hip_addconsoleActions().

Here is the caller graph for this function:

showHipInfo()

static void showHipInfo ( )

static

Definition at line 599 of file hip9011.cpp.

                          {
    if (!engineConfiguration->isHip9011Enabled) {
        efiPrintf("hip9011 driver not active");
        return;
    }
 
    efiPrintf("HIP9011: enabled %s",
        boolToString(engineConfiguration->isHip9011Enabled));
 
    if (!engineConfiguration->isHip9011Enabled) {
        return;
    }
 
    efiPrintf(" State %s",
        hip_state_names[instance.state]);
 
    efiPrintf(" Advanced mode: enabled %d used %d",
        engineConfiguration->useTpicAdvancedMode,
        instance.adv_mode);
 
    efiPrintf(" Input Ch %d (cylinder %d next %d)",
        instance.channelIdx,
        instance.cylinderNumber,
        instance.expectedCylinderNumber);
 
    efiPrintf(" Cyl bore %.2fmm freq %.2fkHz band idx 0x%x",
        (float)engineConfiguration->cylinderBore,
        instance.getBand(PASS_HIP_PARAMS),
        instance.bandIdx);
 
    efiPrintf(" Integrator %d uS idx 0x%x RPM %d",
        instance.getIntegrationTimeByIndex(instance.intergratorIdx),
        instance.intergratorIdx, instance.rpmLookup[INT_LOOKUP_SIZE - 1 - instance.intergratorIdx]);
 
    efiPrintf(" Gain %.2f idx 0x%x",
        engineConfiguration->hip9011Gain,
        instance.gainIdx);
 
    efiPrintf(" PaSDO=0x%x",
        instance.prescaler);
 
    efiPrintf(" IntHold %s (mode 0x%x)",
        hwPortname(engineConfiguration->hip9011IntHoldPin),
        engineConfiguration->hip9011IntHoldPinMode);
 
    efiPrintf(" Spi %s CS %s (mode 0x%x)",
        getSpi_device_e(engineConfiguration->hip9011SpiDevice),
        hwPortname(engineConfiguration->hip9011CsPin),
        engineConfiguration->hip9011CsPinMode);
 
#if EFI_PROD_CODE
    printSpiConfig("hip9011", engineConfiguration->hip9011SpiDevice);
#endif /* EFI_PROD_CODE */
 
    efiPrintf(" SPI: good response %d incorrect response %d",
        instance.correctResponsesCount,
        instance.invalidResponsesCount);
 
    efiPrintf(" Counters: samples %d overruns %d sync miss %d",
        instance.samples, instance.overrun, instance.unsync);
 
    efiPrintf(" Window start %.2f end %.2f",
        engineConfiguration->knockDetectionWindowStart,
        engineConfiguration->knockDetectionWindowStart + engineConfiguration->knockSamplingDuration);
 
    if (!instance.adv_mode) {
        efiPrintf(" Adc input %d (%.2f V)",
            (int)engineConfiguration->hipOutputChannel,
            adcGetRawVoltage("hipinfo", engineConfiguration->hipOutputChannel));
    }
 
    for (int i = 0; i < HIP_INPUT_CHANNELS; i++) {
        efiPrintf("  input[%d] %d -> %.3f (max %.3f)",
            i,
            instance.rawValue[i],
            normalizedValue[i],
            normalizedValueMax[i]);
        normalizedValueMax[i] = 0.0;
    }
}

Referenced by hip_addconsoleActions(), and setHipGain().

Here is the call graph for this function:

Here is the caller graph for this function:

startHip9011_pins()

void startHip9011_pins

(

)

Definition at line 547 of file hip9011.cpp.

                         {
    intHold.initPin("hip int/hold", engineConfiguration->hip9011IntHoldPin, engineConfiguration->hip9011IntHoldPinMode);
    intHold.setValue(1);
    Cs.initPin("hip CS", engineConfiguration->hip9011CsPin, engineConfiguration->hip9011CsPinMode);
    Cs.setValue(1);
 
#if EFI_PROD_CODE
    spi = getSpiDevice(engineConfiguration->hip9011SpiDevice);
    if (spi == NULL) {
        // error already reported
        return;
    }
    hipSpiCfg.ssport = getHwPort("hip", engineConfiguration->hip9011CsPin);
    hipSpiCfg.sspad = getHwPin("hip", engineConfiguration->hip9011CsPin);
#endif /* EFI_PROD_CODE */
}

Referenced by applyNewHardwareSettings(), and initHip9011().

Here is the call graph for this function:

Here is the caller graph for this function:

startIntegration()

static void startIntegration ( HIP9011 *  hip )

static

SPI communication is only allowed while not integrating, so we postpone the exchange until we are done integrating

Definition at line 231 of file hip9011.cpp.

                                           {
    if (hip->state == READY_TO_INTEGRATE) {
        /**
         * SPI communication is only allowed while not integrating, so we postpone the exchange
         * until we are done integrating
         */
        hip->state = IS_INTEGRATING;
        intHold.setHigh();
    } else {
        #if EFI_HIP_9011_DEBUG
            hip->overrun++;
        #endif
    }
}

Here is the call graph for this function:

stopHip9011_pins()

void stopHip9011_pins

(

)

Definition at line 538 of file hip9011.cpp.

                        {
    intHold.deInit();
    Cs.deInit();
#if EFI_PROD_CODE
    spi = NULL;
    hipSpiCfg.ssport = NULL;
#endif
}

Referenced by applyNewHardwareSettings().

Here is the call graph for this function:

Here is the caller graph for this function:

THD_WORKING_AREA()

static THD_WORKING_AREA ( hipThreadStack  , UTILITY_THREAD_STACK_SIZE    )

static

Variable Documentation

Cs

NamedOutputPin Cs(PROTOCOL_HIP_NAME) ( PROTOCOL_HIP_NAME  )

static

Referenced by hipThread(), startHip9011_pins(), and stopHip9011_pins().

hardware

HIP9011 instance & hardware

static

Definition at line 81 of file hip9011.cpp.

Referenced by HIP9011::HIP9011(), hip9011_onFireEvent(), StepperMotorBase::initialize(), and StepperMotor::initialize().

hip_state_names

const char* hip_state_names[]

static

Initial value:

=
{
    "Not ready/calculating",
    "Ready for integration",
    "Integrating",
    "Waiting for first ADC sample",
    "Waiting for second ADC sample"
}

Definition at line 590 of file hip9011.cpp.

{
    "Not ready/calculating",
    "Ready for integration",
    "Integrating",
    "Waiting for first ADC sample",
    "Waiting for second ADC sample"
};

Referenced by showHipInfo().

hipSpiCfg

SPIConfig hipSpiCfg

static

Initial value:

= {
    .circular = false,
#ifdef _CHIBIOS_RT_CONF_VER_6_1_
    .end_cb = NULL,
#else
    .slave = false,
    .data_cb = NULL,
    .error_cb = NULL,
#endif
    .ssport = NULL,
    .sspad = 0,
    .cr1 =
        SPI_CR1_8BIT_MODE |
        SPI_CR1_MSTR |
        SPI_CR1_CPHA |
        
        SPI_CR1_BR_0 | SPI_CR1_BR_1 | SPI_CR1_BR_2,
    .cr2 =
        SPI_CR2_8BIT_MODE
}

Definition at line 97 of file hip9011.cpp.

                             {
    .circular = false,
#ifdef _CHIBIOS_RT_CONF_VER_6_1_
    .end_cb = NULL,
#else
    .slave = false,
    .data_cb = NULL,
    .error_cb = NULL,
#endif
    .ssport = NULL,
    .sspad = 0,
    .cr1 =
        SPI_CR1_8BIT_MODE |
        SPI_CR1_MSTR |
        SPI_CR1_CPHA |
        //SPI_CR1_BR_1 // 5MHz
        SPI_CR1_BR_0 | SPI_CR1_BR_1 | SPI_CR1_BR_2,
    .cr2 =
        SPI_CR2_8BIT_MODE
};

Referenced by startHip9011_pins(), and stopHip9011_pins().

intHold

NamedOutputPin intHold(PROTOCOL_HIP_NAME) ( PROTOCOL_HIP_NAME  )

static

Referenced by endIntegration(), startHip9011_pins(), startIntegration(), and stopHip9011_pins().

normalizedValue

float normalizedValue[HIP_INPUT_CHANNELS]

static

Definition at line 86 of file hip9011.cpp.

Referenced by hipThread(), and showHipInfo().

normalizedValueMax

float normalizedValueMax[HIP_INPUT_CHANNELS]

static

Definition at line 87 of file hip9011.cpp.

Referenced by hipThread(), and showHipInfo().

spi

SPIDriver* spi

static

Definition at line 95 of file hip9011.cpp.

Referenced by hipThread(), initPotentiometer(), nm_bus_init(), spi_lld_master_callback(), spi_lld_slave_callback(), startHip9011_pins(), and stopHip9011_pins().

wake

semaphore_t wake

static

Definition at line 79 of file hip9011.cpp.

Referenced by hip_wake_driver(), hipThread(), and initHip9011().

Go to the source code of this file.