Отправлено PicoDev 05 марта 2003 г. 01:49 В ответ на: TMS320C54xx. Как организовать передачу данных через HPI в направлениях host-DSP, DSP-host? отправлено Руслан 04 марта 2003 г. 15:46

ISA/PC104 connection

// Dev.h: interface for the Dev class.
//
//////////////////////////////////////////////////////////////////////

#if !defined(AFX_DEV_H__3457C054_0E5C_47A5_9672_F610D6ECC8CA__INCLUDED_)
#define AFX_DEV_H__3457C054_0E5C_47A5_9672_F610D6ECC8CA__INCLUDED_

#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000

#define HPI_L 0x0
#define HPI_H 0x1
#define HPI_R 0x8
#define HPI_W 0x0

#define HPIC 0x0
#define HPIDI 0x2
#define HPIA 0x4
#define HPID 0x6

#define HPIC_XADDR 0x1111 //BOB=1, XHPIA=1
#define HPIC_ADDR 0x0101 //BOB=1

#define HOST 0x10
#define HOST_WORKMODE 0x3
#define HOST_nRESET 0x1
#define HOST_nINT2 0x2

class Dev
{
public:
void dspBootOn();
void dspBootOff();
void dspAddrSet(WORD xpc, WORD pc);
WORD dspRpp();
void dspWpp(WORD data);
WORD dspR();
void dspW(WORD data);
void dspWrite(WORD addr, WORD data);
WORD dspRead(WORD addr);
void dspXA(WORD addr);
void dspA(WORD addr);
WORD swap(WORD w);
void outB(WORD addr, BYTE data);
WORD inW(WORD addr);
void outW(WORD addr, WORD data);
void memR(WORD xpc, WORD pc, LPWORD buff, WORD buff_size);
void memW(WORD xpc, WORD pc, LPWORD buff, WORD buff_size);
int putFirmware(LPWORD buff, LONG buff_size);
void setBaseAddr(WORD addr);
WORD getBaseAddr();
Dev();
virtual ~Dev();

protected:
WORD hpi_in(WORD addr);
void hpi_out(WORD addr, WORD data);
WORD m_BaseAddr;
};

#endif // !defined(AFX_DEV_H__3457C054_0E5C_47A5_9672_F610D6ECC8CA__INCLUDED_)

//===========================
// Dev.cpp: implementation of the Dev class.
//
//////////////////////////////////////////////////////////////////////

#include "stdafx.h"
#include "IF3App.h"
#include "Dev.h"

#ifdef _DEBUG
#undef THIS_FILE
static char THIS_FILE[]=__FILE__;
#define new DEBUG_NEW
#endif

#include

//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////

Dev::Dev()
{
setBaseAddr(0x100);
}

Dev::~Dev()
{

}

WORD Dev::inW(WORD addr)
{

BYTE BL = _inp(m_BaseAddr+addr);
BYTE BH = _inp(m_BaseAddr+addr+1);
return MAKEWORD(BL,BH);
// return _inpw(m_BaseAddr+addr);
}

void Dev::outW(WORD addr, WORD data)
{
// _outpw(m_BaseAddr+addr, data);
_outp(m_BaseAddr+addr, LOBYTE(data));
_outp(m_BaseAddr+addr+1, HIBYTE(data));
}
void Dev::outB(WORD addr, BYTE data)
{
_outp(m_BaseAddr+addr, data);
}

WORD Dev::getBaseAddr()
{
return m_BaseAddr;
}

void Dev::setBaseAddr(WORD addr)
{
m_BaseAddr = addr;
}

int Dev::putFirmware(LPWORD buff, LONG buff_size)
{
// 0 - ok
// 1 - wrong integrity
//
WORD e_buff[2];
int retcode =1;
WORD xpc,pc;
dspBootOn();

WORD e_xpc = buff[5];
WORD e_pc = buff[6];
int i=7;
Loop:


WORD size = buff[i++];
if(size==0)
goto Lret;
if( (i+size) > buff_size)
goto Lerr1;

xpc = buff[i++];
pc = buff[i++];
memW(xpc,pc,&buff[i],size);
i+=size;
goto Loop;
//-------exit------
Lerr1:
retcode = 0;
goto Lret;
Lret:

e_buff[0] = e_xpc;
e_buff[1] = e_pc;

memW(0,0x7E,&e_buff[0],2);

dspBootOff();
return retcode;

}

void Dev::dspBootOn()
{

outB(HOST, 0x00); //reset=0 & int2=0
Sleep(1);
outB(HOST, 0x01); //reset=1 & int2=0
Sleep(1);

}
void Dev::dspBootOff()
{
outB(HOST, 0x3);
}

void Dev::memW(WORD xpc, WORD pc, LPWORD buff, WORD buff_size)
{
dspAddrSet(xpc,pc);

hpi_out(HPID,buff[0]);
for(int i=1; i< buff_size; i++)
{
hpi_out(HPIDI,buff[i]);
}

}

void Dev::memR(WORD xpc, WORD pc, LPWORD buff, WORD buff_size)
{
dspAddrSet(xpc,pc);
for(int i=0; i< buff_size; i++)
{
buff[i] = hpi_in(HPIDI);
}
}

void Dev::dspAddrSet(WORD xpc, WORD pc)
{
hpi_out(HPIC, HPIC_XADDR);
hpi_out(HPIA, xpc);
hpi_out(HPIC, HPIC_ADDR);
hpi_out(HPIA, pc);
}

void Dev::hpi_out(WORD addr, WORD data)
{
outW(addr+HPI_W, data);
}

WORD Dev::hpi_in(WORD addr)
{
return inW(addr+HPI_R);
}

WORD Dev::swap(WORD w)
{
//MAKEWORD(low,high)
return MAKEWORD(HIBYTE(w), LOBYTE(w));
}

void Dev::dspXA(WORD xpc)
{
hpi_out(HPIC, HPIC_XADDR);
hpi_out(HPIA, xpc);
}

void Dev::dspA(WORD pc)
{
hpi_out(HPIC, HPIC_ADDR);
hpi_out(HPIA, pc);
}

WORD Dev::dspRead(WORD addr)
{
dspA(addr);
return hpi_in(HPID);
}

void Dev::dspWrite(WORD addr, WORD data)
{
dspA(addr);
hpi_out(HPID,data);
}

void Dev::dspW(WORD data)
{
hpi_out(HPID,data);
}

WORD Dev::dspR()
{
return hpi_in(HPID);
}

void Dev::dspWpp(WORD data)
{
hpi_out(HPIDI,data);
}

WORD Dev::dspRpp()
{
return hpi_in(HPIDI);
}