static void dec_bi(DisasContext *dc)
{
LOG_DIS("bi %d\n", sign_extend(dc->imm26 << 2, 26));
gen_goto_tb(dc, 0, dc->pc + (sign_extend(dc->imm26 << 2, 26)));
dc->is_jmp = DISAS_TB_JUMP;
}
static void dec_calli(DisasContext *dc)
{
LOG_DIS("calli %d\n", sign_extend(dc->imm26, 26) * 4);
tcg_gen_movi_tl(cpu_R[R_RA], dc->pc + 4);
gen_goto_tb(dc, 0, dc->pc + (sign_extend(dc->imm26 << 2, 26)));
dc->is_jmp = DISAS_TB_JUMP;
}
static void dec_lw(DisasContext *dc)
{
TCGv t0;
LOG_DIS("lw r%d, (r%d+%d)\n", dc->r1, dc->r0, sign_extend(dc->imm16, 16));
t0 = tcg_temp_new();
tcg_gen_addi_tl(t0, cpu_R[dc->r0], sign_extend(dc->imm16, 16));
tcg_gen_qemu_ld32s(cpu_R[dc->r1], t0, MEM_INDEX);
tcg_temp_free(t0);
}
static void dec_sw(DisasContext *dc)
{
TCGv t0;
LOG_DIS("sw (r%d+%d), r%d\n", dc->r0, sign_extend(dc->imm16, 16), dc->r1);
t0 = tcg_temp_new();
tcg_gen_addi_tl(t0, cpu_R[dc->r0], sign_extend(dc->imm16, 16));
tcg_gen_qemu_st32(cpu_R[dc->r1], t0, MEM_INDEX);
tcg_temp_free(t0);
}
/**
* sensor_convert_from_raw: convert raw sensor values to interpreted values.
* It can be used to convert raw data, raw thresholds or raw hysteresis of a sensor
* to human readable format.
*
* @sensor: sensor.
* @val: raw sensor value.
* @result: the interpreted value
*
* Return value: SA_OK if conversion possible
**/
SaErrorT
sensor_convert_from_raw (SaHpiSensorRecT *sensor,
SaHpiUint32T val,
SaHpiFloat32T *result)
{
SaHpiFloat32T m, b, b_exp, r_exp, fval;
linearizer c_func;
SaHpiSensorFactorsT *factors = &sensor->DataFormat.Factors;
if ( factors->Linearization == SAHPI_SL_NONLINEAR )
c_func = c_linear;
else if ( factors->Linearization <= 11 )
c_func = linearize[factors->Linearization];
else
return SA_ERR_HPI_INVALID_DATA;
val &= 0xff;
m = (SaHpiFloat32T)factors->M_Factor;
b = (SaHpiFloat32T)factors->B_Factor;
r_exp = (SaHpiFloat32T)factors->ExpR;
b_exp = (SaHpiFloat32T)factors->ExpB;
switch( sensor->DataFormat.SignFormat ) {
case SAHPI_SDF_UNSIGNED:
fval = (SaHpiFloat32T)val;
break;
case SAHPI_SDF_1S_COMPLEMENT:
val = sign_extend( val, 8 );
if ( val < 0 )
val += 1;
fval = (SaHpiFloat32T)val;
break;
case SAHPI_SDF_2S_COMPLEMENT:
fval = (SaHpiFloat32T)sign_extend( val, 8 );
break;
default:
return SA_ERR_HPI_INVALID_DATA;
}
*result = c_func( ((m * fval) + (b * pow(10, b_exp)))
* pow(10, r_exp) );
return SA_OK;
}
static void dec_bg(DisasContext *dc)
{
LOG_DIS("bg r%d, r%d, %d\n", dc->r0, dc->r1,
sign_extend(dc->imm16, 16 * 4));
gen_cond_branch(dc, TCG_COND_GT);
}
static int paf_audio_decode(AVCodecContext *avctx, void *data,
int *got_frame, AVPacket *pkt)
{
AVFrame *frame = data;
int16_t *output_samples;
const uint8_t *src = pkt->data;
int frames, ret, i, j;
int16_t cb[256];
frames = pkt->size / PAF_SOUND_FRAME_SIZE;
if (frames < 1)
return AVERROR_INVALIDDATA;
frame->nb_samples = PAF_SOUND_SAMPLES * frames;
if ((ret = ff_get_buffer(avctx, frame, 0)) < 0)
return ret;
output_samples = (int16_t *)frame->data[0];
// codebook of 256 16-bit samples and 8-bit indices to it
for (j = 0; j < frames; j++) {
for (i = 0; i < 256; i++)
cb[i] = sign_extend(AV_RL16(src + i * 2), 16);
src += 256 * 2;
// always 2 channels
for (i = 0; i < PAF_SOUND_SAMPLES * 2; i++)
*output_samples++ = cb[*src++];
}
*got_frame = 1;
return pkt->size;
}
static int cinaudio_decode_frame(AVCodecContext *avctx, void *data,
int *got_frame_ptr, AVPacket *avpkt)
{
AVFrame *frame = data;
const uint8_t *buf = avpkt->data;
CinAudioContext *cin = avctx->priv_data;
const uint8_t *buf_end = buf + avpkt->size;
int16_t *samples;
int delta, ret;
/* get output buffer */
frame->nb_samples = avpkt->size - cin->initial_decode_frame;
if ((ret = ff_get_buffer(avctx, frame, 0)) < 0)
return ret;
samples = (int16_t *)frame->data[0];
delta = cin->delta;
if (cin->initial_decode_frame) {
cin->initial_decode_frame = 0;
delta = sign_extend(AV_RL16(buf), 16);
buf += 2;
*samples++ = delta;
}
while (buf < buf_end) {
delta += cinaudio_delta16_table[*buf++];
delta = av_clip_int16(delta);
*samples++ = delta;
}
cin->delta = delta;
*got_frame_ptr = 1;
return avpkt->size;
}
static void dec_bne(DisasContext *dc)
{
LOG_DIS("bne r%d, r%d, %d\n", dc->r0, dc->r1,
sign_extend(dc->imm16, 16) * 4);
gen_cond_branch(dc, TCG_COND_NE);
}
static void dec_bgeu(DisasContext *dc)
{
LOG_DIS("bgeu r%d, r%d, %d\n", dc->r1, dc->r0,
sign_extend(dc->imm16, 16) * 4);
gen_cond_branch(dc, TCG_COND_GEU);
}
int ff_h263_decode_motion(MpegEncContext * s, int pred, int f_code)
{
int code, val, sign, shift;
code = get_vlc2(&s->gb, mv_vlc.table, MV_VLC_BITS, 2);
if (code == 0)
return pred;
if (code < 0)
return 0xffff;
sign = get_bits1(&s->gb);
shift = f_code - 1;
val = code;
if (shift) {
val = (val - 1) << shift;
val |= get_bits(&s->gb, shift);
val++;
}
if (sign)
val = -val;
val += pred;
/* modulo decoding */
if (!s->h263_long_vectors) {
val = sign_extend(val, 5 + f_code);
} else {
/* horrible h263 long vector mode */
if (pred < -31 && val < -63)
val += 64;
if (pred > 32 && val > 63)
val -= 64;
}
return val;
}
CORE_ADDR
arm_wince_skip_main_prologue (struct gdbarch *gdbarch, CORE_ADDR pc)
{
enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
ULONGEST this_instr;
this_instr = read_memory_unsigned_integer (pc, 4, byte_order);
/* bl offset <__gccmain> */
if ((this_instr & 0xfff00000) == 0xeb000000)
{
#define sign_extend(V, N) \
(((long) (V) ^ (1L << ((N) - 1))) - (1L << ((N) - 1)))
long offset = sign_extend (this_instr & 0x000fffff, 23) << 2;
CORE_ADDR call_dest = (pc + 8 + offset) & 0xffffffffU;
struct minimal_symbol *s = lookup_minimal_symbol_by_pc (call_dest);
if (s != NULL
&& SYMBOL_LINKAGE_NAME (s) != NULL
&& strcmp (SYMBOL_LINKAGE_NAME (s), "__gccmain") == 0)
pc += 4;
}
return pc;
}
static void twl6030battery_current(struct twl6030_bci_device_info *di)
{
int ret = 0;
u16 read_value = 0;
s16 temp = 0;
int current_now = 0;
/* FG_REG_10, 11 is 14 bit signed instantaneous current sample value */
ret = twl_i2c_read(TWL6030_MODULE_GASGAUGE, (u8 *)&read_value,
FG_REG_10, 2);
if (ret < 0) {
dev_dbg(di->dev, "failed to read FG_REG_10: current_now\n");
return;
}
temp = sign_extend(read_value, 14);
current_now = temp - di->cc_offset;
/* current drawn per sec */
current_now = current_now * fuelgauge_rate[0 /*di->fuelgauge_mode*/];
/* current in mAmperes */
current_now = (current_now * 3000) >> 14;
/* current in uAmperes */
current_now = current_now * 1000;
di->current_uA = current_now;
return;
}
/* LB: Load Byte */
fastcall void MTS_PROTO(lb)(cpu_mips_t *cpu,m_uint64_t vaddr,u_int reg)
{
m_uint64_t data;
void *haddr;
haddr = MTS_PROTO(access)(cpu,vaddr,MIPS_MEMOP_LB,1,MTS_READ,&data);
if (likely(haddr != NULL)) data = *(m_uint8_t *)haddr;
cpu->gpr[reg] = sign_extend(data,8);
}
void fastcall mips_cp0_exec_mfc0_fastcall (cpu_mips_t * cpu,
mips_insn_t insn)
{
int rt = bits (insn, 16, 20);
int rd = bits (insn, 11, 15);
int sel = bits (insn, 0, 2);
cpu->reg_set (cpu, rt, sign_extend (mips_cp0_get_reg_fast (cpu, rd, sel), 32));
}
/* LW: Load Word */
fastcall void MTS_PROTO(lw)(cpu_mips_t *cpu,m_uint64_t vaddr,u_int reg)
{
m_uint64_t data;
void *haddr;
haddr = MTS_PROTO(access)(cpu,vaddr,MIPS_MEMOP_LW,4,MTS_READ,&data);
if (likely(haddr != NULL)) data = vmtoh32(*(m_uint32_t *)haddr);
cpu->gpr[reg] = sign_extend(data,32);
}
static inline void gen_cond_branch(DisasContext *dc, int cond)
{
TCGLabel *l1 = gen_new_label();
tcg_gen_brcond_tl(cond, cpu_R[dc->r0], cpu_R[dc->r1], l1);
gen_goto_tb(dc, 0, dc->pc + 4);
gen_set_label(l1);
gen_goto_tb(dc, 1, dc->pc + (sign_extend(dc->imm16 << 2, 16)));
dc->is_jmp = DISAS_TB_JUMP;
}
static int twl6030_read_gasguage_regs(struct twl6030_bci_device_info *di)
{
int ret;
u32 data[2];
#if 0
s16 integ;
ret = twl_i2c_read_u8(TWL6030_MODULE_GASGAUGE, (u8 *) data, FG_REG_00);
if (ret < 0) {
pr_err("twl6030: failed to read gasgauge config\n");
goto done;
}
#endif
/* must pause updates while reading multibyte registers to avoid bogus data */
ret = twl_i2c_write_u8(TWL6030_MODULE_GASGAUGE, CC_PAUSE, FG_REG_00);
if (ret < 0) {
pr_err("twl6030: cannot pause gasgauge\n");
goto done;
}
ret = twl_i2c_read(TWL6030_MODULE_GASGAUGE, ((u8*) data) + 1, FG_REG_01, 7);
if (ret < 0) {
pr_err("twl6030: cannot read gasgauge\n");
goto err;
}
di->timer_n1 = data[0] >> 8; /* FG_REG_{01..03} is 24 bit unsigned sample counter */
di->charge_n1 = data[1]; /* FG_REG_{04..07} is 32 bit signed accumulator */
#if 0
ret = twl_i2c_read(TWL6030_MODULE_GASGAUGE, (u8 *) &integ, FG_REG_10, 2);
if (ret < 0) {
pr_err("twl6030: failed to read integrator\n");
goto err;
}
/* sign extend the value */
integ = sign_extend(integ, 14);
printk("battery: data[0] = %08x data[1] = %08x\n", data[0], data[1]);
printk("battery: integ = %02x (%d)\n", (unsigned) integ, (int) integ);
#endif
err:
ret = twl_i2c_write_u8(TWL6030_MODULE_GASGAUGE, 0, FG_REG_00);
if (ret < 0) {
pr_err("twl6030: cannot resume gasgauge\n");
}
done:
return ret;
}
/* Execute a memory operation (2) */
static int forced_inline mips_exec_memop2 (cpu_mips_t * cpu, int memop,
m_va_t base, int offset, u_int dst_reg, int keep_ll_bit)
{
m_va_t vaddr = cpu->gpr[base] + sign_extend (offset, 16);
mips_memop_fn fn;
if (!keep_ll_bit)
cpu->ll_bit = 0;
fn = cpu->mem_op_fn[memop];
return (fn (cpu, vaddr, dst_reg));
}
static void dec_cmpne(DisasContext *dc)
{
if (dc->format == OP_FMT_RI) {
LOG_DIS("cmpnei r%d, r%d, %d\n", dc->r0, dc->r1,
sign_extend(dc->imm16, 16));
} else {
LOG_DIS("cmpne r%d, r%d, r%d\n", dc->r2, dc->r0, dc->r1);
}
gen_compare(dc, TCG_COND_NE);
}
static void dec_mul(DisasContext *dc)
{
if (dc->format == OP_FMT_RI) {
LOG_DIS("muli r%d, r%d, %d\n", dc->r0, dc->r1,
sign_extend(dc->imm16, 16));
} else {
LOG_DIS("mul r%d, r%d, r%d\n", dc->r2, dc->r0, dc->r1);
}
if (!(dc->features & LM32_FEATURE_MULTIPLY)) {
qemu_log_mask(LOG_GUEST_ERROR,
"hardware multiplier is not available\n");
t_gen_illegal_insn(dc);
return;
}
if (dc->format == OP_FMT_RI) {
tcg_gen_muli_tl(cpu_R[dc->r1], cpu_R[dc->r0],
sign_extend(dc->imm16, 16));
} else {
tcg_gen_mul_tl(cpu_R[dc->r2], cpu_R[dc->r0], cpu_R[dc->r1]);
}
}
static void dec_add(DisasContext *dc)
{
if (dc->format == OP_FMT_RI) {
if (dc->r0 == R_R0) {
if (dc->r1 == R_R0 && dc->imm16 == 0) {
LOG_DIS("nop\n");
} else {
LOG_DIS("mvi r%d, %d\n", dc->r1, sign_extend(dc->imm16, 16));
}
} else {
LOG_DIS("addi r%d, r%d, %d\n", dc->r1, dc->r0,
sign_extend(dc->imm16, 16));
}
} else {
LOG_DIS("add r%d, r%d, r%d\n", dc->r2, dc->r0, dc->r1);
}
if (dc->format == OP_FMT_RI) {
tcg_gen_addi_tl(cpu_R[dc->r1], cpu_R[dc->r0],
sign_extend(dc->imm16, 16));
} else {
tcg_gen_add_tl(cpu_R[dc->r2], cpu_R[dc->r0], cpu_R[dc->r1]);
}
}
void print_code_immed( int opcode, int imme ) {
int se_imme = (sign_extend(imme));
switch( opcode ) {
case op_call:
printf("call %d\n", se_imme); break;
case op_jump:
printf("jump %d\n", se_imme); break;
case op_mova:
printf("mova %d\n", se_imme); break;
case op_movb:
printf("movb %d\n", se_imme); break;
case op_push:
printf("push %d\n", se_imme); break;
default:
break;
}
}
static int twl6030_calibrate_fuelgauge(struct twl6030_bci_device_info *di)
{
s16 cc_offset;
int n, ret;
u8 reg;
ret = twl_i2c_write_u8(TWL6030_MODULE_GASGAUGE, CC_AUTOCLEAR, FG_REG_00);
if (ret)
goto err;
/* ensure autoclear completes before we calibrate */
msleep(300);
ret = twl_i2c_write_u8(TWL6030_MODULE_GASGAUGE, CC_CAL_EN, FG_REG_00);
if (ret)
goto err;
/* TODO: use IRQ to detect complete, plus timeout in case of failure */
for (n = 0; n < 25; n++) {
ret = twl_i2c_read_u8(TWL6030_MODULE_GASGAUGE, ®, FG_REG_00);
if (ret)
goto err;
if ((reg & CC_CAL_EN) == 0) break;
msleep(100);
}
/* FG_REG_08, 09 is 10 bit signed calibration offset value */
ret = twl_i2c_read(TWL6030_MODULE_GASGAUGE, (u8 *) &cc_offset, FG_REG_08, 2);
if (ret < 0)
goto err;
cc_offset = sign_extend(cc_offset, 10);
di->cc_offset = cc_offset;
printk("battery: calibration took %d ms, offset = %d\n", n * 100, cc_offset);
di->charge_n1 = 0;
di->timer_n1 = 0;
return 0;
err:
return ret;
}
static taddr read_number(void)
{
taddr val;
uint8_t n,*q;
int size;
if ((n = *p++) <= 0x7f)
return (taddr)n;
val = 0;
if (n -= 0x80) {
size = n << 3;
p += n;
q = p;
while (n--)
val = (val<<8) | *(--q);
val = sign_extend(val,size);
}
return val;
}
static inline void gen_compare(DisasContext *dc, int cond)
{
int i;
if (dc->format == OP_FMT_RI) {
switch (cond) {
case TCG_COND_GEU:
case TCG_COND_GTU:
i = zero_extend(dc->imm16, 16);
break;
default:
i = sign_extend(dc->imm16, 16);
break;
}
tcg_gen_setcondi_tl(cond, cpu_R[dc->r1], cpu_R[dc->r0], i);
} else {
tcg_gen_setcond_tl(cond, cpu_R[dc->r2], cpu_R[dc->r0], cpu_R[dc->r1]);
}
}
void Step(void)
{
/* fetch instruction from memory */
Halt = instruction_fetch(PC,Mem,&instruction);
if(!Halt)
{
/* partition the instruction */
instruction_partition(instruction,&op,&r1,&r2,&r3,&funct,&offset,&jsec);
/* instruction decode */
Halt = instruction_decode(op,&controls);
}
if(!Halt)
{
/* read_register */
read_register(r1,r2,Reg,&data1,&data2);
/* sign_extend */
sign_extend(offset,&extended_value);
/* ALU */
Halt = ALU_operations(data1,data2,extended_value,funct,controls.ALUOp,controls.ALUSrc,&ALUresult,&Zero);
}
if(!Halt)
{
/* read/write memory */
Halt = rw_memory(ALUresult,data2,controls.MemWrite,controls.MemRead,&memdata,Mem);
}
if(!Halt)
{
/* write to register */
write_register(r2,r3,memdata,ALUresult,controls.RegWrite,controls.RegDst,controls.MemtoReg,Reg);
/* PC update */
PC_update(jsec,extended_value,controls.Branch,controls.Jump,Zero,&PC);
}
}
/* LWL: Load Word Left */
fastcall void MTS_PROTO(lwl)(cpu_mips_t *cpu,m_uint64_t vaddr,u_int reg)
{
m_uint64_t r_mask,naddr;
m_uint64_t data;
u_int m_shift;
void *haddr;
naddr = vaddr & ~(0x03);
haddr = MTS_PROTO(access)(cpu,naddr,MIPS_MEMOP_LWL,4,MTS_READ,&data);
if (likely(haddr != NULL))
data = vmtoh32(*(m_uint32_t *)haddr);
m_shift = (vaddr & 0x03) << 3;
r_mask = (1ULL << m_shift) - 1;
data <<= m_shift;
cpu->gpr[reg] &= r_mask;
cpu->gpr[reg] |= data;
cpu->gpr[reg] = sign_extend(cpu->gpr[reg],32);
}
void bl_inst(int inst, ARMProc *proc) {
int l;
int signed_immed_24;
int branch_addr;
if(!check_condition(proc, inst))
return;
l = getbit(inst, 24);
signed_immed_24 = getbits(inst, 0, 24);
if(l) {
*proc->lr = *proc->pc;
}
branch_addr = sign_extend(signed_immed_24, 24, 30);
branch_addr <<= 2;
*proc->pc += 4 + branch_addr;
}
static taddr read_number(int is_signed)
{
int bitcnt;
taddr val;
uint8_t n,*q;
if ((n = *p++) <= 0x7f)
return (taddr)n;
val = 0;
if (n -= 0x80) {
p += n;
q = p;
bitcnt = n << 3;
while (n--)
val = (val<<8) | *(--q);
if (is_signed)
val = sign_extend(val,bitcnt);
}
return val;
}
