unsigned int spi_transfer16(unsigned int data, unsigned char cs) {
unsigned char l = data & 0xFF;
unsigned char h = (data & 0xFF00) >> 8;
put32(AUX_SPI0_CS, 0x000000B0 | cs);
while (1) {
if (get32(AUX_SPI0_CS) & (1 << 18)) {
break;
}
}
put8(AUX_SPI0_FIFO, h);
while (1) {
if (get32(AUX_SPI0_CS) & (1 << 16)) {
break;
}
}
h = get8(AUX_SPI0_FIFO);
while (1) {
if (get32(AUX_SPI0_CS) & (1 << 18)) {
break;
}
}
put8(AUX_SPI0_FIFO, l);
while (1) {
if (get32(AUX_SPI0_CS) & (1 << 16)) {
break;
}
}
l = get8(AUX_SPI0_FIFO);
put32(AUX_SPI0_CS, 0x00000000 | cs);
return (h << 8) | l;
}
/*
* 0 - /dev/nul
* 1 - binary
* 2 - as assic
*/
void dump(int size, int screen) {
int i;
if(screen == 0) {
for(i=0; i<size; i++) {
get8();
}
} else if(screen == 1) {
for(i=0; i<size; i++) {
if(i%16 == 0) {
printf("%02x", get8());
} else if(i%16 == 15) {
printf(", %02x\n", get8());
} else {
printf(", %02x", get8());
}
}
if(i%16 != 0) {
printf("\n");
}
} else if(screen == 2) {
for(i=0; i<size; i++) {
printf("%c", get8());
}
}
}
void unpack(const uint8_t** pp, const uint8_t* pend) {
const uint8_t* p = *pp;
if(pend - p < 2)
std::runtime_error("");
service_type = get8(p);
p += 1;
size_t length = get8(p);
p += 1;
if(pend - p < length)
std::runtime_error("");
service_provider_name.assign(p, p+length);
p += length;
if(pend - p < 1)
std::runtime_error("");
length = get8(p);
p += 1;
if(pend - p < length)
std::runtime_error("");
service_name.assign(p, p+length);
p += length;
*pp = p;
}
static uint16_t get16be(struct buffer *input)
{
uint16_t ret;
ret = get8(input)<<8;
ret |= get8(input);
return ret;
}
static int parse_section_header(SectionHeader *h,
const uint8_t **pp, const uint8_t *p_end)
{
int val;
val = get8(pp, p_end);
if (val < 0)
return -1;
h->tid = val;
*pp += 2;
val = get16(pp, p_end);
if (val < 0)
return -1;
h->id = val;
val = get8(pp, p_end);
if (val < 0)
return -1;
h->version = (val >> 1) & 0x1f;
val = get8(pp, p_end);
if (val < 0)
return -1;
h->sec_num = val;
val = get8(pp, p_end);
if (val < 0)
return -1;
h->last_sec_num = val;
return 0;
}
CARD16 StreamCopyPaste::GetBuffer::get16() {
if (transferRec.bytesWritten == transferRec.bytesRead) {
logger.error("bytesWritten == bytesRead");
ERROR();
}
CARD16 b1 = get8();
CARD16 b2 = get8();
return (b2 << 8) | (b1 << 0);
}
int
get16(void)
{
int i;
i = get8();
i |= get8() << 8;
return i;
}
int ei_decode_ref(const char *buf, int *index, erlang_ref *p)
{
const char *s = buf + *index;
const char *s0 = s;
int count, i;
switch (get8(s)) {
case ERL_REFERENCE_EXT:
/* nodename */
if (get_atom(&s, p->node, &p->node_org_enc) < 0) return -1;
/* now the numbers: num (4), creation (1) */
if (p) {
p->n[0] = get32be(s);
p->len = 1;
p->creation = get8(s) & 0x03;
}
else s += 5;
*index += s-s0;
return 0;
break;
case ERL_NEW_REFERENCE_EXT:
/* first the integer count */
count = get16be(s);
if (p) p->len = count;
/* then the nodename */
if (get_atom(&s, p->node, &p->node_org_enc) < 0) return -1;
/* creation */
if (p) {
p->creation = get8(s) & 0x03;
}
else s += 1;
/* finally the id integers */
if (p) {
for (i = 0; (i<count) && (i<3); i++) {
p->n[i] = get32be(s);
}
}
else s += 4 * count;
*index += s-s0;
return 0;
break;
default:
return -1;
}
}
void get_ether(struct EthernetHeader* ehead) {
int i;
for(i=0; i<6; i++) {
ehead->dest[i] = get8();
}
for(i=0; i<6; i++) {
ehead->src[i] = get8();
}
ehead->length_type = get16();
}
void get_tcp(struct TCPHeader* tcphead) {
tcphead->src = get16();
tcphead->dest = get16();
tcphead->seqnum = get32();
tcphead->acknum = get32();
tcphead->byte0 = get8();
tcphead->byte1 = get8();
tcphead->winsize = get16();
tcphead->checksum = get16();
tcphead->urgpoint = get16();
}
int
get32(void)
{
int i;
i = get8();
i |= get8() << 8;
i |= get8() << 16;
i |= get8() << 24;
return i;
}
static int bmp_test(stbi *s)
{
int sz;
if (get8(s) != 'B') return 0;
if (get8(s) != 'M') return 0;
get32le(s);
get16le(s);
get16le(s);
get32le(s);
sz = get32le(s);
if (sz == 12 || sz == 40 || sz == 56 || sz == 108) return 1;
return 0;
}
void es_eventState(sdl_data *sd, int len, char *bp)
{
Uint8 type, res;
int sendlen, state;
char *start;
type = get8(bp);
state = get8(bp);
res = SDL_EventState(type, state);
bp = start = sdl_get_temp_buff(sd, 1);
put8(bp, res);
sendlen = bp - start;
sdl_send(sd, sendlen);
}
void describe4(uint8_t *p, size_t nbytes, const char *dev)
{
char fromaddr[INET_ADDRSTRLEN];
char toaddr[INET_ADDRSTRLEN];
int headerlen = 4*(p[HLEN_OFFSET]&0x0f);
int proto = p[PROTO_OFFSET];
inet_ntop(AF_INET, p+SRC_OFFSET4, fromaddr, sizeof(fromaddr));
inet_ntop(AF_INET, p+DST_OFFSET4, toaddr, sizeof(toaddr));
uint8_t *phdr = p+headerlen;
if (proto == PROTO_TCP) {
// Should do this for IPv6 as well
uint16_t srcport = ntohs(get16(phdr+0));
uint16_t dstport = ntohs(get16(phdr+2));
uint16_t flags = 0x0f & get8(phdr+13);
char flagstring[16];
snprintf(flagstring, sizeof(flagstring),
"%s%s%s%s",
(flags&1)?"F":"",
(flags&2)?"S":"",
(flags&4)?"R":"",
(flags&8)?"P":"");
printf("dev=%s src=%s:%hu dst=%s:%hu len=%zu proto=%d flags=%s\n",
dev, fromaddr, srcport, toaddr, dstport, nbytes, proto, flagstring);
} else if (proto == PROTO_UDP) {
uint16_t srcport = ntohs(get16(phdr+0));
uint16_t dstport = ntohs(get16(phdr+2));
printf("proto=4 dev=%s src=%s:%hu dst=%s:%hu len=%zu proto=%d\n",
dev, fromaddr, srcport, toaddr, dstport, nbytes, proto);
} else {
printf("proto=4 dev=%s src=%s dst=%s len=%zu proto=%d\n",
dev, fromaddr, toaddr, nbytes, proto);
}
}
int
sample(Map *map)
{
int i;
static int n;
n++;
if(registers) {
for(i = 0; i < sizeof ureg; i+=8) {
if(get8(map, (uvlong)i, &((uvlong*)&ureg)[i/8]) < 0)
goto bad;
}
} else {
// we need only two registers
if(get8(map, offsetof(struct Ureg, ip), (uvlong*)&ureg.ip) < 0)
goto bad;
if(get8(map, offsetof(struct Ureg, sp), (uvlong*)&ureg.sp) < 0)
goto bad;
}
return 1;
bad:
if(n == 1)
fprint(2, "prof: can't read registers: %r\n");
return 0;
}
/* c non-zero -> erlang "true" atom, otherwise "false" */
int ei_decode_boolean(const char *buf, int *index, int *p)
{
const char *s = buf + *index;
const char *s0 = s;
int len;
int t;
if (get8(s) != ERL_ATOM_EXT) return -1;
len = get16be(s);
switch (len) {
case 4:
/* typecast makes ansi happy */
if (strncmp((char*)s,"true",4)) return -1;
t = 1;
break;
case 5:
if (strncmp((char*)s,"false",5)) return -1;
t = 0;
break;
default:
return -1;
}
s += len;
if (p) *p = t;
*index += s-s0;
return 0;
}
void es_pauseAudio(sdl_data *sd, int len, char *buff)
{
char *bp;
int pause;
bp = buff;
pause = get8(bp);
SDL_PauseAudio(pause);
}
void
main()
{
U_LONG key[2], plain[2], cipher[2], answer[2];
int i;
int test;
int fail;
for(test=0;!feof(stdin);test++){
get8(key);
do_setkey(key);
printf(" K: "); put8(key);
get8(plain);
printf(" P: "); put8(plain);
get8(answer);
printf(" C: "); put8(answer);
for(i=0;i<2;i++)
cipher[i] = plain[i];
do_crypt(cipher, 0);
for(i=0;i<2;i++)
if(cipher[i] != answer[i])
break;
fail = 0;
if(i != 2){
printf(" Encrypt FAIL");
fail++;
}
do_crypt(cipher, 1);
for(i=0;i<2;i++)
if(cipher[i] != plain[i])
break;
if(i != 2){
printf(" Decrypt FAIL");
fail++;
}
if(fail == 0)
printf(" OK");
printf("\n");
}
}
void es_openAudio(sdl_data *sd, int len, char *buff)
{
int sendlen;
char *bp, *start;
int ff;
SDL_AudioSpec desired, obtained, *obptr;
bp = buff;
ff = get8(bp);
desired.freq = get32be(bp);
desired.format = get16be(bp);
desired.channels = get8(bp);
desired.samples = get16be(bp);
desired.padding = get16be(bp);
desired.callback = myaudiomixer;
/* Init the global data structures */
wave.sound = NULL;
wave.soundpos = 0;
wave.soundlen = 0;
if(ff == 1) /* Force the requested format */
obptr = NULL;
else
obptr = &obtained;
bp = start = sdl_getbuff(sd, 16);
if( SDL_OpenAudio(&desired, obptr) < 0 ) {
fprintf(stderr, "Couldn't open audio: %s\n", SDL_GetError());
} else {
if(ff == 1)
obptr = &desired;
put32be(bp, obptr->freq);
put16be(bp, obptr->format);
put8(bp, obptr->channels);
put8(bp, obptr->silence);
put16be(bp, obptr->samples);
put16be(bp, obptr->padding);
put32be(bp, obptr->size);
wave.silence = obptr->silence;
}
sendlen = (int) (bp - start);
sdl_send(sd, sendlen);
}
int ei_get_type_internal(const char *buf, const int *index,
int *type, int *len)
{
const char *s = buf + *index;
*type = get8(s);
switch (*type) {
case ERL_SMALL_TUPLE_EXT:
*len = get8(s);
break;
case ERL_ATOM_EXT:
case ERL_STRING_EXT:
*len = get16be(s);
break;
case ERL_FLOAT_EXT:
case NEW_FLOAT_EXT:
*type = ERL_FLOAT_EXT;
break;
case ERL_LARGE_TUPLE_EXT:
case ERL_LIST_EXT:
case ERL_BINARY_EXT:
*len = get32be(s);
break;
case ERL_SMALL_BIG_EXT:
*len = get8(s); /* #digit_bytes */
break;
case ERL_LARGE_BIG_EXT:
*len = get32be(s); /* #digit_bytes */
break;
default:
*len = 0;
break;
}
/* leave index unchanged */
return 0;
}
int ei_decode_intlist(const char *buf, int *index, long *a, int *count)
{
const unsigned char *s = (const unsigned char *)(buf + *index);
const unsigned char *s0 = s;
int idx;
int len;
int i;
switch (get8(s)) {
case ERL_STRING_EXT:
len = get16be(s);
/* transfer and cast chars one at a time into array */
if (a) {
for (i=0; i<len; i++) {
a[i] = (long)(s[i]);
}
}
if (count) *count = len;
s += len;
break;
case ERL_LIST_EXT:
len = get32be(s);
idx = 0;
if (a) {
for (i=0; i<len; i++) {
if (ei_decode_long((char*)s,&idx,a+i) < 0) {
if (count) *count = i;
return -1;
}
}
}
else {
for (i=0; i<len; i++) {
if (ei_decode_long((char*)s,&idx,NULL) < 0) {
if (count) *count = i;
return -1;
}
}
}
if (count) *count = len;
s += idx;
break;
default:
return -1;
}
*index += s-s0;
return 0;
}
static int recv_challenge_reply (int fd,
unsigned our_challenge,
char cookie[],
unsigned *her_challenge,
unsigned ms)
{
char dbuf[DEFBUF_SIZ];
char *buf = dbuf;
int is_static = 1;
int buflen = DEFBUF_SIZ;
int rlen;
char *s;
char tag;
char her_digest[16], expected_digest[16];
erl_errno = EIO; /* Default */
if ((rlen = read_2byte_package(fd, &buf, &buflen, &is_static, ms)) != 21) {
EI_TRACE_ERR1("recv_challenge_reply",
"<- RECV_CHALLENGE_REPLY socket read failed (%d)",rlen);
goto error;
}
s = buf;
if ((tag = get8(s)) != 'r') {
EI_TRACE_ERR2("recv_challenge_reply",
"<- RECV_CHALLENGE_REPLY incorrect tag, "
"expected 'r' got '%c' (%u)",tag,tag);
goto error;
}
*her_challenge = get32be(s);
memcpy(her_digest, s, 16);
gen_digest(our_challenge, cookie, (unsigned char*)expected_digest);
if (memcmp(her_digest, expected_digest, 16)) {
EI_TRACE_ERR0("recv_challenge_reply",
"<- RECV_CHALLENGE_REPLY authorization failure");
goto error;
}
if (!is_static)
free(buf);
if (ei_tracelevel >= 3) {
char buffer[33];
EI_TRACE_CONN2("recv_challenge_reply",
"<- RECV_CHALLENGE_REPLY (ok) challenge = %u, digest = %s",
*her_challenge,hex(her_digest,buffer));
}
erl_errno = 0;
return 0;
error:
if (!is_static)
free(buf);
return -1;
}
int ei_decode_port(const char *buf, int *index, erlang_port *p)
{
const char *s = buf + *index;
const char *s0 = s;
if (get8(s) != ERL_PORT_EXT) return -1;
/* first the nodename */
if (get_atom(&s, p->node, &p->node_org_enc) < 0) return -1;
/* now the numbers: num (4), creation (1) */
if (p) {
p->id = get32be(s) & 0x0fffffff /* 28 bits */;
p->creation = get8(s) & 0x03;
}
else s += 5;
*index += s-s0;
return 0;
}
void es_convertAudio(sdl_data *sd, int len, char *buff)
{
char *bp, *start;
void *mptr;
Uint16 oformat, nformat;
Uint8 ochannels, nchannels;
int ofreq, nfreq, osize, nsize;
SDL_AudioCVT wav_cvt;
int sendlen;
bp = buff;
oformat = get16be(bp);
ochannels = get8(bp);
ofreq = get32be(bp);
nformat = get16be(bp);
nchannels = get8(bp);
nfreq = get32be(bp);
POPGLPTR(mptr, bp);
osize = get32be(bp);
bp = start = sdl_getbuff(sd, 12);
/* Build AudioCVT */
if(SDL_BuildAudioCVT(&wav_cvt,oformat, ochannels, ofreq,
nformat, nchannels, nfreq) >= 0) {
/* Setup for conversion */
nsize = osize*wav_cvt.len_mult;
wav_cvt.buf=(Uint8 *)malloc(nsize);
if(wav_cvt.buf != NULL) {
wav_cvt.len=osize;
memcpy(wav_cvt.buf, mptr, osize);
if (SDL_ConvertAudio(&wav_cvt) >= 0) {
PUSHGLPTR(wav_cvt.buf, bp);
put32be(bp, nsize);
}
}
}
sendlen = (int) (bp - start);
sdl_send(sd, sendlen);
}
BYTE CHD61102::cmd_read(qint16 cmd)
{
BYTE value = get8((info.Xadr * 0x40) + (info.Yadr==0 ? 63 : info.Yadr - 1) );
AddLog(LOG_TEMP,tr("HD61102 READ CMD : x=%1 Y=%2 v=%3").arg(info.Xadr).arg(info.Yadr).arg(value,2,16,QChar('0')));
(info.Yadr)++;
if (info.Yadr == 64) {
info.Yadr=0;
}
// if (pPC->fp_log) fprintf(pPC->fp_log,"LCD Read:%02x\n",value);
return value;
}
void es_joystick_opened(sdl_data *sd, int len,char *buff)
{
int sendlen;
char *bp, *start;
int index, bool;
bp = buff;
index = get8(bp);
bp = start = sdl_get_temp_buff(sd, 1);
bool = SDL_JoystickOpened(index);
put8(bp, bool);
sendlen = bp - start;
sdl_send(sd, sendlen);
}
void es_enableUNICODE(sdl_data *sd, int len,char *buff)
{
int sendlen;
char *bp, *start;
Uint8 enable;
bp = buff;
enable = get8(bp);
bp = start = sdl_get_temp_buff(sd, 1);
enable = SDL_EnableUNICODE(enable);
put8(bp, enable);
sendlen = bp - start;
sdl_send(sd, sendlen);
}
void es_joystick_getAxis(sdl_data *sd, int len,char *buff)
{
int sendlen;
char *bp, *start;
SDL_Joystick *joy;
int state, axis;
bp = buff;
POPGLPTR(joy, bp);
axis = get8(bp);
bp = start = sdl_get_temp_buff(sd, 4);
state = SDL_JoystickGetAxis(joy, axis);
put32be(bp, state);
sendlen = bp - start;
sdl_send(sd, sendlen);
}
void es_joystick_getButton(sdl_data *sd, int len,char *buff)
{
int sendlen;
char *bp, *start;
SDL_Joystick *joy;
int state;
Uint8 button;
bp = buff;
POPGLPTR(joy, bp);
button = get8(bp);
bp = start = sdl_get_temp_buff(sd, 1);
state = SDL_JoystickGetButton(joy, button);
put8(bp,state);
sendlen = bp - start;
sdl_send(sd, sendlen);
}
void es_joystick_open(sdl_data *sd, int len,char *buff)
{
int sendlen;
char *bp, *start;
SDL_Joystick *joy;
int index;
bp = buff;
index = get8(bp);
bp = start = sdl_get_temp_buff(sd, 8);
if((joy = SDL_JoystickOpen(index)) != NULL) {
PUSHGLPTR(joy, bp);
}
sendlen = bp - start;
sdl_send(sd, sendlen);
}
