mediatek.cpp

DVD

// **********************************************************************
//  This file is a part of MaBreakers
//  MTK RS232 Communication package
// **********************************************************************
//
//  Copyright (C) 2006 MaBreaker
//
//  This program 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.
//
//  This program 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, write to the Free Software
//  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
//  02110-1301, USA.
//
// **********************************************************************

#define STRICT

#include <stdio.h>
#include <time.h>

#include "Mediatek.h"
#include "ComMain.h"
#include "Print.h"
//#include "Init.h"

// **********************************************************************
//TMediatek *Mediatek;
// **********************************************************************

//---------------------------------------------------------------------------
// MEDIATEK ERROR VALUES
//---------------------------------------------------------------------------

// 2000 - Com port
#define MEDIATEK_ERROR_ALLOCATE         -2

// 2010 - Com port
#define MEDIATEK_ERROR_COM              -10
#define MEDIATEK_ERROR_COM_OPEN         -11
#define MEDIATEK_ERROR_COM_CLOSE        -12
#define MEDIATEK_ERROR_COM_SEND         -13
#define MEDIATEK_ERROR_COM_READ         -14
#define MEDIATEK_ERROR_COM_IO           -15 // No aswer from player

// 2020 - Memory dump
#define MEDIATEK_ERROR_DUMP             -20
#define MEDIATEK_ERROR_DUMP_ADDRESS     -21
#define MEDIATEK_ERROR_DUMP_LENGTH      -22
#define MEDIATEK_ERROR_DUMP_SIZE        -23

//---------------------------------------------------------------------------
// Send Serial Command type
//---------------------------------------------------------------------------

enum
{
    SEND_BOOT,
    SEND_START,
    SEND_STOP,
    SEND_TEST,
    SEND_INIT_END,
    SEND_INIT_TOP,
    SEND_INIT_BOTTOM,
    SEND_LOG_ON,
    SEND_LOG_OFF,
    SEND_NOP,
    SEND_CHIP,
    SEND_FLASH,
    SEND_BACKUP
};

//---------------------------------------------------------------------------
// MEDIATEK RS-232 DUMP Common
//---------------------------------------------------------------------------

#define BOOT_NORMAL         0x13
#define BOOT_FLASH          0x10

#define DUMP_PARSER         0x50

#define MTK_LOG             0xFF
#define LOG_OFF               0xF0
#define LOG_ON                0xF1

//---------------------------------------------------------------------------
// MEDIATEK RS-232 DUMP Read Command MT13x9 Code
//---------------------------------------------------------------------------

#define READ_XDATA          0x00
#define READ_SRV_TYPE_1     0x01
#define READ_SRV_TYPE_2     0x02
#define READ_IDATA          0x03
#define READ_RISC_REG       0x04
#define READ_RISC_RAM       0x05
#define READ_DRAM_BYTE      0x08
#define READ_DRAM_LONG      0x09
#define SERVO_DEBUG_CMD     0x0A
#define READ_SHARE_MEM      0x0B
#define NOT_USED_1          0x0C
#define READ_SRV_TYPE_0     0x0D
#define READ_SERIAL_CMD     0x0E
#define READ_PPSEL_WORD     0x0F
#define READ_PPSEL_LO       0x10
#define READ_PPSEL_HI       0x11
#define STOP_SERVO          0x12
#define READ_EEPROM         0x13
#define READ_I2C            0x14

//---------------------------------------------------------------------------
// MEDIATEK RS-232 DUMP Write Command MT13x9 Code
//---------------------------------------------------------------------------

#define WRITE_XDATA         0x80
#define WRITE_SRV_TYPE_1    0x81
#define WRITE_SRV_TYPE_2    0x82
#define WRITE_IDATA         0x83
#define WRITE_RISC_REG      0x84
#define WRITE_RISC_RAM      0x85
#define WRITE_DRAM_BYTE     0x88
#define WRITE_DRAM_LONG     0x89
#define WRITE_SRV_TYPE_0    0x8D
#define WRITE_SERIAL_CMD    0x8E
#define WRITE_PPSEL_HI      0x8F
#define INPUT_A_CHARACTER   0x90
#define WRITE_EEPROM        0x93
#define WRITE_I2C           0x94

//---------------------------------------------------------------------------
// MEDIATEK RS-232 MTK Commands
//---------------------------------------------------------------------------

#define MTK_ALIGN           0x20
//#define MTK_???             0x2A

#define MTK_READ            0x90
#define MTK_RESET           0xF0

//---------------------------------------------------------------------------
// Lengths for Memory Dump
// DumpLength[TARGET][CMD,SEND,READ]
//---------------------------------------------------------------------------

const stMemoryCmd MemCommand[TARGET_FLASH] =
{ {0,               0, 0, 0,                0, 0},          //      - NULL
  {READ_XDATA,      2, 1, WRITE_XDATA,      4, 0x10000},    // 0x00 - XDATA 8032
  {READ_IDATA,      1, 1, WRITE_IDATA,      3, 0x80},       // 0x03 - IDATA 8032
  {READ_RISC_RAM,   4, 4, WRITE_RISC_RAM,   9, 0x100000},   // 0x05 - RISC RAM
  {READ_RISC_REG,   4, 4, WRITE_RISC_REG,   9, 0x100000},   // 0x04 - RISC REG
  {READ_DRAM_BYTE,  3, 1, WRITE_DRAM_BYTE,  5, 0x800000},   // 0x08 - DRAM Byte
  {READ_DRAM_LONG,  3, 4, WRITE_DRAM_LONG,  8, 0x800000},   // 0x09 - DRAM Long
  {READ_EEPROM,     3, 1, WRITE_EEPROM,     4, 0x100} };    // 0x13 - Eeprom (Not Yet)

/*
const ulong MemSize[TARGET_FLASH] =
{ {0},          //      - NULL
  {0x10000},    // 0x80 - XDATA 8032
  {0x80},       // 0x83 - IDATA 8032
  {0x100000},   // 0x85 - RISC RAM
  {0x100000},   // 0x84 - RISC REG
  {0x100000},   // 0x88 - DRAM Byte
  {0x100000},   // 0x89 - DRAM Long
  {0x100} };    // 0x93 - Eeprom (Not Yet)


const uchar DumpLength[TARGET_FLASH][3] =
{ {0,               0, 0},      //      - NULL
  {READ_XDATA,      2, 1},      // 0x00 - XDATA 8032
  {READ_IDATA,      1, 1},      // 0x03 - IDATA 8032
  {READ_RISC_RAM,   4, 4},      // 0x05 - RISC RAM
  {READ_RISC_REG,   4, 4},      // 0x04 - RISC REG
  {READ_DRAM_BYTE,  3, 1},      // 0x08 - DRAM Byte
  {READ_DRAM_LONG,  3, 4},      // 0x09 - DRAM Long
  {READ_EEPROM,     3, 1} };    // 0x13 - Eeprom (Not Yet)

#define DUMP_CMD    0
#define DUMP_SEND   1
#define DUMP_READ   2

const uchar PatchLength[TARGET_FLASH][2] =
{ {0,               0},         //      - NULL
  {WRITE_XDATA,     4},         // 0x80 - XDATA 8032
  {WRITE_IDATA,     3},         // 0x83 - IDATA 8032
  {WRITE_RISC_RAM,  9},         // 0x85 - RISC RAM
  {WRITE_RISC_REG,  9},         // 0x84 - RISC REG
  {WRITE_DRAM_BYTE, 5},         // 0x88 - DRAM Byte
  {WRITE_DRAM_LONG, 8},         // 0x89 - DRAM Long
  {WRITE_EEPROM,    4} };       // 0x93 - Eeprom (Not Yet)

#define PATCH_CMD   1
#define PATCH_SEND  2
*/

// **********************************************************************
//  THREAD START FUNCTIONS
// **********************************************************************

//---------------------------------------------------------------------------
// READ THREAD CONSTRUCTOR
//---------------------------------------------------------------------------

void StartRead(void *stParam)
{
    int iRet;
    stThreadParam *Tmp = (stThreadParam *) stParam;

    Tmp->This->Error = MEDIATEK_RET_TRUE;

    if(Tmp->bTargetMem == TARGET_FLASH)
    {
        iRet = Tmp->This->ReadFlash(Tmp->ulAddress, *Tmp->ulLength, Tmp->ptrBuffer);
    }
    else
    {
        iRet = Tmp->This->ReadMemory(Tmp->ulAddress, *Tmp->ulLength, Tmp->bTargetMem, Tmp->ptrBuffer);
    }

    Tmp->This->Error = iRet;
}

void StartWrite(void *arg)
{

}

// **********************************************************************
//  PUBLIC FUNCTIONS
// **********************************************************************

//---------------------------------------------------------------------------
// NEW TMediatek
//---------------------------------------------------------------------------

TMediatek::TMediatek(void)
{
    //ComPort->Create();
    if(ComPort == NULL)
        ComPort = new TCom();

    Progress = 0;
    ErrorPrint = true;
    BootMode = BOOT_NORMAL;

  #ifdef _DEBUG
    ComPort->ErrorPrint = true;
  #else
    ComPort->ErrorPrint = false;
  #endif
}

//---------------------------------------------------------------------------
// DELETE TMediatek
//---------------------------------------------------------------------------

TMediatek::~TMediatek(void)
{
    // Stop port
    ComPort->SerialStop();
//    if(ComPort->PortMessage(ComPort->SerialStop()) != COM_ID_SUCCESS)
//      throw;

    //ComPort->Destroy();
    if(ComPort != NULL)
        ComPort = NULL;
    //    delete ComPort;
}

//---------------------------------------------------------------------------
// SET COM PORT PARAMS
//---------------------------------------------------------------------------

int TMediatek::SetComPort(uchar bPort, ulong ulBaud, uchar bData, uchar cParity, uchar bStop)
{
    char sPort[10];

    sprintf(sPort,"COM%i", bPort);
    strcpy(ComPort->sPort, sPort);
    ComPort->ulParamBaud    = ulBaud;
    ComPort->bParamData     = bData;
    ComPort->cParamParity   = cParity;
    ComPort->bParamStop     = bStop;
    return true;
}

//---------------------------------------------------------------------------
// SET COM PORT RETRY VALUES
//---------------------------------------------------------------------------

int TMediatek::SetComRetry(uchar bRetry, uchar bDelay)
{
    ComPort->bRetry = bRetry;
    ComPort->bDelay = bDelay;
    return MEDIATEK_RET_TRUE;
}

//---------------------------------------------------------------------------
// OPEN COM PORT
//---------------------------------------------------------------------------

int TMediatek::ComOpen(uchar bMode)
{
    int iRet;
    int iRetry = 3;

    // Open COM
    iRet = ComPort->SerialStart(bMode);
    if(iRet != COM_ID_SUCCESS)
        return MEDIATEK_ERROR_COM_OPEN;

    while (1)
    {
        // Send Mediatek Com start Byte
        Common(SEND_BOOT);
        Common(SEND_START);
        Sleep(100);

        // Test Communication
        iRet = TestCom();

        // Return success
        if(iRet == MEDIATEK_RET_TRUE)
            return MEDIATEK_RET_TRUE;

        // No more retry
        if(iRetry-- <= 0)
            break;

        // Reset COM
        Common(SEND_STOP);
        if(ComPort->SerialReset() != COM_ID_SUCCESS)
            return MEDIATEK_ERROR_COM_OPEN;
    }

    return iRet;
}

//---------------------------------------------------------------------------
// CLOSE COM PORT
//---------------------------------------------------------------------------

int TMediatek::ComClose(void)
{
    // Send Mediatek Com stop Byte
    Common(SEND_STOP);

    return ComPort->SerialStop();
}

//---------------------------------------------------------------------------
// RESET COM PORT
//---------------------------------------------------------------------------

int TMediatek::ComReset(void)
{
    int iRetry = 3;
    int iRet;

    // Send Mediatek Com stop Byte
    Common(SEND_STOP);

    do
    {
        // Reset COM
        if(ComPort->SerialReset() != COM_ID_SUCCESS)
            return MEDIATEK_ERROR_COM_OPEN;

        // Send Mediatek Com start Byte
        Common(SEND_BOOT);
        Common(SEND_START);
        Sleep(100);

        // Test Communication
        iRet = TestCom();

    } while((iRet != MEDIATEK_RET_TRUE) && (iRetry-- > 0));

    return iRet;
}

//---------------------------------------------------------------------------
// GET MEMORY SIZE