STDMETHODIMP MachineDebuggerWrap::SetRegisters(ULONG aCpuId,
ComSafeArrayIn(IN_BSTR, aNames),
ComSafeArrayIn(IN_BSTR, aValues))
{
LogRelFlow(("{%p} %s:enter aCpuId=%RU32 aNames=%zu aValues=%zu\n", this, "MachineDebugger::setRegisters", aCpuId, aNames, aValues));
VirtualBoxBase::clearError();
HRESULT hrc;
try
{
AutoCaller autoCaller(this);
if (FAILED(autoCaller.rc()))
throw autoCaller.rc();
hrc = setRegisters(aCpuId,
ArrayBSTRInConverter(ComSafeArrayInArg(aNames)).array(),
ArrayBSTRInConverter(ComSafeArrayInArg(aValues)).array());
}
catch (HRESULT hrc2)
{
hrc = hrc2;
}
catch (...)
{
hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
}
LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "MachineDebugger::setRegisters", hrc));
return hrc;
}
const Adc::Measurement Adc::measure()
{
if (!isConfigured)
return Adc::Measurement();
setRegisters();
ADCSRA |= (1<<ADSC);
while (ADCSRA & (1<<ADSC));
return Adc::Measurement(ADCL, ADCH);
}
/*!
Grows the register array by \a count elements, and returns the offset of
the newly added elements (note that the register file grows downwards,
starting at index -1).
*/
int QScriptStaticScopeObject::growRegisterArray(int count)
{
size_t oldSize = d_ptr()->registerArraySize;
size_t newSize = oldSize + count;
JSC::Register* registerArray = new JSC::Register[newSize];
if (d_ptr()->registerArray)
memcpy(registerArray + count, d_ptr()->registerArray.get(), oldSize * sizeof(JSC::Register));
setRegisters(registerArray + newSize, registerArray);
d_ptr()->registerArraySize = newSize;
return -oldSize - 1;
}
Allocator::Allocator(const SpillPolicy::RegisterId regs, const policy_t spillPolicies)
{
setRegisters(regs);
assertM(spillPolicies != 0, "No spill policy");
for(SpillType i = SpillType::LRU; i <= spillPolicies;
i = (SpillType) ((unsigned) (i) * 2))
{
if(spillPolicies & i)
{
insertPolicy(i, 1);
}
}
}
void JSGlobalObject::copyGlobalsTo(RegisterFile& registerFile)
{
JSGlobalObject* lastGlobalObject = registerFile.globalObject();
if (lastGlobalObject && lastGlobalObject != this)
lastGlobalObject->copyGlobalsFrom(registerFile);
registerFile.setGlobalObject(this);
registerFile.setNumGlobals(symbolTable().size());
if (d()->registerArray) {
memcpy(registerFile.start() - d()->registerArraySize, d()->registerArray.get(), d()->registerArraySize * sizeof(Register));
setRegisters(registerFile.start(), 0, 0);
}
}
void JSGlobalObject::copyGlobalsFrom(RegisterFile& registerFile)
{
ASSERT(!d()->registerArray);
ASSERT(!d()->registerArraySize);
int numGlobals = registerFile.numGlobals();
if (!numGlobals) {
d()->registers = 0;
return;
}
Register* registerArray = copyRegisterArray(registerFile.lastGlobal(), numGlobals);
setRegisters(registerArray + numGlobals, registerArray, numGlobals);
}
SPUArchitecture::SPUArchitecture(ByteOrder byteOrder):
byteOrder_(byteOrder)
{
setName(QLatin1String("spu-be"));
setBitness(64);
setMaxInstructionSize(SPUInstruction::MAX_SIZE);
setRegisters(SPURegisters::instance());
static core::MasterAnalyzer masterAnalyzer;
setMasterAnalyzer(&masterAnalyzer);
addCallingConvention(std::make_unique<DefaultCallingConvention>());
}
void JSGlobalObject::copyGlobalsTo(RegisterFile& registerFile)
{
JSGlobalObject* lastGlobalObject = registerFile.globalObject();
if (lastGlobalObject && lastGlobalObject != this)
lastGlobalObject->copyGlobalsFrom(registerFile);
registerFile.setGlobalObject(this);
registerFile.setNumGlobals(symbolTable().size());
if (m_registerArray) {
// The register file is always a gc root so no barrier is needed here
memcpy(registerFile.start() - m_registerArraySize, m_registerArray.get(), m_registerArraySize * sizeof(WriteBarrier<Unknown>));
setRegisters(reinterpret_cast<WriteBarrier<Unknown>*>(registerFile.start()), nullptr, 0);
}
}
void JSGlobalObject::copyGlobalsFrom(RegisterFile& registerFile)
{
ASSERT(!m_registerArray);
ASSERT(!m_registerArraySize);
int numGlobals = registerFile.numGlobals();
if (!numGlobals) {
m_registers = 0;
return;
}
OwnArrayPtr<WriteBarrier<Unknown> > registerArray = copyRegisterArray(globalData(), reinterpret_cast<WriteBarrier<Unknown>*>(registerFile.lastGlobal()), numGlobals, numGlobals);
WriteBarrier<Unknown>* registers = registerArray.get() + numGlobals;
setRegisters(registers, registerArray.release(), numGlobals);
}
void RegisterHandler::setAndMarkRegisters(const Registers ®isters)
{
if (!compareRegisterSet(m_registers, registers)) {
setRegisters(registers);
return;
}
const int size = m_registers.size();
for (int r = 0; r != size; ++r) {
const QModelIndex regIndex = index(r, 1, QModelIndex());
if (m_registers.at(r).value != registers.at(r).value) {
// Indicate red if values change, keep changed.
m_registers[r].changed = m_registers.at(r).changed
|| !m_registers.at(r).value.isEmpty();
m_registers[r].value = registers.at(r).value;
emit dataChanged(regIndex, regIndex);
}
emit registerSet(regIndex); // Notify attached memory views.
}
}
void JSGlobalObject::resizeRegisters(int oldSize, int newSize)
{
ASSERT(oldSize <= newSize);
if (newSize == oldSize)
return;
ASSERT(newSize && newSize > oldSize);
if (m_registerArray || !m_registers) {
ASSERT(static_cast<size_t>(oldSize) == m_registerArraySize);
OwnArrayPtr<WriteBarrier<Unknown> > registerArray = adoptArrayPtr(new WriteBarrier<Unknown>[newSize]);
for (int i = 0; i < oldSize; i++)
registerArray[newSize - oldSize + i].set(globalData(), this, m_registerArray[i].get());
WriteBarrier<Unknown>* registers = registerArray.get() + newSize;
setRegisters(registers, registerArray.release(), newSize);
} else {
ASSERT(static_cast<size_t>(newSize) < globalData().interpreter->registerFile().maxGlobals());
globalData().interpreter->registerFile().setNumGlobals(newSize);
}
for (int i = -newSize; i < -oldSize; ++i)
m_registers[i].setUndefined();
}
static void sendState(PDWriter* writer)
{
setExceptionLocation(writer);
setRegisters(writer);
setDisassembly(writer, 0, 10);
}
/**
* Main routine. Parse commandline args and trigger actions.
*/
int main(int argc, char **argv) {
usb_dev_handle *handle = NULL;
char * usbSerialID = NULL;
int c;
// moved this malloc() here instead of within the while(1) loop
// to prevent memory leakage problem
// as *args is not free'ed.
char **args = malloc(MAX_COMMAND_ARGS * sizeof(char *));
int port = 19004;
int daemon = 0;
// Read options
while ( (c = getopt(argc, argv, "adhi:m:p:s:u:vx:")) != -1) {
switch (c) {
case 'i':
i2cAddress = atoi(optarg);
break;
case 'a':
setByValue = 1;
break;
case 'd':
daemon = 1;
break;
case 'h':
firmware_PTT = 1;
break;
case 'm':
multiplier = atof(optarg);
break;
case 'p':
port = atoi(optarg);
break;
case 's':
startupFreq = atof(optarg);
break;
case 'x':
fXtall = atof(optarg);
break;
case 'u':
usbSerialID = optarg;
break;
case 'v':
verbose++;
break;
default: /* '?' */
usage(argv[0]);
exit(EXIT_FAILURE);
}
}
if (verbose) {
printf("I2C Address = %X\n", i2cAddress);
printf("fXtall = %f\n", fXtall);
printf("multiplier = %f\n", multiplier);
printf("startupFreq = %f\n", startupFreq);
}
if((argc <= optind) && (daemon == 0)){
usage(argv[0]);
exit(1);
}
usb_init();
char attempt=0, error=0;
do {
attempt++;
error=usbOpenDevice(&handle, USBDEV_SHARED_VENDOR, VENDOR_NAME, USBDEV_SHARED_PRODUCT, PRODUCT_NAME, usbSerialID);
if(error != 0){
fprintf(stderr, "Could not open USB device \"%s\" with vid=0x%x pid=0x%x, retrying\n", PRODUCT_NAME, USBDEV_SHARED_VENDOR, USBDEV_SHARED_PRODUCT);
sleep(2*attempt);
}
} while (error && attempt < USB_MAX_RETRIES);
if (error) {
fprintf(stderr, "Permanent problem opening usb device. Giving up.\n");
exit(1);
}
unsigned short version = readVersion(handle);
major = (version & 0xFF00) >> 8;
minor = (version & 0xFF);
/* Relocate lower later */
if (daemon) {
printf("Starting daemon...\n");
int socket_desc;
socket_desc=socket(AF_INET,SOCK_DGRAM,IPPROTO_UDP);
if (socket_desc==-1)
perror("Create socket");
struct sockaddr_in address;
/* type of socket created in socket() */
address.sin_family = AF_INET;
address.sin_addr.s_addr = INADDR_ANY;
address.sin_port = htons(port);
/* bind the socket to the port specified above */
int retval;
if (bind(socket_desc,(struct sockaddr *)&address,sizeof(address)) != 0) {
fprintf(stderr, "Error binding to port %d\n", port);
exit(0);
}
while (1) {
ssize_t bytes;
char buffer[1024];
struct sockaddr_in clnt;
socklen_t clnt_len;
clnt_len = sizeof(clnt);
bytes = recvfrom (socket_desc, buffer, sizeof(buffer) - 1, 0, (struct sockaddr *)&clnt, &clnt_len);
if (bytes > 0) {
buffer[bytes] = 0;
if (verbose >= 2)
printf("Returned %d bytes from %s: %s\n", bytes, inet_ntoa(clnt.sin_addr), buffer);
if (strncmp(buffer, "quit", 4) == 0) {
if (verbose)
printf("Quit command received\n");
exit(0);
}
char *saveptr;
char *token;
int argn = 0;
for (int i=0; i < MAX_COMMAND_ARGS;i++)
args[i] = NULL;
token = strtok_r(buffer, " ", &saveptr);
while (token != NULL) {
args[argn] = strcpy(malloc(strlen(token) + 1), token);
argn++;
token = strtok_r(NULL, " ", &saveptr);
}
// Execute command here
char result[100];
do_command(handle, args, argn, result);
// Cleanup
for (int i=0; i < MAX_COMMAND_ARGS;i++) {
if (args[i] != NULL)
free(args[i]);
}
int retlen = strlen(result);
if (sendto(socket_desc, result, retlen,0, (struct sockaddr *) &clnt, clnt_len) != retlen) {
perror("Failed to send ack");
exit(1);
}
} else {
fprintf(stderr, "recvfrom returned %d\n", bytes);
}
}
close(socket_desc);
exit(0);
}
/* Device has been opened - perform the requested operation */
if (strcmp(argv[optind], "getregisters") == 0) {
getRegisters(handle);
} else if(strcmp(argv[optind], "getfreq") == 0){
double freq;
if (setByValue)
freq = readFrequencyByValue(handle);
else
freq = getFrequency(handle);
if (freq != 0.00)
printf("Frequency : %f (x %.2f)\n", freq / multiplier, multiplier);
#ifdef HAVE_LIBNCURSES
} else if (strcmp(argv[optind], "interactive") == 0) {
run_interactive(handle);
#endif
} else if (strcmp(argv[optind], "getptt") == 0){
if (firmware_PTT) PTT = getPTT(handle);
printf("PTT : %d\n", PTT);
} else if (strcmp(argv[optind], "getkeys") == 0){
keys = getkeys(handle);
printf("Paddles: %d\n", keys);
} else if (strcmp(argv[optind], "gettone") == 0){
printf("CW Tone: %d\n", CW_tone);
} else if ((strcmp(argv[optind], "ptt") == 0) && (argc >= optind + 1)) {
PTT = (strcmp(argv[optind+1],"on") == 0) ? 1: 0;
setPTT(handle, PTT);
printf("PTT set to %d\n", PTT);
} else if (strcmp(argv[optind], "calibrate") == 0) {
calibrate(handle);
} else if ((strcmp(argv[optind], "set") == 0) && (argc >= optind + 2)) {
if ((strcmp(argv[optind+1], "bpf_addr") == 0) && (argc >= optind + 3)) {
// set bpf_addr index value
setBPFAddress(handle, atoi(argv[optind+2]), atoi(argv[optind+3]));
} else if ((strcmp(argv[optind+1], "bpf_point") == 0) && (argc >= optind + 3)) {
// set bpf_point index (int) value (float)
setBPFCrossOver(handle, atoi(argv[optind+2]), atof(argv[optind+3]));
} else if ((strcmp(argv[optind+1], "bpf") == 0) && (argc >= optind + 2)) {
setBPF(handle, (strcmp(argv[optind+2],"on") == 0) ? 1 : 0);
} else if ((strcmp(argv[optind+1], "lpf") == 0) && (argc >= optind + 2)) {
setLPF(handle, (strcmp(argv[optind+2],"on") == 0) ? 1 : 0);
} else if ((strcmp(argv[optind+1], "lpf_addr") == 0) && (argc >= optind + 3)) {
// set bpf_addr index value
setBPFAddress(handle, atoi(argv[optind+2]), atoi(argv[optind+3]));
displayLPFs(handle);
} else if ((strcmp(argv[optind+1], "lpf_point") == 0) && (argc >= optind + 3)) {
// set lpf_point index (int) value (float)
setLPFCrossOver(handle, atoi(argv[optind+2]), atof(argv[optind+3]));
} else if (strcmp(argv[optind+1], "freq") == 0) {
if (setByValue)
setFreqByValue(handle, atof(argv[optind+2]));
else
setFrequency(handle, atof(argv[optind+2]));
} else if ((strcmp(argv[optind+1], "registers") == 0 || strcmp(argv[optind+1], "regs") == 0) && argc == optind+8) {
unsigned char regs[6];
int i;
for (i = 0; i < 6; i += 1)
regs[i] = strtol(argv[optind+2+i], NULL, 0);
setRegisters(handle, regs);
} else if ((strcmp(argv[optind+1], "si570_addr") == 0) && (argc >= optind + 2)) {
setSi570Address(handle, atoi(argv[optind+2]));
} else if (strcmp(argv[optind+1], "si570_multiplier") == 0) {
int index = 0;
int valueIndex = optind+2;
// If there are 2 args after the variable name, one is index
if (argc >= optind + 3) {
index = atoi(argv[optind+2]);
valueIndex++;
}
double sub, mul;
readMultiplyLO(handle, index, &mul, &sub);
mul = atof(argv[valueIndex]);
setMultiplyLo(handle, index, mul, sub);
if (verbose)
printf("Set multiply [%d] to : %f\n", index, mul);
} else if (strcmp(argv[optind+1], "xtall") == 0) {
setXtallFrequency(handle, atof(argv[optind+2]));
} else if (strcmp(argv[optind+1], "startup") == 0) {
setStartupFrequency(handle, atof(argv[optind+2]));
} else {
usage(argv[0]);
exit(1);
}
} else if (strcmp(argv[optind], "solutions") == 0) {
solveRegisters(handle);
} else if (strcmp(argv[optind], "status") == 0) {
printf("USB SerialID: %s\n", serialNumberString);
if (major >= 15) {
readFrequencyByValue(handle);
readStartupFreq(handle);
readXtallFreq(handle);
readSmoothTunePPM(handle);
if (major >= 16 || minor >= 12) {
readSi570Address(handle);
}
displayBands(handle);
displayLPFs(handle);
/*
if (major >= 16 || ((major >= 15) && (minor >= 12))) {
displayBands(handle);
} else if (minor >= 10) {
double sub, mul;
readMultiplyLO(handle, 0, &mul, &sub);
printf("LO Subtract : %f\n", sub);
printf("Multiply : %f\n", mul);
}
//displayBPFFilters(handle);
//displayLPFFilters(handle);*/
}
} else if (strcmp(argv[optind], "tweak") == 0) {
tweakRegisters(handle);
} else {
usage(argv[0]);
exit(1);
}
usb_close(handle);
return 0;
}
int do_command(usb_dev_handle *handle, char **argv, int argc, char *result) {
sprintf(result, "ok");
if (strcmp(argv[0], "get") == 0) {
if(argv[1][0] == 'p'){
if (firmware_PTT) PTT = getPTT(handle); // this reads the PTT status from the connected Mobo
sprintf(result, "ok %d", PTT);
}
else if (argv[1][0] == 'k'){
keys = getkeys(handle);
sprintf(result, "ok %d", keys);
}
else if(argv[1][0] == 'f'){
double freq;
if (setByValue)
freq = readFrequencyByValue(handle);
else
freq = getFrequency(handle);
if (freq != 0.00) {
if (verbose >= 2) printf("Frequency : %f (x %.2f)\n", freq / multiplier, multiplier);
sprintf(result, "ok %f", freq / multiplier);
}
else
{
sprintf(result, "error");
return -1;
}
}
else if(argv[1][0] == 't'){
sprintf(result, "ok %d", CW_tone);
}
else if (strcmp(argv[1], "si570_multiplier") == 0) {
double sub, mul;
// Just works for non per-band multipliers
if (readMultiplyLO(handle, 0, &mul, &sub) == 0)
sprintf(result, "ok %f", mul);
else {
sprintf(result, "error");
return -1;
}
}
else if (strcmp(argv[1], "local_multiplier") == 0) {
sprintf(result, "ok %f", multiplier);
}
else {
sprintf(result, "error");
return -1;
} // end if "local multiplier"
} // end if "get"
else if ((strcmp(argv[0], "set") == 0) && (argc >= 2)) {
if ((strcmp(argv[1], "ptt") == 0) && (argc >= 1)) {
PTT = (strncmp(argv[2],"on",2) == 0) ? 1 : 0;
setPTT(handle, PTT);
} else if ((strcmp(argv[1], "bpf") == 0)) {
setBPF(handle, (strncmp(argv[2],"on",2) == 0) ? 1 : 0);
} else if (strcmp(argv[1], "freq") == 0) {
if (setByValue)
setFreqByValue(handle, atof(argv[2]));
else
setFrequency(handle, atof(argv[2]));
} else if (strcmp(argv[1], "tone") == 0) {
CW_tone = atof(argv[2]);
} else if (strcmp(argv[1], "local_multiplier") == 0) {
multiplier = atof(argv[2]);
} else if (strcmp(argv[1], "registers") == 0 || strcmp(argv[1], "regs") == 0 && argc == 8) {
unsigned char regs[6];
int i;
for (i = 0; i < 6; i += 1)
regs[i] = strtol(argv[2+i], NULL, 0);
setRegisters(handle, regs);
} else if (strcmp(argv[1], "tweak") == 0) {
tweakRegisters(handle);
} else {
sprintf(result, "error");
return -1;
}
} else {
sprintf(result, "error");
return -1;
}
return 0;
}
/**********************************************************************
*********** Main Program ***********************
***********************************************************************
Aim : main program
NOTE :
**********************************************************************/
int main (void)
{
SystemCoreClockUpdate();
// SysTick_Config(10000); //turn SysTick timer on
SysTick_Config(SystemCoreClock/1600); // 1ms SysTicks
Delay(100); //wait for system stabilization
SIM->SCGC5 |= SIM_SCGC5_PORTD_MASK | SIM_SCGC5_PORTB_MASK; //Port-D-B clock ON
SIM->SCGC5 |= SIM_SCGC5_PORTA_MASK;
Delay(0x500); //delay
LED_Init(); //Initialize the LEDs
spi_init(); // SPI-1 init
Delay(0x100); //delay
hede=PTD->PDIR;
TI_Init();
// TI_HW_Reset();
// Delay(0x3000); //delay for logic analyzer
hede=PTD->PDIR;
// SpiStart();
// SPI_Send(0x10);
// SpiStop();
// test[0]=TI_ReadByte(0x0F);
// test[1]=TI_ReadByte(0x0F);
// test[2]=TI_ReadByte(0x0F);
// test[3]=TI_ReadByte(0x0F);
// test[4]=TI_ReadByte(0x0F);
//
// TI_WriteByte(CC112X_IOCFG3,0x87);
// test[5]=TI_ReadByte(CC112X_IOCFG3);
// TI_Command(CC112X_SRES); //sofware reset
//
// test[6]=TI_ReadByte(CC112X_IOCFG3);
// TI_WriteByte(CC112X_IOCFG3,0x87);
// test[7]=TI_ReadByte(CC112X_IOCFG3);
//
TI_Write_brst(CC112X_BURST_TXFIFO,toto,20);
Delay(100);
TI_Read_brst(CC112X_RSSI1,got,1);
//Delay(100);
//TI_Command(CC112X_SRES); //sofware reset
setRegisters();
getReg_Test();
// TI_WriteByte(CC112X_DCFILT_CFG,0x40);
// TI_WriteByte(CC112X_IOCFG2, 0x06);
// TI_WriteByte(CC112X_IOCFG1, 0xB0);
// TI_WriteByte(CC112X_IOCFG0, 0x40);
test[0] = getCelcius(); //Read temp sensor TEST
// Delay(0x2000);
while(1)
{
// Turn on leds 1 by 1
YELLOW_ON;
Delay(1000);
GREEN_ON;
Delay(1000);
RED_ON;
Delay(1000);
//Turn off leds
YELLOW_OFF;
GREEN_OFF;
RED_OFF;
// SpiStart();
// hede=PTD->PDIR;
// DelayUs(0x1000);
// SPI_Send(0x10);
// x=SPI_Send(0x00);
// x=SPI_Send(0x00);
// SpiStop();
// Delay(0x50);
// SpiStart();
// SPI_Send(0x10);
// x=SPI_Send(0x00);
// SpiStop();
// hede=PTD->PDIR;
//
// SpiStop();
//// YELLOW_ON; Delay(1000); GREEN_ON; Delay(1000); RED_ON; Delay(1000);
//// TI_WriteByte(CC112X_IOCFG3,0x87);
//// test[2]=TI_ReadByte(CC112X_IOCFG3);
//// YELLOW_OFF; GREEN_OFF; RED_OFF;
//
// PTD->PCOR |= (1UL<<4); // CS=0, SPI start
//
// hede=PTD->PDIR;
//// test[0]=SPI_Send(0x10);
// while((PTD->PDIR & 0x80)!= 0); //Wait for CHIP_RDYn signal
//
// SPI_Send(0x8F); //send the adress and get the status byte
// test[2]= SPI_Send(0x00); //read the adress
//// test[1]=SPI_Send(0x00);
//// test[2]=SPI_Send(0x10);
//// test[3]=SPI_Send(0x00);
//// SPI_Send(0x10);
//
// PTD->PSOR |= (1UL<<4); // CS=0, SPI stop
}
}
