static int cmd_info_r() {
int i;
for (i = 0; i < 8; i++) {
printf("%s\t%#10x\t%10d\t", regsl[i], reg_l(i), reg_l(i));
printf("%s\t%#6x\t%5d", regsw[i], reg_w(i), reg_w(i));
if (i < 4) {
printf("\t%s\t%#4x\t%3d\t", regsb[i|4], reg_b(i|4), reg_b(i|4));
printf("%s\t%#4x\t%3d\n", regsb[i], reg_b(i), reg_b(i));
} else printf("\n");
}
for (i = 0; i < 6; i++) {
printf("%s\t%#6x: base = %#10x, limit = %#10x\n", regss[i], cpu.sr[i].sel, cpu.sr[i].base, cpu.sr[i].limit);
}
printf("eflags\t%#10x [%s%s%s%s%s%s%s ]\n", cpu.eflags,
cpu.cf ? "CF" : "",
cpu.pf ? "PF" : "",
cpu.zf ? "ZF" : "",
cpu.sf ? "SF" : "",
cpu.ief? "IF" : "",
cpu.df ? "DF" : "",
cpu.of ? "OF" : ""
);
printf("eip\t%#10x\n", cpu.eip);
printf("cr0\t%#10x\tcr3\t%#10x\n", cpu.cr0.value, cpu.cr3);
printf("gdtr:\tbase = %#10x, limit = %#10x\nidtr:\tbase = %#10x, limit = %#10x\n", cpu.gdtr.base, cpu.gdtr.limit, cpu.idtr.base, cpu.idtr.limit);
return 0;
}
static void w9968cf_set_crop_window(struct sd *sd)
{
int start_cropx, start_cropy, x, y, fw, fh, cw, ch,
max_width, max_height;
if (sd->sif) {
max_width = 352;
max_height = 288;
} else {
max_width = 640;
max_height = 480;
}
if (sd->sensor == SEN_OV7620) {
/*
* Sigh, this is dependend on the clock / framerate changes
* made by the frequency control, sick.
*
* Note we cannot use v4l2_ctrl_g_ctrl here, as we get called
* from ov519.c:setfreq() with the ctrl lock held!
*/
if (sd->freq->val == 1) {
start_cropx = 277;
start_cropy = 37;
} else {
start_cropx = 105;
start_cropy = 37;
}
} else {
start_cropx = 320;
start_cropy = 35;
}
/* Work around to avoid FP arithmetics */
#define SC(x) ((x) << 10)
/* Scaling factors */
fw = SC(sd->gspca_dev.pixfmt.width) / max_width;
fh = SC(sd->gspca_dev.pixfmt.height) / max_height;
cw = (fw >= fh) ? max_width : SC(sd->gspca_dev.pixfmt.width) / fh;
ch = (fw >= fh) ? SC(sd->gspca_dev.pixfmt.height) / fw : max_height;
sd->sensor_width = max_width;
sd->sensor_height = max_height;
x = (max_width - cw) / 2;
y = (max_height - ch) / 2;
reg_w(sd, 0x10, start_cropx + x);
reg_w(sd, 0x11, start_cropy + y);
reg_w(sd, 0x12, start_cropx + x + cw);
reg_w(sd, 0x13, start_cropy + y + ch);
}
int DebugPutChar(register int chr)
{
if (chr == '\n')
DebugPutChar('\r');
while ((reg_r(SERDATR) & SERDATR_TBE) == 0);
reg_w(INTREQ, INTF_TBE);
/* Output a char to the debug UART */
reg_w(SERDAT, SERDAT_STP8 | SERDAT_DB8(chr));
return 1;
}
/*
* @describe get the value of the reg
* @param {string} reg
* @return {uint32_t}
*/
uint32_t getreg(char* reg) {
uint32_t res;
if(!strcmp(reg, "$eax")) res = cpu.eax;
else if(!strcmp(reg, "$ecx")) res = cpu.ecx;
else if(!strcmp(reg, "$edx")) res = cpu.edx;
else if(!strcmp(reg, "$ebx")) res = cpu.ebx;
else if(!strcmp(reg, "$esp")) res = cpu.esp;
else if(!strcmp(reg, "$ebp")) res = cpu.ebp;
else if(!strcmp(reg, "$esi")) res = cpu.esi;
else if(!strcmp(reg, "$edi")) res = cpu.edi;
else if(!strcmp(reg, "$eip")) res = cpu.eip;
else if(!strcmp(reg, "$ax")) res = reg_w(0);
else if(!strcmp(reg, "$cx")) res = reg_w(1);
else if(!strcmp(reg, "$dx")) res = reg_w(2);
else if(!strcmp(reg, "$bx")) res = reg_w(3);
else if(!strcmp(reg, "$sp")) res = reg_w(4);
else if(!strcmp(reg, "$bp")) res = reg_w(5);
else if(!strcmp(reg, "$si")) res = reg_w(6);
else if(!strcmp(reg, "$di")) res = reg_w(7);
else if(!strcmp(reg, "$al")) res = reg_b(0);
else if(!strcmp(reg, "$cl")) res = reg_b(1);
else if(!strcmp(reg, "$dl")) res = reg_b(2);
else if(!strcmp(reg, "$bl")) res = reg_b(3);
else if(!strcmp(reg, "$ah")) res = reg_b(4);
else if(!strcmp(reg, "$ch")) res = reg_b(5);
else if(!strcmp(reg, "$dh")) res = reg_b(6);
else if(!strcmp(reg, "$bh")) res = reg_b(7);
else assert(0);
return res;
}
/*--------------------------------------------------------------------------
Upload quantization tables for the JPEG compression.
This function is called by w9968cf_start_transfer().
Return 0 on success, a negative number otherwise.
--------------------------------------------------------------------------*/
static void w9968cf_upload_quantizationtables(struct sd *sd)
{
u16 a, b;
int i, j;
reg_w(sd, 0x39, 0x0010); /* JPEG clock enable */
for (i = 0, j = 0; i < 32; i++, j += 2) {
a = Y_QUANTABLE[j] | ((unsigned)(Y_QUANTABLE[j + 1]) << 8);
b = UV_QUANTABLE[j] | ((unsigned)(UV_QUANTABLE[j + 1]) << 8);
reg_w(sd, 0x40 + i, a);
reg_w(sd, 0x60 + i, b);
}
reg_w(sd, 0x39, 0x0012); /* JPEG encoder enable */
}
int read_ModR_M(swaddr_t eip, Operand *rm, Operand *reg) {
ModR_M m;
m.val = instr_fetch(eip, 1);
// Log("m.val = %02x", m.val);
reg->type = OP_TYPE_REG;
reg->reg = m.reg;
if(m.mod == 3) {
rm->type = OP_TYPE_REG;
rm->reg = m.R_M;
switch(rm->size) {
case 1: rm->val = reg_b(m.R_M); break;
case 2: rm->val = reg_w(m.R_M); break;
case 4: rm->val = reg_l(m.R_M); break;
default: assert(0);
}
#ifdef DEBUG
switch(rm->size) {
case 1: sprintf(rm->str, "%%%s", regsb[m.R_M]); break;
case 2: sprintf(rm->str, "%%%s", regsw[m.R_M]); break;
case 4: sprintf(rm->str, "%%%s", regsl[m.R_M]); break;
}
#endif
return 1;
}
else {
int instr_len = load_addr(eip, &m, rm);
rm->val = swaddr_read(rm->addr, rm->size, R_DS); //TODO DS or SS
return instr_len;
}
}
static int cmd_info(char *args) {
int i;
if(strcmp(args, "r") == 0) {
for(i=0;i<8;i++){
printf("%s-%08x\n", regsl[i], reg_l(i));
}
for(i=0;i<8;i++){
printf("%s-%04x\n", regsw[i], reg_w(i));
}
for(i=0;i<8;i++){
printf("%s-%02x\n", regsb[i], reg_b(i));
}
printf("eip-%x\n", cpu.eip);
}
else if( strcmp(args, "w") == 0 ){
WP* temp = head;
while(temp != NULL){
printf("%d, %s, %d\n", temp->NO, temp->addr, temp->old_value);
temp = temp->next;
}
}
else
printf("Something's wrong:-(\n");
return 0;
}
void DebugInit(void)
{
/* Set DTR, RTS, etc */
volatile UBYTE *ciab_pra = (APTR)0xBFD000;
volatile UBYTE *ciab_ddra = (APTR)0xBFD200;
*ciab_ddra = 0xc0; /* Only DTR and RTS are driven as outputs */
*ciab_pra = 0; /* Turn on DTR and RTS */
/* Set the debug UART to 115200 */
reg_w(SERPER, SERPER_BAUD(SERPER_BASE_PAL, 115200));
}
void vdp_ctrl_w(unsigned int data)
{
if (pending == 0)
{
if ((data & 0xC000) == 0x8000)
{
/* VDP register write */
uint8 r = (data >> 8) & 0x1F;
uint8 d = data & 0xFF;
reg_w(r,d);
}
else pending = 1;
static int cmd_info(char *args) {
char command;
if(args == NULL){
printf("please input arguments\n");
return 0;
}
if(sscanf(args,"%c",&command) != 1){
printf("wrong argument\n");
return 0;
}
if(command == 'r'){
//print the rigisters
int i = 0;
for(i = 0;i < 8; ++i){
printf("%s\t0x%x\t\t%u\n",regsl[i],reg_l(i),reg_l(i));
}
for(i = 0;i < 8; ++i){
printf("%s\t0x%x\t\t%u\n",regsw[i],reg_w(i),reg_w(i));
}
for(i = 0;i < 8; ++i){
printf("%s\t0x%x\t\t%u\n",regsb[i],reg_b(i),reg_b(i));
}
printf("eip\t0x%x\t%d\n",cpu.eip,cpu.eip);
printf("eflags\t0x%8x\t%d\n",cpu.eflags, cpu.eflags);
printf("CF\t%x\n",cpu.CF);
printf("PF\t%x\n",cpu.PF);
printf("ZF\t%x\n",cpu.ZF);
printf("SF\t%x\n",cpu.SF);
printf("IF\t%x\n",cpu.IF);
printf("DF\t%x\n",cpu.DF);
printf("OF\t%x\n",cpu.OF);
}else if(command == 'w'){
//打印监视点信息
print_wp();
}else{
printf("Unknown command: info %c\n",command);
}
return 0;
}
/*--------------------------------------------------------------------------
Turn on the LED on some webcams. A beep should be heard too.
Return 0 on success, a negative number otherwise.
--------------------------------------------------------------------------*/
static void w9968cf_configure(struct sd *sd)
{
reg_w(sd, 0x00, 0xff00); /* power-down */
reg_w(sd, 0x00, 0xbf17); /* reset everything */
reg_w(sd, 0x00, 0xbf10); /* normal operation */
reg_w(sd, 0x01, 0x0010); /* serial bus, SDS high */
reg_w(sd, 0x01, 0x0000); /* serial bus, SDS low */
reg_w(sd, 0x01, 0x0010); /* ..high 'beep-beep' */
reg_w(sd, 0x01, 0x0030); /* Set sda scl to FSB mode */
sd->stopped = 1;
}
int DebugMayGetChar(void)
{
int c;
if ((reg_r(SERDATR) & SERDATR_RBF) == 0)
return -1;
c = SERDATR_DB8_of(reg_r(SERDATR));
/* Clear RBF */
reg_w(INTREQ, INTF_RBF);
return c;
}
void vdp_restore(uint8 *vdp_regs)
{
int i;
for (i=0;i<0x20;i++)
{
reg_w(i, vdp_regs[i]);
}
/* reinitialize HVC tables */
vctab = (vdp_pal) ? ((reg[1] & 8) ? vc_pal_240 : vc_pal_224) : vc_ntsc_224;
hctab = (reg[12] & 1) ? cycle2hc40 : cycle2hc32;
/* reinitialize overscan area */
bitmap.viewport.x = config.overscan ? 14 : 0;
bitmap.viewport.y = config.overscan ? (((reg[1] & 8) ? 0 : 8) + (vdp_pal ? 24 : 0)) : 0;
bitmap.viewport.changed = 2;
/* restore VDP timings */
fifo_latency = (reg[12] & 1) ? 27 : 30;
if ((code & 0x0F) == 0x01) fifo_latency = fifo_latency * 2;
/* remake cache */
for (i=0;i<0x800;i++)
{
bg_name_list[i]=i;
bg_name_dirty[i]=0xFF;
}
bg_list_index=0x800;
/* reinitialize palette */
color_update(0x00, *(uint16 *)&cram[border << 1]);
for(i = 1; i < 0x40; i += 1)
{
color_update(i, *(uint16 *)&cram[i << 1]);
}
}
static void w9968cf_init(struct sd *sd)
{
unsigned long hw_bufsize = sd->sif ? (352 * 288 * 2) : (640 * 480 * 2),
y0 = 0x0000,
u0 = y0 + hw_bufsize / 2,
v0 = u0 + hw_bufsize / 4,
y1 = v0 + hw_bufsize / 4,
u1 = y1 + hw_bufsize / 2,
v1 = u1 + hw_bufsize / 4;
reg_w(sd, 0x00, 0xff00); /* power off */
reg_w(sd, 0x00, 0xbf10); /* power on */
reg_w(sd, 0x03, 0x405d); /* DRAM timings */
reg_w(sd, 0x04, 0x0030); /* SDRAM timings */
reg_w(sd, 0x20, y0 & 0xffff); /* Y buf.0, low */
reg_w(sd, 0x21, y0 >> 16); /* Y buf.0, high */
reg_w(sd, 0x24, u0 & 0xffff); /* U buf.0, low */
reg_w(sd, 0x25, u0 >> 16); /* U buf.0, high */
reg_w(sd, 0x28, v0 & 0xffff); /* V buf.0, low */
reg_w(sd, 0x29, v0 >> 16); /* V buf.0, high */
reg_w(sd, 0x22, y1 & 0xffff); /* Y buf.1, low */
reg_w(sd, 0x23, y1 >> 16); /* Y buf.1, high */
reg_w(sd, 0x26, u1 & 0xffff); /* U buf.1, low */
reg_w(sd, 0x27, u1 >> 16); /* U buf.1, high */
reg_w(sd, 0x2a, v1 & 0xffff); /* V buf.1, low */
reg_w(sd, 0x2b, v1 >> 16); /* V buf.1, high */
reg_w(sd, 0x32, y1 & 0xffff); /* JPEG buf 0 low */
reg_w(sd, 0x33, y1 >> 16); /* JPEG buf 0 high */
reg_w(sd, 0x34, y1 & 0xffff); /* JPEG buf 1 low */
reg_w(sd, 0x35, y1 >> 16); /* JPEG bug 1 high */
reg_w(sd, 0x36, 0x0000);/* JPEG restart interval */
reg_w(sd, 0x37, 0x0804);/*JPEG VLE FIFO threshold*/
reg_w(sd, 0x38, 0x0000);/* disable hw up-scaling */
reg_w(sd, 0x3f, 0x0000); /* JPEG/MCTL test data */
}
int eval(int p,int q)
{
int val=0;
int j;
if(p>q)
assert(0);
else if(p==q)
{
char *rec=NULL;
char temp[5];
switch(tokens[p].type)
{
case NUM:
return atoi(tokens[p].str);break;
case HEX:
return strtoll(tokens[p].str,&rec,16);break;
case REG:
strcpy(temp,tokens[p].str);
if(!strcmp(temp,"$eax"))return cpu.eax;
else if(!strcmp(temp,"$ecx")) return cpu.ecx;
else if(!strcmp(temp,"$edx")) return cpu.edx;
else if(!strcmp(temp,"$ebx")) return cpu.ebx;
else if(!strcmp(temp,"$esp")) return cpu.esp;
else if(!strcmp(temp,"$eip")) return cpu.eip;
else if(!strcmp(temp,"$edi")) return cpu.edi;
else if(!strcmp(temp,"$esi")) return cpu.esi;
else if(!strcmp(temp,"$ebp")) return cpu.ebp;
else if(!strcmp(temp,"$al")) return reg_w(R_AX);
else if(!strcmp(temp,"$ah")) return reg_w(R_AH);
else if(!strcmp(temp,"$bl")) return reg_w(R_BL);
else if(!strcmp(temp,"bh")) return reg_w(R_BH);
else if(!strcmp(temp,"cl")) return reg_w(R_CL);
else if(!strcmp(temp,"ch")) return reg_w(R_CH);
else if(!strcmp(temp,"$dl")) return reg_w(R_DL);
else if(!strcmp(temp,"$dh")) return reg_w(R_DH);
else if(!strcmp(temp,"$eflags")) return cpu.EFLAGS;
else if(!strcmp(temp,"$es")) return cpu.es;
else if(!strcmp(temp,"$cs")) return cpu.cs;
else if(!strcmp(temp,"$ss")) return cpu.ss;
else if(!strcmp(temp,"$ds")) return cpu.ds;
case TOK:
for(j = 0;j < nr_symtab_entry ; j++)
{
//if(symtab[j].st_info == 0x11)
//{
if(!strcmp (&strtab[symtab[j].st_name] , tokens[p].str))
return symtab[j].st_value;
//}
//else if(symtab[j].st_info == 0x12)
//{
// if(!strcmp (&strtab[symtab[j].st_name] , tokens[p].str))
// return symtab[j].st_value;
// }
}
}
}
else if(check_parentheses(p,q)==true)
return eval(p+1,q-1);
else
{
int val1=0;
int val2=0;
int op=dominate_operate(p,q);
if(tokens[op].type==NEG)
{
if(op!=0)
{
op--;
val1=eval(p,op-1);
val2=-eval(op+2,q);
}
else
{
val=-eval(op+1,q);
}
}
else if(tokens[op].type==POINTER)
{
if(op!=0)
{
op--;
val1=eval(p,op-1);
val2=swaddr_read(eval(op+2,q),4);
}
else
val=swaddr_read(eval(op+1,q),4);
}
else if(tokens[op].type==NOT)
{
if(op!=0)
{
op--;
val1=eval(p,op-1);
val2=!eval(op+2,q);
}
else
val=!eval(op+1,q);
}
else if(tokens[op].type==BIT_NOT)
{
if(op!=0)
{
op--;
val1=eval(p,op-1);
val2=~eval(op+2,q);
}
else val=~eval(op+1,q);
}
else
{
val1=eval(p,op-1);
val2=eval(op+1,q);
switch(tokens[op].type)
{
case ADD: val= val1+val2; break;
case SUB: val= val1-val2; break;
case MUL: val= val1*val2; break;
case DIV:
if(val2==0)
assert(0);
else
val= val1/val2;
break;
case RSHIFT: val= val1>>val2; break;
case LSHIFT: val= val1<<val2; break;
case LS: val= val1<val2; break;
case GT: val= val1>val2; break;
case GE: val= val1>=val2; break;
case LE: val= val1<=val2; break;
case NE: val= val1!=val2; break;
case EQ: val= val1== val2; break;
case BIT_AND: val= val1&val2; break;
case BIT_XOR: val= val1^val2; break;
case BIT_OR: val= val1|val2; break;
case AND: val= val1&&val2; break;
case OR: val= val1||val2; break;
}
}
}
return val;
}
void vdp_reset(void)
{
memset ((char *) sat, 0, sizeof (sat));
memset ((char *) vram, 0, sizeof (vram));
memset ((char *) cram, 0, sizeof (cram));
memset ((char *) vsram, 0, sizeof (vsram));
memset ((char *) reg, 0, sizeof (reg));
addr = 0;
addr_latch = 0;
code = 0;
pending = 0;
status = 0x200; /* fifo empty */
status |= vdp_pal;
ntab = 0;
ntbb = 0;
ntwb = 0;
satb = 0;
hscb = 0;
sat_base_mask = 0xFE00;
sat_addr_mask = 0x01FF;
border = 0x00;
memset ((char *) bg_name_dirty, 0, sizeof (bg_name_dirty));
memset ((char *) bg_name_list, 0, sizeof (bg_name_list));
bg_list_index = 0;
memset ((char *) bg_pattern_cache, 0, sizeof (bg_pattern_cache));
playfield_shift = 6;
playfield_col_mask = 0x0F;
playfield_row_mask = 0x0FF;
y_mask = 0x1FC0;
hint_pending = 0;
vint_pending = 0;
irq_status = 0;
hc_latch = 0;
v_counter = 0;
dmafill = 0;
dma_length = 0;
dma_endCycles = 0;
im2_flag = 0;
interlaced = 0;
odd_frame = 0;
fifo_write_cnt = 0;
/* reset HVC tables */
vctab = (vdp_pal) ? vc_pal_224 : vc_ntsc_224;
hctab = cycle2hc32;
/* reset display area */
bitmap.viewport.w = 256;
bitmap.viewport.h = 224;
bitmap.viewport.oh = 256;
bitmap.viewport.ow = 224;
/* reset border area */
bitmap.viewport.x = config.overscan ? 14 : 0;
bitmap.viewport.y = config.overscan ? (vdp_pal ? 32 : 8) : 0;
bitmap.viewport.changed = 2;
/* initialize some registers (normally set by BIOS) */
if (config.bios_enabled != 3)
{
reg_w(1 , 0x04); /* Mode 5 enabled */
reg_w(10, 0xff); /* HINT disabled */
reg_w(12, 0x81); /* H40 mode */
reg_w(15, 0x02); /* auto increment */
}
/* default latency */
fifo_latency = 27;
}
static void w9968cf_stop0(struct sd *sd)
{
reg_w(sd, 0x39, 0x0000); /* disable JPEG encoder */
reg_w(sd, 0x16, 0x0000); /* stop video capture */
}
static void w9968cf_mode_init_regs(struct sd *sd)
{
int val, vs_polarity, hs_polarity;
w9968cf_set_crop_window(sd);
reg_w(sd, 0x14, sd->gspca_dev.width);
reg_w(sd, 0x15, sd->gspca_dev.height);
/* JPEG width & height */
reg_w(sd, 0x30, sd->gspca_dev.width);
reg_w(sd, 0x31, sd->gspca_dev.height);
/* Y & UV frame buffer strides (in WORD) */
if (w9968cf_vga_mode[sd->gspca_dev.curr_mode].pixelformat ==
V4L2_PIX_FMT_JPEG) {
reg_w(sd, 0x2c, sd->gspca_dev.width / 2);
reg_w(sd, 0x2d, sd->gspca_dev.width / 4);
} else
reg_w(sd, 0x2c, sd->gspca_dev.width);
reg_w(sd, 0x00, 0xbf17); /* reset everything */
reg_w(sd, 0x00, 0xbf10); /* normal operation */
/* Transfer size in WORDS (for UYVY format only) */
val = sd->gspca_dev.width * sd->gspca_dev.height;
reg_w(sd, 0x3d, val & 0xffff); /* low bits */
reg_w(sd, 0x3e, val >> 16); /* high bits */
if (w9968cf_vga_mode[sd->gspca_dev.curr_mode].pixelformat ==
V4L2_PIX_FMT_JPEG) {
/* We may get called multiple times (usb isoc bw negotiat.) */
jpeg_define(sd->jpeg_hdr, sd->gspca_dev.height,
sd->gspca_dev.width, 0x22); /* JPEG 420 */
jpeg_set_qual(sd->jpeg_hdr, sd->quality);
w9968cf_upload_quantizationtables(sd);
}
/* Video Capture Control Register */
if (sd->sensor == SEN_OV7620) {
/* Seems to work around a bug in the image sensor */
vs_polarity = 1;
hs_polarity = 1;
} else {
vs_polarity = 1;
hs_polarity = 0;
}
val = (vs_polarity << 12) | (hs_polarity << 11);
/* NOTE: We may not have enough memory to do double buffering while
doing compression (amount of memory differs per model cam).
So we use the second image buffer also as jpeg stream buffer
(see w9968cf_init), and disable double buffering. */
if (w9968cf_vga_mode[sd->gspca_dev.curr_mode].pixelformat ==
V4L2_PIX_FMT_JPEG) {
/* val |= 0x0002; YUV422P */
val |= 0x0003; /* YUV420P */
} else
val |= 0x0080; /* Enable HW double buffering */
/* val |= 0x0020; enable clamping */
/* val |= 0x0008; enable (1-2-1) filter */
/* val |= 0x000c; enable (2-3-6-3-2) filter */
val |= 0x8000; /* capt. enable */
reg_w(sd, 0x16, val);
sd->gspca_dev.empty_packet = 0;
}
static void w9968cf_stop0(struct sd *sd)
{
v4l2_ctrl_grab(sd->jpegqual, false);
reg_w(sd, 0x39, 0x0000); /* disable JPEG encoder */
reg_w(sd, 0x16, 0x0000); /* stop video capture */
}
