tunerstudio.cpp File Reference

Detailed Description

Binary protocol implementation.

This implementation would not happen without the documentation provided by Jon Zeeff (jon@z.nosp@m.eeff.nosp@m..com)

Integration with EFI Analytics Tuner Studio software

Tuner Studio has a really simple protocol, a minimal implementation capable of displaying current engine state on the gauges would require only two commands: queryCommand and ochGetCommand

queryCommand: Communication initialization command. TunerStudio sends a single byte H ECU response: One of the known ECU id strings.

ochGetCommand: Request for output channels state.TunerStudio sends a single byte O ECU response: A snapshot of output channels as described in [OutputChannels] section of the .ini file The length of this block is 'ochBlockSize' property of the .ini file

These two commands are enough to get working gauges. In order to start configuring the ECU using tuner studio, three more commands should be implemented:

See also https://www.efianalytics.com/TunerStudio/docs/EFI%20Analytics%20ECU%20Definition%20files.pdf

Date

Oct 22, 2013

Author

Andrey Belomutskiy, (c) 2012-2020

This file is part of rusEfi - see http://rusefi.com

rusEfi 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 3 of the License, or (at your option) any later version.

rusEfi 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 this program. If not, see http://www.gnu.org/licenses/.

This file is part of rusEfi - see http://rusefi.com

rusEfi 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 3 of the License, or (at your option) any later version.

rusEfi 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 this program. If not, see http://www.gnu.org/licenses/.

Definition in file tunerstudio.cpp.

Functions
static void	printErrorCounters ()
static void	printScatterList (TsChannelBase *tsChannel)
static void	resetTs ()
static void	printTsStats (void)
static void	setTsSpeed (int value)
void	tunerStudioDebug (TsChannelBase *tsChannel, const char *msg)
static uint8_t *	getWorkingPageAddr (TsChannelBase *tsChannel, size_t page, size_t offset)
static constexpr size_t	getTunerStudioPageSize (size_t page)
static bool	validateOffsetCount (size_t page, size_t offset, size_t count, TsChannelBase *tsChannel)
static void	sendOkResponse (TsChannelBase *tsChannel)
void	sendErrorCode (TsChannelBase *tsChannel, uint8_t code, const char *msg)
PUBLIC_API_WEAK bool	isBoardAskingTriggerTsRefresh ()
bool	needToTriggerTsRefresh ()
void	onApplyPreset ()
PUBLIC_API_WEAK bool	isTouchingVe (uint16_t offset, uint16_t count)
static void	onCalibrationWrite (uint16_t page, uint16_t offset, uint16_t count)
bool	isTouchingArea (uint16_t offset, uint16_t count, int areaStart, int areaSize)
void	requestBurn ()
static void	handleBurnCommand (TsChannelBase *tsChannel, uint16_t page)
static bool	isKnownCommand (char command)
static void	handleTestCommand (TsChannelBase *tsChannel)
static void	handleGetConfigErorr (TsChannelBase *tsChannel)
static int	tsProcessOne (TsChannelBase *tsChannel)
void	tunerStudioError (TsChannelBase *tsChannel, const char *msg)
static void	handleGetVersion (TsChannelBase *tsChannel)
static void	handleGetText (TsChannelBase *tsChannel)
bool	isTuningVeNow ()
void	startTunerStudioConnectivity ()

Variables
uint8_t	ts_blank_page_placeholder [256]
TunerStudio	tsInstance
tunerstudio_counters_s	tsState
CommandHandler	console_line_callback

Function Documentation

getTunerStudioPageSize()

static constexpr size_t getTunerStudioPageSize ( size_t  page )

staticconstexpr

Definition at line 195 of file tunerstudio.cpp.

                                                            {
    switch (page) {
    case TS_PAGE_SETTINGS:
        return TOTAL_CONFIG_SIZE;
#if EFI_TS_SCATTER
    case TS_PAGE_SCATTER_OFFSETS:
        return PAGE_SIZE_1;
#else
    case TS_PAGE_SCATTER_OFFSETS:
        // min read from TS seems to be 256b?
        return 256;
#endif
#if EFI_LTFT_CONTROL
    case TS_PAGE_LTFT_TRIMS:
        return ltftGetTsPageSize();
#endif
    default:
        return 0;
    }
}

Referenced by validateOffsetCount().

Here is the call graph for this function:

Here is the caller graph for this function:

getWorkingPageAddr()

static uint8_t * getWorkingPageAddr ( TsChannelBase *  tsChannel, size_t  page, size_t  offset  )

static

Definition at line 171 of file tunerstudio.cpp.

                                                                                         {
    // TODO: validate offset?
    switch (page) {
    case TS_PAGE_SETTINGS:
        // TODO: why engineConfiguration, not config
        // TS has access to whole persistent_config_s
        return (uint8_t*)engineConfiguration + offset;
#if EFI_TS_SCATTER
    case TS_PAGE_SCATTER_OFFSETS:
        return (uint8_t *)tsChannel->page1.highSpeedOffsets + offset;
#else
    case TS_PAGE_SCATTER_OFFSETS:
        return (uint8_t *)&ts_blank_page_placeholder;
#endif
#if EFI_LTFT_CONTROL
    case TS_PAGE_LTFT_TRIMS:
        return (uint8_t *)ltftGetTsPage() + offset;
#endif
    default:
        tunerStudioError(tsChannel, "ERROR: page address out of range");
        return nullptr;
    }
}

Referenced by TunerStudio::handleCrc32Check(), TunerStudio::handlePageReadCommand(), and TunerStudio::handleWriteChunkCommand().

Here is the call graph for this function:

Here is the caller graph for this function:

handleBurnCommand()

static void handleBurnCommand ( TsChannelBase *  tsChannel, uint16_t  page  )

static

'Burn' command is a command to commit the changes

Definition at line 471 of file tunerstudio.cpp.

                                                                       {
    if (page == TS_PAGE_SETTINGS) {
        Timer t;
        t.reset();
 
        tsState.burnCommandCounter++;
 
        efiPrintf("TS -> Burn");
        validateConfigOnStartUpOrBurn(true);
 
        // problem: 'popular vehicles' dialog has 'Burn' which is very NOT helpful on that dialog
        // since users often click both buttons producing a conflict between ECU desire to change settings
        // and TS desire to send TS calibration snapshot into ECU
        // Skip the burn if a preset was just loaded - we don't want to overwrite it
        // [tag:popular_vehicle]
        if (!needToTriggerTsRefresh()) {
            efiPrintf("TS -> Burn, we are allowed to burn");
            requestBurn();
        }
        efiPrintf("Burned in %.1fms", t.getElapsedSeconds() * 1e3);
    } else if (page == TS_PAGE_SCATTER_OFFSETS) {
        /* do nothing */
    } else {
        sendErrorCode(tsChannel, TS_RESPONSE_OUT_OF_RANGE, "ERROR: Burn invalid page");
        return;
    }
 
    tsChannel->writeCrcResponse(TS_RESPONSE_BURN_OK);
}

Referenced by TunerStudio::handleCrcCommand().

Here is the call graph for this function:

Here is the caller graph for this function:

handleGetConfigErorr()

static void handleGetConfigErorr ( TsChannelBase *  tsChannel )

static

Definition at line 555 of file tunerstudio.cpp.

                                                           {
    const char* errorMessage = hasFirmwareError() ? getCriticalErrorMessage() : getConfigErrorMessage();
    if (strlen(errorMessage) == 0) {
        // Check for engine's warning code
        errorMessage = engine->engineState.warnings.getWarningMessage();
    }
    tsChannel->sendResponse(TS_CRC, reinterpret_cast<const uint8_t*>(errorMessage), strlen(errorMessage), true);
}

Referenced by TunerStudio::handleCrcCommand().

Here is the call graph for this function:

Here is the caller graph for this function:

handleGetText()

static void handleGetText ( TsChannelBase *  tsChannel )

static

Definition at line 787 of file tunerstudio.cpp.

                                                    {
    tsState.textCommandCounter++;
 
    printOverallStatus();
 
    size_t outputSize;
    const char* output = swapOutputBuffers(&outputSize);
#if EFI_SIMULATOR
    logMsg("get test sending [%d]\r\n", outputSize);
#endif
 
    tsChannel->writeCrcPacket(TS_RESPONSE_OK, reinterpret_cast<const uint8_t*>(output), outputSize, true);
#if EFI_SIMULATOR
    logMsg("sent [%d]\r\n", outputSize);
#endif // EFI_SIMULATOR
}

Referenced by TunerStudio::handleCrcCommand().

Here is the call graph for this function:

Here is the caller graph for this function:

handleGetVersion()

static void handleGetVersion ( TsChannelBase *  tsChannel )

static

Definition at line 780 of file tunerstudio.cpp.

                                                       {
    char versionBuffer[32];
    chsnprintf(versionBuffer, sizeof(versionBuffer), "%s v%d@%u", FRONTEND_TITLE_BAR_NAME, getRusEfiVersion(), SIGNATURE_HASH);
    tsChannel->sendResponse(TS_CRC, (const uint8_t *) versionBuffer, strlen(versionBuffer) + 1);
}

Referenced by TunerStudio::handleCrcCommand().

Here is the call graph for this function:

Here is the caller graph for this function:

handleTestCommand()

static void handleTestCommand ( TsChannelBase *  tsChannel )

static

rusEfi own test command

this is NOT a standard TunerStudio command, this is my own extension of the protocol to simplify troubleshooting

Definition at line 528 of file tunerstudio.cpp.

                                                        {
    tsState.testCommandCounter++;
    char testOutputBuffer[64];
    /**
     * this is NOT a standard TunerStudio command, this is my own
     * extension of the protocol to simplify troubleshooting
     */
    tunerStudioDebug(tsChannel, "got T (Test)");
    tsChannel->write((const uint8_t*)QUOTE(SIGNATURE_HASH), sizeof(QUOTE(SIGNATURE_HASH)));
 
    chsnprintf(testOutputBuffer, sizeof(testOutputBuffer), " %d %d", engine->engineState.warnings.lastErrorCode, tsState.testCommandCounter);
    tsChannel->write((const uint8_t*)testOutputBuffer, strlen(testOutputBuffer));
 
    chsnprintf(testOutputBuffer, sizeof(testOutputBuffer), " uptime=%ds ", (int)getTimeNowS());
    tsChannel->write((const uint8_t*)testOutputBuffer, strlen(testOutputBuffer));
 
    chsnprintf(testOutputBuffer, sizeof(testOutputBuffer), __DATE__ " %s\r\n", PROTOCOL_TEST_RESPONSE_TAG);
    tsChannel->write((const uint8_t*)testOutputBuffer, strlen(testOutputBuffer));
 
    if (hasFirmwareError()) {
        const char* error = getCriticalErrorMessage();
        chsnprintf(testOutputBuffer, sizeof(testOutputBuffer), "error=%s\r\n", error);
        tsChannel->write((const uint8_t*)testOutputBuffer, strlen(testOutputBuffer));
    }
    tsChannel->flush();
}

Referenced by TunerStudio::handleCrcCommand(), and TunerStudio::handlePlainCommand().

Here is the call graph for this function:

Here is the caller graph for this function:

isBoardAskingTriggerTsRefresh()

PUBLIC_API_WEAK bool isBoardAskingTriggerTsRefresh

(

)

Definition at line 269 of file tunerstudio.cpp.

                                                     {
    return false;
}

isKnownCommand()

static bool isKnownCommand ( char  command )

static

Definition at line 503 of file tunerstudio.cpp.

                                         {
    return command == TS_HELLO_COMMAND || command == TS_READ_COMMAND || command == TS_OUTPUT_COMMAND
            || command == TS_BURN_COMMAND
            || command == TS_CHUNK_WRITE_COMMAND || command == TS_EXECUTE
            || command == TS_IO_TEST_COMMAND
#if EFI_SIMULATOR
            || command == TS_SIMULATE_CAN
#endif // EFI_SIMULATOR
#if EFI_TS_SCATTER
            || command == TS_GET_SCATTERED_GET_COMMAND
#endif
            || command == TS_SET_LOGGER_SWITCH
            || command == TS_GET_COMPOSITE_BUFFER_DONE_DIFFERENTLY
            || command == TS_GET_TEXT
            || command == TS_CRC_CHECK_COMMAND
            || command == TS_GET_FIRMWARE_VERSION
            || command == TS_PERF_TRACE_BEGIN
            || command == TS_PERF_TRACE_GET_BUFFER
            || command == TS_GET_CONFIG_ERROR
            || command == TS_QUERY_BOOTLOADER;
}

Referenced by tsProcessOne().

Here is the caller graph for this function:

isTouchingArea()

bool isTouchingArea	(	uint16_t	offset,
		uint16_t	count,
		int	areaStart,
		int	areaSize
	)

Definition at line 291 of file tunerstudio.cpp.

                                                                                  {
  if (offset + count < areaStart) {
    // we are touching below for instance VE table
    return false;
  }
  if (offset > areaStart + areaSize) {
    // we are touching after for instance VE table
    return false;
  }
  // else - we are touching it!
  return true;
}

Referenced by isTouchingVe().

Here is the caller graph for this function:

isTouchingVe()

PUBLIC_API_WEAK bool isTouchingVe	(	uint16_t	offset,
		uint16_t	count
	)

Definition at line 281 of file tunerstudio.cpp.

                                                                   {
  return isTouchingArea(offset, count, offsetof(persistent_config_s, veTable), sizeof(config->veTable));
}

Referenced by onCalibrationWrite().

Here is the call graph for this function:

Here is the caller graph for this function:

isTuningVeNow()

bool isTuningVeNow

(

)

Definition at line 1044 of file tunerstudio.cpp.

                     {
  int tuningDetector = engineConfiguration->isTuningDetectorEnabled ? 0 : 20;
    return !calibrationsVeWriteTimer.hasElapsedSec(tuningDetector);
}

Referenced by checkIfTuningVeNow(), and TpsAccelEnrichment::getTpsEnrichment().

Here is the caller graph for this function:

needToTriggerTsRefresh()

bool needToTriggerTsRefresh

(

)

Definition at line 273 of file tunerstudio.cpp.

                              {
    return !engine->engineTypeChangeTimer.hasElapsedSec(1);
}

Referenced by handleBurnCommand(), TunerStudio::handleWriteChunkCommand(), and updateTunerStudioState().

Here is the caller graph for this function:

onApplyPreset()

void onApplyPreset

(

)

Definition at line 277 of file tunerstudio.cpp.

                     {
    engine->engineTypeChangeTimer.reset();
}

Referenced by applyPreset(), handleCommandX14(), and vinStrategy().

Here is the caller graph for this function:

onCalibrationWrite()

static void onCalibrationWrite ( uint16_t  page, uint16_t  offset, uint16_t  count  )

static

Definition at line 285 of file tunerstudio.cpp.

                                                                               {
    if ((page == TS_PAGE_SETTINGS) && isTouchingVe(offset, count)) {
        calibrationsVeWriteTimer.reset();
    }
}

Referenced by TunerStudio::handleWriteChunkCommand().

Here is the call graph for this function:

Here is the caller graph for this function:

printErrorCounters()

static void printErrorCounters ( )

static

Definition at line 99 of file tunerstudio.cpp.

                                 {
    efiPrintf("TunerStudio size=%d / total=%d / errors=%d / H=%d / O=%d / P=%d / B=%d / 9=%d",
            sizeof(engine->outputChannels), tsState.totalCounter, tsState.errorCounter, tsState.queryCommandCounter,
            tsState.outputChannelsCommandCounter, tsState.readPageCommandsCounter, tsState.burnCommandCounter,
            tsState.readScatterCommandsCounter);
    efiPrintf("TunerStudio C=%d",
            tsState.writeChunkCommandCounter);
    efiPrintf("TunerStudio errors: underrun=%d / overrun=%d / crc=%d / unrecognized=%d / outofrange=%d / other=%d",
            tsState.errorUnderrunCounter, tsState.errorOverrunCounter, tsState.errorCrcCounter,
            tsState.errorUnrecognizedCommand, tsState.errorOutOfRange, tsState.errorOther);
}

Referenced by printTsStats(), and tunerStudioError().

Here is the caller graph for this function:

printScatterList()

static void printScatterList ( TsChannelBase *  tsChannel )

static

Definition at line 116 of file tunerstudio.cpp.

                                                       {
    efiPrintf("Scatter list (global)");
    for (size_t i = 0; i < TS_SCATTER_OFFSETS_COUNT; i++) {
        uint16_t packed = tsChannel->highSpeedOffsets[i];
        uint16_t type = packed >> 13;
        uint16_t offset = packed & 0x1FFF;
 
        if (type == 0)
            continue;
        size_t size = 1 << (type - 1);
 
        efiPrintf("%02d offset 0x%04x size %d", i, offset, size);
    }
}

printTsStats()

static void printTsStats ( void  )

static

Definition at line 141 of file tunerstudio.cpp.

                               {
#ifdef EFI_CONSOLE_RX_BRAIN_PIN
    efiPrintf("Primary UART RX %s", hwPortname(EFI_CONSOLE_RX_BRAIN_PIN));
    efiPrintf("Primary UART TX %s", hwPortname(EFI_CONSOLE_TX_BRAIN_PIN));
#endif /* EFI_CONSOLE_RX_BRAIN_PIN */
 
#if EFI_USB_SERIAL
    printUsbConnectorStats();
#endif // EFI_USB_SERIAL
 
    printErrorCounters();
 
    // TODO: find way to get all tsChannel
    //printScatterList();
}

Referenced by setTsSpeed(), and startTunerStudioConnectivity().

Here is the call graph for this function:

Here is the caller graph for this function:

requestBurn()

void requestBurn

(

)

Definition at line 457 of file tunerstudio.cpp.

                   {
#if !EFI_UNIT_TEST
    onBurnRequest();
 
#if EFI_CONFIGURATION_STORAGE
    setNeedToWriteConfiguration();
#endif /* EFI_CONFIGURATION_STORAGE */
#endif // !EFI_UNIT_TEST
}

Referenced by configureRusefiLuaHooks(), handleBurnCommand(), initFlash(), and unlockEcu().

Here is the call graph for this function:

Here is the caller graph for this function:

resetTs()

static void resetTs ( )

static

Definition at line 137 of file tunerstudio.cpp.

                      {
    memset(&tsState, 0, sizeof(tsState));
}

Referenced by startTunerStudioConnectivity().

Here is the caller graph for this function:

sendErrorCode()

void sendErrorCode	(	TsChannelBase *	tsChannel,
		uint8_t	code,
		const char *	msg
	)

Definition at line 234 of file tunerstudio.cpp.

                                                                            {
    //TODO uncomment once I have test it myself
    UNUSED(msg);
    //if (msg != DO_NOT_LOG) {
    //  efiPrintf("TS <- Err: %d [%s]", code, msg);
    //}
 
    switch (code) {
    case TS_RESPONSE_UNDERRUN:
        tsState.errorUnderrunCounter++;
        break;
    case TS_RESPONSE_OVERRUN:
        tsState.errorOverrunCounter++;
        break;
    case TS_RESPONSE_CRC_FAILURE:
        tsState.errorCrcCounter++;
        break;
    case TS_RESPONSE_UNRECOGNIZED_COMMAND:
        tsState.errorUnrecognizedCommand++;
        break;
    case TS_RESPONSE_OUT_OF_RANGE:
        tsState.errorOutOfRange++;
        break;
    default:
        tsState.errorOther++;
        break;
    }
 
    tsChannel->writeCrcResponse(code);
}

Referenced by handleBurnCommand(), tsProcessOne(), and validateOffsetCount().

Here is the call graph for this function:

Here is the caller graph for this function:

sendOkResponse()

static void sendOkResponse ( TsChannelBase *  tsChannel )

static

Definition at line 230 of file tunerstudio.cpp.

                                                     {
    tsChannel->sendResponse(TS_CRC, nullptr, 0);
}

Referenced by TunerStudio::handleCrcCommand(), and TunerStudio::handleWriteChunkCommand().

Here is the call graph for this function:

Here is the caller graph for this function:

setTsSpeed()

static void setTsSpeed ( int  value )

static

Definition at line 157 of file tunerstudio.cpp.

                                  {
    engineConfiguration->tunerStudioSerialSpeed = value;
    printTsStats();
}

Referenced by startTunerStudioConnectivity().

Here is the call graph for this function:

Here is the caller graph for this function:

startTunerStudioConnectivity()

void startTunerStudioConnectivity

(

)

Definition at line 1049 of file tunerstudio.cpp.

                                    {
    // Assert tune & output channel struct sizes
    static_assert(sizeof(persistent_config_s) == TOTAL_CONFIG_SIZE, "TS datapage size mismatch");
    // useful trick if you need to know how far off is the static_assert
    //char (*__kaboom)[sizeof(persistent_config_s)] = 1;
    // another useful trick
    //static_assert(offsetof (engine_configuration_s,HD44780_e) == 700);
 
    memset(&tsState, 0, sizeof(tsState));
 
    addConsoleAction("tsinfo", printTsStats);
    addConsoleAction("reset_ts", resetTs);
    addConsoleActionI("set_ts_speed", setTsSpeed);
 
#if EFI_BLUETOOTH_SETUP
    // module initialization start (it waits for disconnect and then communicates to the module)
    // Usage:   "bluetooth_hc06 <baud> <name> <pincode>"
    // Example: "bluetooth_hc06 38400 rusefi 1234"
    // bluetooth_jdy 115200 alphax 1234
    addConsoleActionSSS("bluetooth_hc05", [](const char *baudRate, const char *name, const char *pinCode) {
        bluetoothStart(BLUETOOTH_HC_05, baudRate, name, pinCode);
    });
    addConsoleActionSSS("bluetooth_hc06", [](const char *baudRate, const char *name, const char *pinCode) {
        bluetoothStart(BLUETOOTH_HC_06, baudRate, name, pinCode);
    });
    addConsoleActionSSS("bluetooth_bk", [](const char *baudRate, const char *name, const char *pinCode) {
        bluetoothStart(BLUETOOTH_BK3231, baudRate, name, pinCode);
    });
    addConsoleActionSSS("bluetooth_jdy", [](const char *baudRate, const char *name, const char *pinCode) {
        bluetoothStart(BLUETOOTH_JDY_3x, baudRate, name, pinCode);
    });
    addConsoleActionSSS("bluetooth_jdy31", [](const char *baudRate, const char *name, const char *pinCode) {
        bluetoothStart(BLUETOOTH_JDY_31, baudRate, name, pinCode);
    });
#endif /* EFI_BLUETOOTH_SETUP */
}

Referenced by runRusEfi().

Here is the call graph for this function:

Here is the caller graph for this function:

tsProcessOne()

static int tsProcessOne ( TsChannelBase *  tsChannel )

static

Definition at line 615 of file tunerstudio.cpp.

                                                  {
    assertStack("communication", ObdCode::STACK_USAGE_COMMUNICATION, EXPECTED_REMAINING_STACK, -1);
 
    if (!tsChannel->isReady()) {
        chThdSleepMilliseconds(10);
        return -1;
    }
 
    tsState.totalCounter++;
 
    uint8_t firstByte;
    size_t received = tsChannel->readTimeout(&firstByte, 1, TS_COMMUNICATION_TIMEOUT);
#if EFI_SIMULATOR
    logMsg("received %d\r\n", received);
#endif // EFI_SIMULATOR
 
    if (received != 1) {
        //tunerStudioError("ERROR: no command");
#if EFI_BLUETOOTH_SETUP
        if (tsChannel == getBluetoothChannel()) {
            // no data in a whole second means time to disconnect BT
            // assume there's connection loss and notify the bluetooth init code
            bluetoothSoftwareDisconnectNotify(getBluetoothChannel());
        }
#endif /* EFI_BLUETOOTH_SETUP */
        tsChannel->in_sync = false;
        return -1;
    }
 
    if (tsInstance.handlePlainCommand(tsChannel, firstByte)) {
        return 0;
    }
 
    uint8_t secondByte;
    /* second byte should be received within minimal delay */
    received = tsChannel->readTimeout(&secondByte, 1, TS_COMMUNICATION_TIMEOUT_SHORT);
    if (received != 1) {
        tunerStudioError(tsChannel, "TS: ERROR: no second byte");
        tsChannel->in_sync = false;
        return -1;
    }
 
    uint16_t incomingPacketSize = firstByte << 8 | secondByte;
    size_t expectedSize = incomingPacketSize + TS_PACKET_TAIL_SIZE;
 
    if ((incomingPacketSize == 0) || (expectedSize > sizeof(tsChannel->scratchBuffer))) {
        if (tsChannel->in_sync) {
            efiPrintf("process_ts: channel=%s invalid size: %d", tsChannel->name, incomingPacketSize);
            tunerStudioError(tsChannel, "process_ts: ERROR: packet size");
            /* send error only if previously we were in sync */
            sendErrorCode(tsChannel, TS_RESPONSE_OUT_OF_RANGE, "invalid size");
        }
        tsChannel->in_sync = false;
        return -1;
    }
 
    char command;
    if (tsChannel->in_sync) {
        /* we are in sync state, packet size should be correct so lets receive full packet and then check if command is supported
         * otherwise (if abort reception in middle of packet) it will break synchronization and cause error on next packet */
        received = tsChannel->readTimeout((uint8_t*)(tsChannel->scratchBuffer), expectedSize, TS_COMMUNICATION_TIMEOUT);
        command = tsChannel->scratchBuffer[0];
 
        if (received != expectedSize) {
            /* print and send error as we were in sync */
            efiPrintf("Got only %d bytes while expecting %d for command 0x%02x", received,
                    expectedSize, command);
            tunerStudioError(tsChannel, "ERROR: not enough bytes in stream");
            // MS serial protocol spec: There was a timeout before all data was received. (25ms per character.)
            sendErrorCode(tsChannel, TS_RESPONSE_UNDERRUN, "underrun");
            tsChannel->in_sync = false;
            return -1;
        }
 
        if (!isKnownCommand(command)) {
            /* print and send error as we were in sync */
            efiPrintf("unexpected command %x", command);
            sendErrorCode(tsChannel, TS_RESPONSE_UNRECOGNIZED_COMMAND, "unknown");
            tsChannel->in_sync = false;
            return -1;
        }
    } else {
        /* receive only command byte to check if it is supported */
        received = tsChannel->readTimeout((uint8_t*)(tsChannel->scratchBuffer), 1, TS_COMMUNICATION_TIMEOUT_SHORT);
        command = tsChannel->scratchBuffer[0];
 
        if (!isKnownCommand(command)) {
            /* do not report any error as we are not in sync */
            return -1;
        }
 
        received = tsChannel->readTimeout((uint8_t*)(tsChannel->scratchBuffer) + 1, expectedSize - 1, TS_COMMUNICATION_TIMEOUT);
        if (received != expectedSize - 1) {
            /* do not report any error as we are not in sync */
            return -1;
        }
    }
 
#if EFI_SIMULATOR
    logMsg("command %c\r\n", command);
#endif
 
    uint32_t expectedCrc = *(uint32_t*) (tsChannel->scratchBuffer + incomingPacketSize);
 
    expectedCrc = SWAP_UINT32(expectedCrc);
 
    uint32_t actualCrc = crc32(tsChannel->scratchBuffer, incomingPacketSize);
    if (actualCrc != expectedCrc) {
        /* send error only if previously we were in sync */
        if (tsChannel->in_sync) {
            efiPrintf("TunerStudio: command %c actual CRC %x/expected %x", tsChannel->scratchBuffer[0],
                    (unsigned int)actualCrc, (unsigned int)expectedCrc);
            tunerStudioError(tsChannel, "ERROR: CRC issue");
            sendErrorCode(tsChannel, TS_RESPONSE_CRC_FAILURE, "crc_issue");
            tsChannel->in_sync = false;
        }
        return -1;
    }
 
    /* we were able to receive known command with correct crc and size! */
    tsChannel->in_sync = true;
 
    int success = tsInstance.handleCrcCommand(tsChannel, tsChannel->scratchBuffer, incomingPacketSize);
 
    if (!success) {
        efiPrintf("got unexpected TunerStudio command %x:%c", command, command);
        return -1;
    }
 
    return 0;
}

Referenced by TunerstudioThread::ThreadTask().

Here is the call graph for this function:

Here is the caller graph for this function:

tunerStudioDebug()

void tunerStudioDebug	(	TsChannelBase *	tsChannel,
		const char *	msg
	)

Definition at line 162 of file tunerstudio.cpp.

                                                                 {
#if EFI_TUNER_STUDIO_VERBOSE
    efiPrintf("%s: %s", tsChannel->name, msg);
#endif /* EFI_TUNER_STUDIO_VERBOSE */
}

Referenced by TunerStudio::handlePlainCommand(), handleTestCommand(), and tunerStudioError().

Here is the caller graph for this function:

tunerStudioError()

void tunerStudioError	(	TsChannelBase *	tsChannel,
		const char *	msg
	)

Definition at line 768 of file tunerstudio.cpp.

                                                                 {
    tunerStudioDebug(tsChannel, msg);
    printErrorCounters();
    tsState.errorCounter++;
}

Referenced by getWorkingPageAddr(), TunerStudio::handleCrc32Check(), TunerStudio::handleCrcCommand(), TunerStudio::handlePageReadCommand(), TunerStudio::handleWriteChunkCommand(), tsProcessOne(), and validateOffsetCount().

Here is the call graph for this function:

Here is the caller graph for this function:

validateOffsetCount()

static bool validateOffsetCount ( size_t  page, size_t  offset, size_t  count, TsChannelBase *  tsChannel  )

static

Definition at line 218 of file tunerstudio.cpp.

                                                                                                    {
    size_t allowedSize = getTunerStudioPageSize(page);
    if (offset + count > allowedSize) {
        efiPrintf("TS: Project mismatch? Too much configuration requested %d+%d>%d", offset, count, allowedSize);
        tunerStudioError(tsChannel, "ERROR: out of range");
        sendErrorCode(tsChannel, TS_RESPONSE_OUT_OF_RANGE, "bad_offset");
        return true;
    }
 
    return false;
}

Referenced by TunerStudio::handleCrc32Check(), TunerStudio::handlePageReadCommand(), and TunerStudio::handleWriteChunkCommand().

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

console_line_callback

CommandHandler console_line_callback

extern

Definition at line 53 of file console_io.cpp.

Referenced by TunerStudio::handleExecuteCommand(), and startConsole().

ts_blank_page_placeholder

uint8_t ts_blank_page_placeholder[256]

Definition at line 169 of file tunerstudio.cpp.

Referenced by getWorkingPageAddr().

tsInstance

TunerStudio tsInstance

Definition at line 613 of file tunerstudio.cpp.

Referenced by tsProcessOne().

tsState

tunerstudio_counters_s tsState

Definition at line 766 of file tunerstudio.cpp.

Referenced by TunerStudio::cmdOutputChannels(), handleBurnCommand(), TunerStudio::handleCrc32Check(), handleGetText(), TunerStudio::handlePageReadCommand(), TunerStudio::handleQueryCommand(), TunerStudio::handleScatteredReadCommand(), handleTestCommand(), TunerStudio::handleWriteChunkCommand(), printErrorCounters(), resetTs(), sendErrorCode(), startTunerStudioConnectivity(), tsProcessOne(), and tunerStudioError().

Go to the source code of this file.