/* Count # set bits (within STATE_MASK) */
static
int
numset( int mask )
{
int i, n = 0;
for( i = STATE_SHIFT + 1 ; i <= STATE_SHIFT + 9 ; ++i )
if( mask & BIT_N(i) )
++n;
else
++counts[ i - STATE_SHIFT - 1 ];
return n;
}
/*****************************************************************************
Function : HPA_BbpAwakeIsr
Description: Gsm&Wcdma Drx isr,Only used for asic platform
Input : void
Return : void
Other :
*****************************************************************************/
VOS_VOID HPA_3GSwitchClockIsr(VOS_VOID)
{
VOS_UINT32 ulBbpStatus;
VOS_UINT32 ulBeginSlice;
DRV_VICINT_DISABLE(g_ulWBBPSwtichIntNO);
ulBbpStatus = HPA_Read32Reg(WBBP_ARM_INT03_STA_ADDR);
/* Clear interrupt */
HPA_Write32Reg(WBBP_ARM_INT03_CLR_1CARD_ADDR, ulBbpStatus);
if(0 != ulBbpStatus)
{
ulBeginSlice = OM_GetSlice();
while((0 != HPA_Read32Reg(WBBP_ARM_INT03_STA_ADDR))
&&(BBP_DRX_INT_SLICE_COUNT > (OM_GetSlice() - ulBeginSlice)))
{
;
}
if( BIT_N(WSLEEP_64M_TO_32K_TYPE_BIT) & ulBbpStatus )
{
SLEEP_32KIsr(VOS_RATMODE_WCDMA);
}
else if (BIT_N(WSLEEP_32K_TO_64M_TYPE_BIT) & ulBbpStatus)
{
SLEEP_NormalClockIsr(VOS_RATMODE_WCDMA);
}
else
{
;
}
}
DRV_VICINT_ENABLE(g_ulWBBPSwtichIntNO);
return;
}
// LSL
//-----------------------------------------------------------------------------
TEMPLATE static u32 FASTCALL OP_LSL_0(const u32 i)
{
cpu->R[REG_NUM(i, 0)] = cpu->R[REG_NUM(i, 3)];
cpu->CPSR.bits.N = BIT31(cpu->R[REG_NUM(i, 0)]);
cpu->CPSR.bits.Z = cpu->R[REG_NUM(i, 0)] == 0;
return 1;
}
TEMPLATE static u32 FASTCALL OP_LSL(const u32 i)
{
u32 v = (i>>6) & 0x1F;
cpu->CPSR.bits.C = BIT_N(cpu->R[REG_NUM(i, 3)], 32-v);
cpu->R[REG_NUM(i, 0)] = (cpu->R[REG_NUM(i, 3)] << v);
cpu->CPSR.bits.N = BIT31(cpu->R[REG_NUM(i, 0)]);
cpu->CPSR.bits.Z = cpu->R[REG_NUM(i, 0)] == 0;
return 1;
}
TEMPLATE static u32 FASTCALL OP_LSL_REG(const u32 i)
{
u32 v = cpu->R[REG_NUM(i, 3)] & 0xFF;
if(v == 0)
{
cpu->CPSR.bits.N = BIT31(cpu->R[REG_NUM(i, 0)]);
cpu->CPSR.bits.Z = cpu->R[REG_NUM(i, 0)] == 0;
int cpu_carry(cpu_state_t *state)
{
return BIT_N(state->f, CARRY_BIT);
}
int cpu_subtract(cpu_state_t *state)
{
return BIT_N(state->f, SUBTRACT_BIT);
}
int cpu_half_carry(cpu_state_t *state)
{
return BIT_N(state->f, HALF_CARRY_BIT);
}
int cpu_zero(cpu_state_t *state)
{
return BIT_N(state->f, ZERO_BIT);
}
static void charging_display_info(bool animate)
{
unsigned char charging_logo[36];
const int pox_x = (LCD_WIDTH - sizeof(charging_logo)) / 2;
const int pox_y = 32;
static unsigned phase = 3;
unsigned i;
#ifdef NEED_ATA_POWER_BATT_MEASURE
if (ide_powered()) /* FM and V2 can only measure when ATA power is on */
#endif
{
int battv = battery_voltage();
lcd_putsf(0, 7, " Batt: %d.%02dV %d%% ", battv / 1000,
(battv % 1000) / 10, battery_level());
}
#ifdef ARCHOS_RECORDER
lcd_puts(0, 2, "Charge mode:");
const char *s;
if (charge_state == CHARGING)
s = str(LANG_BATTERY_CHARGE);
else if (charge_state == TOPOFF)
s = str(LANG_BATTERY_TOPOFF_CHARGE);
else if (charge_state == TRICKLE)
s = str(LANG_BATTERY_TRICKLE_CHARGE);
else
s = "not charging";
lcd_puts(0, 3, s);
if (!charger_enabled())
animate = false;
#endif /* ARCHOS_RECORDER */
/* middle part */
memset(charging_logo+3, 0x00, 32);
charging_logo[0] = 0x3C;
charging_logo[1] = 0x24;
charging_logo[2] = charging_logo[35] = 0xFF;
if (!animate)
{ /* draw the outline */
/* middle part */
lcd_mono_bitmap(charging_logo, pox_x, pox_y + 8,
sizeof(charging_logo), 8);
lcd_set_drawmode(DRMODE_FG);
/* upper line */
charging_logo[0] = charging_logo[1] = 0x00;
memset(charging_logo+2, 0x80, 34);
lcd_mono_bitmap(charging_logo, pox_x, pox_y, sizeof(charging_logo), 8);
/* lower line */
memset(charging_logo+2, 0x01, 34);
lcd_mono_bitmap(charging_logo, pox_x, pox_y + 16,
sizeof(charging_logo), 8);
lcd_set_drawmode(DRMODE_SOLID);
}
else
{ /* animate the middle part */
for (i = 3; i<MIN(sizeof(charging_logo)-1, phase); i++)
{
if ((i-phase) % 8 == 0)
{ /* draw a "bubble" here */
unsigned bitpos;
bitpos = (phase + i/8) % 15; /* "bounce" effect */
if (bitpos > 7)
bitpos = 14 - bitpos;
charging_logo[i] = BIT_N(bitpos);
}
}
lcd_mono_bitmap(charging_logo, pox_x, pox_y + 8,
sizeof(charging_logo), 8);
phase++;
}
lcd_update();
}
static long fp_atof(const char* s, int precision)
{
long int_part = 0;
long int_one = BIT_N(precision);
long frac_part = 0;
long frac_count = 0;
long frac_max = ((precision * 4) + 12) / 13;
long frac_max_int = 1;
long sign = 1;
bool point = false;
while ((*s != '\0') && isspace(*s))
{
s++;
}
if (*s == '-')
{
sign = -1;
s++;
}
else if (*s == '+')
{
s++;
}
while (*s != '\0')
{
if (*s == '.')
{
if (point)
{
break;
}
point = true;
}
else if (isdigit(*s))
{
if (point)
{
if (frac_count < frac_max)
{
frac_part = frac_part * 10 + (*s - '0');
frac_count++;
frac_max_int *= 10;
}
}
else
{
int_part = int_part * 10 + (*s - '0');
}
}
else
{
break;
}
s++;
}
while (frac_count < frac_max)
{
frac_part *= 10;
frac_count++;
frac_max_int *= 10;
}
return sign * ((int_part * int_one)
+ (((int64_t) frac_part * int_one) / frac_max_int));
}
static uint32_t update_pn(uint32_t cur)
{
return ((cur << 1) |
(BIT_N(cur, 27) ^ BIT_N(cur, 30))) & MASK_N(31);
}
static void fill_audio(void *udata, Uint8 *stream, int len)
{
sample_t *samples = (sample_t*)stream;
audio_t *audio = (audio_t*)udata;
int num_samples = len / (sizeof(sample_t));
for(int i = 0; i < num_samples; i++)
{
float t = audio->buffer_pos / (float)FREQUENCY;
int16_t val_l = 0;
int16_t val_r = 0;
uint8_t channels[4];
#if 1
if(audio->sq1.en)
{
channels[0] = square1(t, audio);
}
if(audio->sq2.en)
{
channels[1] = square2(t, audio);
}
if(audio->wave.en && audio->wave.power)
{
channels[2] = wave(t, audio);
}
#endif
#if 1
if (audio->noise.en)
{
channels[3] = noise(t, audio);
}
#endif
for(int i = 0; i < 4; i++)
{
int16_t v = DAC(channels[i]) / 4;
if(BIT_N(audio->control.r_en, i))
{
val_r += v;
}
if(BIT_N(audio->control.l_en, i))
{
val_l += v;
}
}
samples[i] = (sample_t) { .left = val_l / 4, .right = val_r / 4 };
audio->buffer_pos = (audio->buffer_pos + 1) % FREQUENCY;
}
}
static void init_wave_table(audio_t *audio)
{
const uint8_t wave_default_table[32] =
{
0x4, 0x8, 0x0, 0x4, 0x3, 0x4,0xA, 0xA,
0xD, 0x2, 0x8, 0x7, 0x2, 0x9,0xC, 0x3,
0x0, 0x6, 0x9, 0x5, 0x9, 0x5,0x0, 0xB,
0x4, 0x3, 0x8, 0xB, 0xE, 0x2,0xA, 0xD,
};
memcpy(audio->wave_table, wave_default_table, sizeof(audio->wave_table));
}
audio_t *audio_init(cpu_state_t *state)
{
audio_t *out = CALLOC(1, sizeof(audio_t));
out->state = state;
init_wave_table(out);
#if AUDIO
SDL_AudioSpec wanted;
/* Set the audio format */
wanted.freq = FREQUENCY;
wanted.format = AUDIO_S16;
wanted.channels = NUM_CHANNELS;
wanted.samples = NUM_SAMPLES;
wanted.callback = fill_audio;
wanted.userdata = out;
/* Open the audio device, forcing the desired format */
if ( SDL_OpenAudio(&wanted, NULL) < 0 )
{
log_error("Couldn't open audio: %s\n", SDL_GetError());
}
SDL_PauseAudio(0);
#endif
return out;
}
static int initialize_card(int card_no)
{
int rc, i;
int blk_exp, ts_exp, taac_exp;
tCardInfo *card = &card_info[card_no];
static const char mantissa[] = { /* *10 */
0, 10, 12, 13, 15, 20, 25, 30,
35, 40, 45, 50, 55, 60, 70, 80
};
static const int exponent[] = { /* use varies */
1, 10, 100, 1000, 10000, 100000, 1000000,
10000000, 100000000, 1000000000
};
if (card_no == 1)
mmc_status = MMC_TOUCHED;
/* switch to SPI mode */
if (send_cmd(CMD_GO_IDLE_STATE, 0, NULL) != 0x01)
return -1; /* error or no response */
/* initialize card */
for (i = HZ;;) /* try for 1 second*/
{
sleep(1);
if (send_cmd(CMD_SEND_OP_COND, 0, NULL) == 0)
break;
if (--i <= 0)
return -2; /* timeout */
}
/* get OCR register */
if (send_cmd(CMD_READ_OCR, 0, &card->ocr))
return -3;
card->ocr = betoh32(card->ocr); /* no-op on big endian */
/* check voltage */
if (!(card->ocr & 0x00100000)) /* 3.2 .. 3.3 V */
return -4;
/* get CSD register */
if (send_cmd(CMD_SEND_CSD, 0, NULL))
return -5;
rc = receive_cxd((unsigned char*)card->csd);
if (rc)
return rc * 10 - 5;
blk_exp = card_extract_bits(card->csd, 83, 4);
if (blk_exp < 9) /* block size < 512 bytes not supported */
return -6;
card->numblocks = (card_extract_bits(card->csd, 73, 12) + 1)
<< (card_extract_bits(card->csd, 49, 3) + 2 + blk_exp - 9);
card->blocksize = BLOCK_SIZE;
/* max transmission speed, clock divider */
ts_exp = card_extract_bits(card->csd, 98, 3);
ts_exp = (ts_exp > 3) ? 3 : ts_exp;
card->speed = mantissa[card_extract_bits(card->csd, 102, 4)]
* exponent[ts_exp + 4];
card->bitrate_register = (FREQ/4-1) / card->speed;
/* NSAC, TAAC, read timeout */
card->nsac = 100 * card_extract_bits(card->csd, 111, 8);
card->taac = mantissa[card_extract_bits(card->csd, 118, 4)];
taac_exp = card_extract_bits(card->csd, 114, 3);
card->read_timeout = ((FREQ/4) / (card->bitrate_register + 1)
* card->taac / exponent[9 - taac_exp]
+ (10 * card->nsac));
card->read_timeout /= 8; /* clocks -> bytes */
card->taac = card->taac * exponent[taac_exp] / 10;
/* r2w_factor, write timeout */
card->r2w_factor = BIT_N(card_extract_bits(card->csd, 28, 3));
card->write_timeout = card->read_timeout * card->r2w_factor;
if (card->r2w_factor > 32) /* Such cards often need extra read delay */
card->read_timeout *= 4;
/* switch to full speed */
setup_sci1(card->bitrate_register);
/* always use 512 byte blocks */
if (send_cmd(CMD_SET_BLOCKLEN, BLOCK_SIZE, NULL))
return -7;
/* get CID register */
if (send_cmd(CMD_SEND_CID, 0, NULL))
return -8;
rc = receive_cxd((unsigned char*)card->cid);
if (rc)
return rc * 10 - 8;
card->initialized = true;
return 0;
}
