BOOL ValidateNDTPeriod(ULONG period)
{
CcspLMLiteConsoleTrace(("RDK_LOG_DEBUG, LMLite %s ENTER\n", __FUNCTION__ ));
BOOL ret = FALSE;
ret = isvalueinarray_ndt(period, NetworkDeviceTrafficPeriods, ARRAY_SZ(NetworkDeviceTrafficPeriods));
CcspLMLiteConsoleTrace(("RDK_LOG_DEBUG, LMLite %s EXIT RET[%d] \n", __FUNCTION__ , ret ));
return ret;
}
int ddmAddUsr(const User &usr)
{
int course_id[3];
memset(course_id, 0, sizeof(course_id));
for (int i = 0; i < ARRAY_SZ(course_id) && i < usr.course_id_list.length(); i++) {
course_id[i] = usr.course_id_list.at(i);
}
QString sql(QObject::tr("INSERT INTO users "
"(name, passwd, IdCardNo, domain, courseId0, courseId1, courseId2) "
"VALUES ('%1', '%2', '%3', %4, %5, %6, %7)")
.arg(usr.name).arg(usr.passwd).arg(usr.idCardNo).arg(usr.domain)
.arg(course_id[0]).arg(course_id[1]).arg(course_id[2]));
qDebug() << sql;
QSqlQuery q;
if (!q.exec(sql)) {
qDebug() << db.lastError();
return -1;
}
return 0;
}
void __hidden init_dvm_iface(struct dvm_iface *dvm, const char *dso_path)
{
int ii;
if (dvm->dso)
return;
dvm->dso = (void *)1;
dvm->dso = dlopen(dso_path, RTLD_NOW | RTLD_LOCAL);
if (!dvm->dso) {
libc_log("E:Could not open libdvm (%s)!", dso_path);
return;
}
/* initialize the minimal Dalvik debug interface */
#define __init_sym(iface,sym,mem) \
do { \
if ((iface)->mem) \
break; \
(iface)->mem = dlsym((iface)->dso, #sym); \
if ((iface)->mem) \
break; \
(iface)->mem = dlsym((iface)->dso, "_" #sym); \
if ((iface)->mem) \
break; \
BUG(0xD0); \
} while (0)
#define _init_sym(iface,sym,mem) \
__init_sym(iface, sym, mem)
#define init_sym(IFACE,SYM) \
_init_sym(IFACE, sym_DVM_ ## SYM, dvm ## SYM)
init_sym(dvm, ThreadSelf);
init_sym(dvm, ComputeExactFrameDepth);
init_sym(dvm, FillStackTraceArray);
init_sym(dvm, GetThreadName);
init_sym(dvm, HumanReadableMethod);
#undef init_sym
#undef _init_sym
#undef __init_sym
/*
* Now find the functions that indicate
* we are within the Java call stack
*/
dvm->dvmCallMethodSym[0][0] = dlsym(dvm->dso, DVM_CALL_METHOD);
dvm->dvmCallMethodSym[1][0] = dlsym(dvm->dso, DVM_CALL_METHOD_A);
dvm->dvmCallMethodSym[2][0] = dlsym(dvm->dso, DVM_CALL_METHOD_V);
dvm->dvmCallMethodSym[3][0] = dlsym(dvm->dso, DVM_CALL_JNI_METHOD);
dvm->dvmCallMethodSym[4][0] = dlsym(dvm->dso, DVM_CALL_JNI_METHOD_CHK);
/*
* note: if either of these fail, then we won't ever find a
* java/dalvik backtrace, but we won't risk instability either
*/
for (ii = 0; ii < (int)ARRAY_SZ(dvm->dvmCallMethodSym); ii++) {
if (!dvm->dvmCallMethodSym[ii][0]) {
libc_log("W:Couldn't find dvmCallMethod[%d] in libdvm.so", ii);
} else {
void *end;
end = _find_symbol_end(dvm->dvmCallMethodSym[ii][0]);
dvm->dvmCallMethodSym[ii][1] = end;
/*
libc_log("I:dvmCallMethod[%d][%p-%p]:", ii,
dvm->dvmCallMethodSym[ii][0],
dvm->dvmCallMethodSym[ii][1]);
*/
}
}
dvm->valid = 1;
return;
}
void __hidden get_dvm_backtrace(struct tls_info *tls, struct dvm_iface *dvm,
struct bt_state *bt_state, struct dvm_bt *dvm_bt)
{
int cnt;
if (!dvm->valid || !tls)
return;
dvm_bt->count = 0;
/*
* Search through the native backtrace for the java stack indicators.
* It should be faster to search up from the bottom of the stack
* because the dvmCallMethod function is generally invoked from
* platform-specific assembly quite early in the backtrace.
*/
cnt = bt_state->count;
while (--cnt >= 0) {
int ii;
void *addr = bt_state->frame[cnt].pc;
for (ii = 0; ii < (int)ARRAY_SZ(dvm->dvmCallMethodSym); ii++)
if (_in_range(addr, dvm->dvmCallMethodSym[ii]))
goto do_dvm_bt;
}
return;
/*
* We have a call stack that's from a Java/Dalvik thread:
* get the backtrace!
*/
do_dvm_bt:
{
struct Thread *self;
uint32_t *fp = NULL;
char *tname;
struct Method **mlist;
int r;
self = dvm->dvmThreadSelf();
if (!self)
return;
fp = self->interpSave.curFrame;
if (!fp)
return;
/*
* There is a bug in dvmGetThreadName() that causes this
* to crash when we call it before the thread has a
* Java/Dalvik name, but after a Java function has been
* invoked. This happens primarily at system boot...
tname = tls->dvm_threadname;
if (!tname[0]) {
int len;
std::string nm = dvm->dvmGetThreadName(self);
len = nm.length();
if (len >= TLS_MAX_STRING_LEN)
len = TLS_MAX_STRING_LEN - 1;
libc.memcpy(tname, nm.c_str(), len);
libc_log("I:DalvikThreadName:%s:", tname);
}
*/
mlist = dvm_bt->mlist;
dvm_bt->count = dvm->dvmComputeExactFrameDepth(fp);
if (dvm_bt->count > MAX_BT_FRAMES) {
/*
* we need an array big enough for this frame
* because the dvm fill stack array function
* doesn't care how big our array really is...
*/
mlist = libc.malloc((dvm_bt->count + 1) * sizeof(struct Method *));
if (!mlist) {
dvm_bt->count = 0;
return;
}
dvm_bt->count = MAX_BT_FRAMES;
}
/*
* Grrr. This API doesn't respect the 'length' parameter.
* It just sends out an error message (if you're lucky enough
* to have copiled without NDEBUG), and continues to mash on
* your memory even though it's out of bounds...
*/
dvm->dvmFillStackTraceArray(fp, mlist, dvm_bt->count);
if (mlist != dvm_bt->mlist) {
/* copy only the portion of data back that fits */
libc.memcpy(dvm_bt->mlist, mlist,
dvm_bt->count * sizeof(struct Method *));
libc.free(mlist);
}
}
return;
}
struct task_steps_pool *steps_pool_get(void) {
return task_steps_pool_create(steps, ARRAY_SZ(steps));
}
// Entry point
int main()
{
struct uart_pkt {
unsigned char magic;
#define UART_PKT_MAGIC 'N'
// | 7 | 6 | 5 | 4 | 3 | 2 | 1 | 0 |
// | dir | dev | cnt |
unsigned char mode;
#define UART_PKT_MODE_CNT_MASK 0xF
#define UART_PKT_MODE_CNT_SHIFT 0
#define UART_PKT_MODE_DEV_MASK 0x30
#define UART_PKT_MODE_DEV_SHIFT 4
#define UART_PKT_DEV_GPIO (0<<UART_PKT_MODE_DEV_SHIFT)
#define UART_PKT_DEV_LMS (1<<UART_PKT_MODE_DEV_SHIFT)
#define UART_PKT_DEV_VCTCXO (2<<UART_PKT_MODE_DEV_SHIFT)
#define UART_PKT_DEV_SI5338 (3<<UART_PKT_MODE_DEV_SHIFT)
#define UART_PKT_MODE_DIR_MASK 0xC0
#define UART_PKT_MODE_DIR_SHIFT 6
#define UART_PKT_MODE_DIR_READ (2<<UART_PKT_MODE_DIR_SHIFT)
#define UART_PKT_MODE_DIR_WRITE (1<<UART_PKT_MODE_DIR_SHIFT)
};
struct uart_cmd {
unsigned char addr;
unsigned char data;
};
// Set the prescaler for 400kHz with an 80MHz clock (prescaer = clock / (5*desired) - 1)
IOWR_16DIRECT(I2C, OC_I2C_PRESCALER, 39 ) ;
IOWR_8DIRECT(I2C, OC_I2C_CTRL, OC_I2C_ENABLE ) ;
// Set the UART divisor to 14 to get 4000000bps UART (baud rate = clock/(divisor + 1))
IOWR_ALTERA_AVALON_UART_DIVISOR(UART_0_BASE, 19) ;
// Set the IQ Correction parameters to 0
IOWR_ALTERA_AVALON_PIO_DATA(IQ_CORR_RX_PHASE_GAIN_BASE, DEFAULT_CORRECTION);
IOWR_ALTERA_AVALON_PIO_DATA(IQ_CORR_TX_PHASE_GAIN_BASE, DEFAULT_CORRECTION);
/* Event loop never exits. */
{
char state;
enum {
LOOKING_FOR_MAGIC,
READING_MODE,
READING_CMDS,
EXECUTE_CMDS
};
unsigned short i, cnt;
unsigned char mode;
unsigned char buf[14];
struct uart_cmd *cmd_ptr;
uint32_t tmpvar = 0;
state = LOOKING_FOR_MAGIC;
while(1)
{
// Check if anything is in the FSK UART
if( IORD_ALTERA_AVALON_UART_STATUS(UART_0_BASE) & ALTERA_AVALON_UART_STATUS_RRDY_MSK )
{
uint8_t val ;
int isRead;
int isWrite;
val = IORD_ALTERA_AVALON_UART_RXDATA(UART_0_BASE) ;
switch (state) {
case LOOKING_FOR_MAGIC:
if (val == UART_PKT_MAGIC)
state = READING_MODE;
break;
case READING_MODE:
mode = val;
if ((mode & UART_PKT_MODE_CNT_MASK) > 7) {
mode &= ~UART_PKT_MODE_CNT_MASK;
mode |= 7;
}
i = 0;
cnt = (mode & UART_PKT_MODE_CNT_MASK) * sizeof(struct uart_cmd);
state = READING_CMDS;
break;
case READING_CMDS:
// cnt here means the number of bytes to read
buf[i++] = val;
if (!--cnt)
state = EXECUTE_CMDS;
break;
default:
break;
}
void write_uart(unsigned char val) {
while (!(IORD_ALTERA_AVALON_UART_STATUS(UART_0_BASE) & ALTERA_AVALON_UART_STATUS_TRDY_MSK));
IOWR_ALTERA_AVALON_UART_TXDATA(UART_0_BASE, val);
}
isRead = (mode & UART_PKT_MODE_DIR_MASK) == UART_PKT_MODE_DIR_READ;
isWrite = (mode & UART_PKT_MODE_DIR_MASK) == UART_PKT_MODE_DIR_WRITE;
if (state == EXECUTE_CMDS) {
write_uart(UART_PKT_MAGIC);
write_uart(mode);
// cnt here means the number of commands
cnt = (mode & UART_PKT_MODE_CNT_MASK);
cmd_ptr = (struct uart_cmd *)buf;
if ((mode & UART_PKT_MODE_DEV_MASK) == UART_PKT_DEV_LMS) {
for (i = 0; i < cnt; i++) {
if (isRead) {
lms_spi_read(cmd_ptr->addr, &cmd_ptr->data);
} else if (isWrite) {
lms_spi_write(cmd_ptr->addr, cmd_ptr->data);
cmd_ptr->data = 0;
} else {
cmd_ptr->addr = 0;
cmd_ptr->data = 0;
}
cmd_ptr++;
}
}
if ((mode & UART_PKT_MODE_DEV_MASK) == UART_PKT_DEV_SI5338) {
for (i = 0; i < cnt; i++) {
if (isRead) {
uint8_t tmpvar;
si5338_read(cmd_ptr->addr, &tmpvar);
cmd_ptr->data = tmpvar;
} else if (isWrite) {
si5338_write(cmd_ptr->addr, cmd_ptr->data);
cmd_ptr->data = 0;
} else {
cmd_ptr->addr = 0;
cmd_ptr->data = 0;
}
cmd_ptr++;
}
}
const struct {
enum {
GDEV_UNKNOWN,
GDEV_GPIO,
GDEV_IQ_CORR_RX,
GDEV_IQ_CORR_TX,
GDEV_FPGA_VERSION,
GDEV_TIME_TIMER,
GDEV_VCTXCO,
GDEV_XB_LO,
GDEV_EXPANSION,
GDEV_EXPANSION_DIR,
} gdev;
int start, len;
} gdev_lut[] = {
{GDEV_GPIO, 0, 4},
{GDEV_IQ_CORR_RX, 4, 4},
{GDEV_IQ_CORR_TX, 8, 4},
{GDEV_FPGA_VERSION, 12, 4},
{GDEV_TIME_TIMER, 16, 16},
{GDEV_VCTXCO, 34, 2},
{GDEV_XB_LO, 36, 4},
{GDEV_EXPANSION, 40, 4},
{GDEV_EXPANSION_DIR, 44, 4},
};
#define ARRAY_SZ(x) (sizeof(x)/sizeof(x[0]))
#define COLLECT_BYTES(x) tmpvar &= ~ ( 0xff << ( 8 * cmd_ptr->addr)); \
tmpvar |= cmd_ptr->data << (8 * cmd_ptr->addr); \
if (lastByte) { x; tmpvar = 0; } \
cmd_ptr->data = 0;
if ((mode & UART_PKT_MODE_DEV_MASK) == UART_PKT_DEV_GPIO) {
uint32_t device;
int lut, lastByte;
for (i = 0; i < cnt; i++) {
device = GDEV_UNKNOWN;
lastByte = 0;
for (lut = 0; lut < ARRAY_SZ(gdev_lut); lut++) {
if (gdev_lut[lut].start <= cmd_ptr->addr && (gdev_lut[lut].start + gdev_lut[lut].len) > cmd_ptr->addr) {
cmd_ptr->addr -= gdev_lut[lut].start;
device = gdev_lut[lut].gdev;
lastByte = cmd_ptr->addr == (gdev_lut[lut].len - 1);
break;
}
}
if (isRead) {
if (device == GDEV_FPGA_VERSION)
cmd_ptr->data = (FPGA_VERSION >> (cmd_ptr->addr * 8));
else if (device == GDEV_TIME_TIMER)
cmd_ptr->data = IORD_8DIRECT(TIME_TAMER, cmd_ptr->addr);
else if (device == GDEV_GPIO)
cmd_ptr->data = (IORD_ALTERA_AVALON_PIO_DATA(PIO_0_BASE)) >> (cmd_ptr->addr * 8);
else if (device == GDEV_EXPANSION)
cmd_ptr->data = (IORD_ALTERA_AVALON_PIO_DATA(PIO_1_BASE)) >> (cmd_ptr->addr * 8);
else if (device == GDEV_EXPANSION_DIR)
cmd_ptr->data = (IORD_ALTERA_AVALON_PIO_DATA(PIO_2_BASE)) >> (cmd_ptr->addr * 8);
else if (device == GDEV_IQ_CORR_RX)
cmd_ptr->data = (IORD_ALTERA_AVALON_PIO_DATA(IQ_CORR_RX_PHASE_GAIN_BASE)) >> (cmd_ptr->addr * 8);
else if (device == GDEV_IQ_CORR_TX)
