---

jtagpxa250.cpp

Go to the documentation of this file.

/*
 * This file is part of Jelie,
 * (c) 2002 Julien Pilet <julien.pilet@epfl.ch> and
 * Stephane Magnenat <stephane.magnenat@epfl.ch>
 *
 * Jelie 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.
 *
 * Jelie 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 Foobar; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */

#include <stdio.h>
#include <unistd.h> // for sleep() and usleep()
#include "jtagpxa250.h"
#include "filemanager.h"
#include <assert.h>
#include <string.h>
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif

JTAGpxa250 *pxa250Ptr=0;

JTAGpxa250::JTAGpxa250(JTAGControl *jtag) : 
        doPolling(false),
        isTargetReady(false), jtag(jtag)
{
}

void JTAGpxa250::registerTargetReadyCallback(void (*func)(void*), void *arg) {
        Callback cb;
        cb.callback = func;
        cb.arg = arg;
        targetReadyCallback.push_back(cb);
}

void JTAGpxa250::unregisterTargetReadyCallback(void (*func)(void*)) {
        for (std::vector<Callback>::iterator it=targetReadyCallback.begin(); it!=targetReadyCallback.end(); ++it)
        {
                if (it->callback == func)
                {
                        targetReadyCallback.erase(it);
                        return;
                }
        }
}

bool JTAGpxa250::init(int argc, char **argv) {
        currentIREG= JTAG_UNSET;
        doPolling = false;
        return true; // check();
}

bool JTAGpxa250::loadDebugHandler() {
        if (!check())
                return false;

        getReadyForUpload();

        FILE *f = fileManagerPtr->openFP(DEBUG_HANDLER_FILE, "rb");

        if (!f) {
                perror(DEBUG_HANDLER_FILE);
                return false;
        } else {
                bool mini = true;
                unsigned address = 0;
                unsigned int buffer[2*1024];    // 2kbyte buffer (512 instructions)
                int nbi = fread(buffer, 4, 2*1024, f);  // read instructions little endian format
                printf("%d instructions read from " DEBUG_HANDLER_FILE "\n", nbi);

#ifdef WORDS_BIGENDIAN
                for (int i=0; i<nbi;i++) {
                        unsigned char *cp= (unsigned char *) &buffer[i];
                        buffer[i] = JTAGpxa250::charArrayLEToInt(cp);
                }
#endif
                loadIC(mini, address, buffer, nbi);
                boot();
                return true;
        }

}

bool JTAGpxa250::check() {

        unsigned char idcode = JTAG_IDCODE;
        unsigned char data[4]={0,0,0,0};
        unsigned int datareg=0;
        jtag->jtagReset();
        jtag->trst(false);
        ireg(idcode);
        // TODO : fix ugly typecast
        jtag->dreg(data, 32);
        datareg=charArrayLEToInt(data);

        unsigned int jedec = datareg&0xFFF;
        unsigned int pnum = (datareg& 0xFFFF000) >> 12;
        unsigned int version = (datareg& 0xF0000000) >> 28;
        printf("idcode 0x%08x:\n", datareg);

        if (jedec == 0x13) {
                switch (pnum) {
                        case 0x9264: printf("PXA250 ");
                                                 break;
                        case 0x926C: printf("PXA210 ");
                                                 break;
                        default:
                                                 printf("Unknown part numer: %x\n", pnum);
                }
                printf("version %d detected\n", version);
                return (pnum == 0x9264);
        } else {
                printf("unknown JEDEC type !\n");
                return false;
        }
}

unsigned int JTAGpxa250::parity(unsigned char data[]) {
        int nb1=0;

        for (int b=0; b<4; b++) {
                for (int i=0; i<=7; i++) {
                        if ((data[b] & (1<<i)) != 0)
                                nb1++;
                }
        }

        // even parity
        return (nb1 & 1);
}

void JTAGpxa250::ldic()
{
        ireg(JTAG_LDIC);
}

void JTAGpxa250::invalidateMiniIC() {
        unsigned char data[8];

        ldic();
        data[0] = 1; // invalidate mini IC command
        data[1] = 0;
        data[2] = 0;
        data[3] = 0;
        data[4] = parity(data); // parity
        jtag->dreg(data, 33);
}

void JTAGpxa250::invalidateMainICLine(unsigned int address) {
        unsigned char data[5];

        assert((address & 0x1F) == 0);

        unsigned char instr = JTAG_LDIC;
        ireg(instr);

        data[0] = address & 0xE0;
        data[1] = (address >> 8);
        data[2] = (address >> 16);
        data[3] = (address >> 24);
        data[4] = parity(data); // parity
        jtag->dreg(data, 33);
}

void JTAGpxa250::intToCharArrayLE(unsigned int src, unsigned char dest[]) {
        for (int i=0; i<4; i++)
                dest[i] = (src >> (i*8)) & 0xFF;
}

int JTAGpxa250::charArrayLEToInt(unsigned char src[]) {
        int res = 0;
        for (int i=0; i<4; i++)
                res += src[i] << (i*8);
        return res;
}

void JTAGpxa250::loadICLine(bool mini,
                unsigned int address, unsigned int instructions[]) {
        // do not use : make sure LDIC is loaded in JTAG ireg
        // ldic();

        assert((address & 0x1F) == 0);
        unsigned char data[8];

        if (mini) {
                // load mini IC line with command 011
                intToCharArrayLE((address << 1) | 0x03, data);
                data[4] = address >> 31;
        } else {
                // load main IC line with command 010
                intToCharArrayLE( (address << 1) | 0x02, data);
                data[4]= address >> 31;
        }
        jtag->dreg(data,33);

        for (int i=0; i<8; i++) {
                // load each instruction
                intToCharArrayLE(instructions[i], data);
                data[4] = parity(data);
                jtag->dreg(data,33);
        }
}

void JTAGpxa250::getReadyForUpload() {

        // do the steps 1 - 5 described on page 10-35 of "Intel(r) XScale(tm)
        // Microarchitecture for the PXA250 and PXA210 Applications Processors
        // user's manual"

        // 1. assert RESET and TRST. JTAG IR => idcode, invalidates instruction
        // cache (main & mini).
        jtag->cpuReset(true);
        jtag->trst(true);

        /*unsigned int datareg;
        datareg=0;
        jtag->jtagReset();
        jtag->dreg((unsigned char *)&datareg, 32);
        printf("idcode 0x%08x\n", datareg);*/
        //check();*/
        //jtag->idle(36);

        jtag->trst(false);

        check();
        //jtag->jtagReset();
        jtag->idle(36);

        //milliSecondsWait(200);
        //sleep(1);
        //jtag->trst(false);

        // 2. DCSR, setup Halt Mode + hold_rst
        unsigned char instr = JTAG_DCSR;
        ireg(instr);
        unsigned char data[8];
        unsigned int dcsr = DCSR_GE | DCSR_H; // enable, halt
        intToCharArrayLE((dcsr << 3) | 0x2, data); // no external debug event, hold_rst
        data[4] = (dcsr >> 29);

        //printf("data debut = [%02x] [%02x] [%02x] [%02x] [%02x]\n", data[0], data[1], data[2], data[3], data[4]);
        jtag->dreg(data, 36);

        /*intToCharArrayLE(0 | 0x2, data); // no external debug event, hold_rst
        data[4] = (0);

        printf("data milieu = [%02x] [%02x] [%02x] [%02x] [%02x]\n", data[0], data[1], data[2], data[3], data[4]);
        jtag->dreg(data, 36);

        printf("data fin = [%02x] [%02x] [%02x] [%02x] [%02x]\n", data[0], data[1], data[2], data[3], data[4]);
        */

        // 3. Deassert RESET. The cpu stays in internal reset state.
        jtag->cpuReset(false);

        // We need to wait until the onboard MAX has deasserted reset
        usleep(300000);

        // 4. wait 2030 TCK
        jtag->idle(2030);

        // 5. Load the LDIC instruction into JTAG IR
        ldic();

        // do not mess trying to read something from the target when it's
        // in internal reset state
        doPolling = false;

        // wait a bit
        //usleep(5000);

        // ready for IC loading.
}

void JTAGpxa250::boot() {

        // 7. wait 15 TCK
        jtag->idle(15);

        // 8. clear hold_rst
        unsigned char instr =JTAG_DCSR;
        ireg(instr);
        unsigned char data[8];
        unsigned int dcsr = DCSR_GE | DCSR_H | DCSR_TR; // global enable, halt (see page 10-35)
        intToCharArrayLE(dcsr << 3, data); // no external debug event, clear hold_rst
        data[4] = (dcsr >> 29);
        jtag->dreg(data, 36);

        usleep(10000);
        doPolling = true;
        pollForTX();

        // done ! the cpu should execute the reset vector at 0.
}

//  This function loads code in the mini or main instruction cache.
//  it will pad with NOP to have a number of instruction multiple of 8.
//
//  \param mini if true: load in the mini IC. Otherwise: load in the main IC.
//  \param startAddr    address of the 1st instruction. Must be a multiple of 8.
//  \param instructions array of nbInst instructions 
//  \param nbInst       number of instruction in the 'instructions' array
//  \return true on sucess, false on error (watch the size)
bool JTAGpxa250::loadIC(bool mini, unsigned int startAddr, unsigned int instructions[],
                unsigned int nbInst) {

        // start address has to be a multiple of 8 instructions (32 bytes)
        if (startAddr & 0x1F) return false;
        
        if (mini) {
                // the mini IC is 2k big, so there's size for
                // 64 lines of 8 instructions 32 bits width
                if (nbInst > 64*8) return false;
        } else {
                // the main IC has 32KB
                // there's 1024 lines of 8 instructions 32 bits width
                if (nbInst > 8*1024) return false;
        }

        unsigned int addr = startAddr;

        unsigned int i;
        for (i=0; i+8 < nbInst ; i+=8) {
                loadICLine(mini, addr, instructions + i);
                printf("\r%d on %d instructions loaded.         ", i+8, nbInst);
                fflush(stdout);
                addr += 8*4;
        }

        unsigned int remain = nbInst % 8;
        if (remain) {
                unsigned int data[8]; // buffer, filled with nop.
                for (unsigned int j=0; j<8; j++) { 
                        if (j < remain)
                                data[j] = instructions[ nbInst - remain + j ];
                        else 
                                data[j] = 0x0000A0E1; // NOP (?)
                }
                printf("adding %d nops\n", 8 - remain);
                loadICLine(mini, addr, data);
        }
        printf("\r%d instructions successfully loaded.             \n", nbInst);

        return true; // everything went ok.
}

// returs true on success, false on error
bool JTAGpxa250::writeRX(unsigned int val)
{
        unsigned char cdata[5]; // 36 bits needs 5 bytes
        int retryCount=0;
        
        // Issue JTAG DBGRX Command
        ireg(JTAG_DBGRX);

        do {
                // set dbg. d and dbg.flush to 0
                intToCharArrayLE((val << 3) | 0x0, cdata);
                cdata[4] = (val >> 29);
                // set dbg.v to 1
                cdata[4] |= 0x8;
                // write 36 bits
                jtag->dreg(cdata, 36);

                if (retryCount)
                {
                        printf("\rJTAG : writeRX : Retry to put jtag-data [%08x] (retry %d)       ", val, retryCount);
                        fflush(stdout);
                }
                if (++retryCount > MAX_RETRY_COUNT) 
                {
                        printf("\nJTAG : writeRX : Writing RX failed\n");
                        return false;
                }

        } while ( cdata[0]&0x1 );

        return true;
}

void JTAGpxa250::fastWriteRX(unsigned int val, bool cont)
{
        unsigned char cdata[5]; // 36 bits needs 5 bytes

        // set dbg. d to one and dbg.flush to 0
        intToCharArrayLE((val << 3) | ((cont) ? 0x4 : 0x0) , cdata);
        cdata[4] = (val >> 29);
        // set dbg.v to 1
        cdata[4] |= 0x8;

        // write 36 bits, write only
        jtag->dreg(cdata, 36, true);

        // flush queu when high speed transfer is finished
        if (!cont)
                jtag->flushQueue();
}

bool JTAGpxa250::readTX(unsigned int *val, int max_retry)
{
        unsigned char cdata[5]; // 36 bits needs 5 bytes
        int retryCount=0;
        
        // Issue JTAG DBGTX Command
        ireg(JTAG_DBGTX);

        while (true)
        {
                // set dbg.d, dbg.v and dbg.flush to 0
                memset(cdata, 0, 5);
                jtag->dreg(cdata, 36);
                
                if (cdata[0]&0x1==1)
                {
                        *val=(cdata[0]>>3)|(cdata[1]<<5)|(cdata[2]<<13)|(cdata[3]<<21)|((cdata[4]&0x7)<<29);
                        return true;
                }

                if (retryCount>=max_retry)
                        break;
                
                printf("\rJTAG : readTX : Retry to get jtag-data (retry %d)      ", retryCount++);
                fflush(stdout);
        }

        if (max_retry > 0)
        printf("\nJTAG : readTX : Reading TX failed. Got %02x %02x %02x %02x %02x\n", cdata[4], cdata[3], cdata[2], cdata[1], cdata[0]);
        return false;
}

void JTAGpxa250::putData(unsigned int startAddr, unsigned int words, unsigned int data[], bool halfword)
{
        if (!readyForTargetCommand()) return;

        // Issue JTAG DBGRX Command
        unsigned char instr = JTAG_DBGRX;
        ireg(instr);

        // Send data
        writeRX((unsigned int)'p');
        writeRX(startAddr);
        writeRX(halfword ? 1 : 0);      // 16 or 32 bits access ? 0 means 32.

        unsigned int pos=0;
        unsigned int sum=0;
        while (pos<words)
        {
                fastWriteRX(data[pos], true);
                sum += data[pos];
                pos++;
        }
        fastWriteRX(0, false);

        unsigned int result;
        if (!readTX(&result)) {
                printf("Error: can't read checksum !\n");
        } else {
                if (result != sum)
                        printf("Checksum error: %08X != %08X !\n", sum, result);
        }
        pollForTX();
}

void JTAGpxa250::getData(unsigned int startAddr, unsigned int words, unsigned int data[])
{
        if (!readyForTargetCommand()) return;

        // Issue JTAG DBGRX Command
        unsigned char instr = JTAG_DBGRX;
        ireg(instr);

        // Get data
        writeRX((unsigned int)'g');
        writeRX(startAddr);
        writeRX(words);
        unsigned int pos=0;

        // Issue JTAG DBGTX Command
        instr = JTAG_DBGTX;
        ireg(instr);
        while (pos<words)
        {
                //if (readTX(data+pos))
                //      printf("word %d is success\n", pos);
                readTX(data+pos);
                pos++;
        }
        pollForTX();
}

// This function execute from an address with a given stack pointer
//
// \param startAddre address where the execution will begin
// \param spAddr address of the stack pointer (grows downside)
void JTAGpxa250::execute(unsigned int startAddr, unsigned int spAddr)
{
        if (!isTargetReady) return;
        savePlaces[save_LR] = startAddr;
        savePlaces[save_R13] = spAddr;
        continueCmd();
}

void JTAGpxa250::extBreak() {

        // the SELCDSR instruction selects access to
        // the DCSR JTAG Data register, allowing us to 
        // generate an external debug break.
        unsigned char instr = JTAG_DCSR;
        ireg(instr);

        unsigned char data[5];

        unsigned int dcsr = DCSR_GE | DCSR_H; // enable, halt
        intToCharArrayLE((dcsr << 3) | 0x4, data); //  external debug event, no hold_rst
        data[4] = (dcsr >> 29);

        jtag->dreg(data,36);
        
        printf("DCSR: %08X\n", (data[4] << 29) | (data[3] << 21) | (data[2] << 13) | (data[1] << 5) | (data[0] >> 3));

        doPolling = true;
        pollForTX();
}

void JTAGpxa250::reboot() {

        jtag->cpuReset(true);
        jtag->cpuReset(false);
        isTargetReady= false;
        pollForTX();
}
        
void JTAGpxa250::pollForTX() {
        unsigned int tx;

        if (!doPolling) return;


        while (readTX(&tx, 0)) {

                if ((tx == 0xFFFFFFFF) || (tx==0)) {
                        printf("Target disconnected.\n");
                        doPolling = false;
                        return;
                }
                switch (tx & TARGET_TO_HOST_CMD_MASK) {
                case SAVE_ON_HOST: {
                        unsigned int place = tx & (~TARGET_TO_HOST_CMD_MASK);
                        assert(place < NBR_OF_SAVE_PLACES);
                        readTX(savePlaces + place);
                        //printf("Saving in place %d value %08X\n", place, savePlaces[place]);
                        break;
                        }
                case LOAD_FROM_HOST: {
                        unsigned int place = tx & (~TARGET_TO_HOST_CMD_MASK);
                        assert(place < NBR_OF_SAVE_PLACES);
                        ireg(JTAG_DBGRX);
                        writeRX(savePlaces[place]);
                        break;
                        }
                case TARGET_READY_FOR_CMD:
                        printf("(target ready at PC=%08X)\n", savePlaces[15]);
                        isTargetReady = true;
                        for (std::vector<Callback>::iterator it=targetReadyCallback.begin(); it!=targetReadyCallback.end(); ++it)
                                it->callback(it->arg);
                        break;
                default:
                        // we don't understand the debug handler :/
                        printf("Unknown target to host command: 0x%08X (%d, %c)\n", tx, tx, tx);
                }
        }

        // nothing to do...
}

void JTAGpxa250::ireg(unsigned char instr) {
        if (currentIREG != instr) {
                jtag->ireg(&instr);
                currentIREG=instr;
        }
}

void JTAGpxa250::continueCmd() {
        if (!readyForTargetCommand()) return;

        // Issue JTAG DBGRX Command
        ireg(JTAG_DBGRX);

        // Send data
        writeRX((unsigned int)'c');
        pollForTX();
}

bool JTAGpxa250::readyForTargetCommand() {
        if (isTargetReady) {
                isTargetReady=false; 
                return true;
        } 
        printf("warning: trying to issue a command when the debug handler is not ready!\n");
        return false;
}

bool JTAGpxa250::setSavePlace(unsigned int place, unsigned int value) {
        assert(place < NBR_OF_SAVE_PLACES);
        savePlaces[place] = value;

        if (isTargetReady) {
                return true;
        }
        printf("Warning: setting a register while the target is not ready!\n");
        return false;
}

unsigned int JTAGpxa250::getSavePlace(unsigned int place) {
        assert(place < NBR_OF_SAVE_PLACES);
        if (!isTargetReady)
                printf("Warning: trying to read a register while the target is not ready!\n");
        return savePlaces[place];
}

bool JTAGpxa250::setCp15DebugRegister(unsigned int value, Cp15Reg reg) {

        if (!readyForTargetCommand()) return false;

        // SetBreakpoint command
        writeRX('b');

        // send the number of the register
        writeRX((unsigned int) reg);

        // send the value
        writeRX(value);

        pollForTX();

        return true;
}

---