static void send_command(struct bthost *bthost, uint16_t opcode,
const void *data, uint8_t len)
{
struct bt_hci_cmd_hdr *hdr;
uint16_t pkt_len;
void *pkt_data;
pkt_len = 1 + sizeof(*hdr) + len;
pkt_data = malloc(pkt_len);
if (!pkt_data)
return;
((uint8_t *) pkt_data)[0] = BT_H4_CMD_PKT;
hdr = pkt_data + 1;
hdr->opcode = cpu_to_le16(opcode);
hdr->plen = len;
if (len > 0)
memcpy(pkt_data + 1 + sizeof(*hdr), data, len);
if (bthost->ncmd) {
send_packet(bthost, pkt_data, pkt_len);
bthost->ncmd--;
} else {
queue_command(bthost, pkt_data, pkt_len);
}
free(pkt_data);
}
int maccept(Entry *e, void *p1, void *p2, void *p3, void *p4, void *p5)
{
int t;
Word ipid;
int xerrno;
int *newfd = (int *)p1;
selwakeupfx fx = (selwakeupfx)p2;
xsockaddr_in *addr = (xsockaddr_in *)p3;
int *addrlen = (int *)p4;
if (Debug > 0)
{
s16_debug_printf("accept");
}
if (e->_TYPE != SOCK_STREAM) return EOPNOTSUPP;
xerrno = sock_accept(e, newfd, fx, addr, addrlen);
if (xerrno != EAGAIN || e->_NONBLOCK)
{
return xerrno;
}
for (;;)
{
xerrno = queue_command(e, kCommandAccept, 0, 0);
if (xerrno == EINTR) return EINTR;
if (xerrno) return EIO;
if (e->command) continue; // reset to 0 if processed.
xerrno = sock_accept(e, newfd, fx, addr, addrlen);
if (xerrno != EAGAIN) return xerrno;
}
return 0;
}
static void queue_commands_from_cert(struct command **tail,
struct strbuf *push_cert)
{
const char *boc, *eoc;
if (*tail)
die("protocol error: got both push certificate and unsigned commands");
boc = strstr(push_cert->buf, "\n\n");
if (!boc)
die("malformed push certificate %.*s", 100, push_cert->buf);
else
boc += 2;
eoc = push_cert->buf + parse_signature(push_cert->buf, push_cert->len);
while (boc < eoc) {
const char *eol = memchr(boc, '\n', eoc - boc);
tail = queue_command(tail, boc, eol ? eol - boc : eoc - eol);
boc = eol ? eol + 1 : eoc;
}
}
static struct command *read_head_info(struct sha1_array *shallow)
{
struct command *commands = NULL;
struct command **p = &commands;
for (;;) {
char *line;
int len, linelen;
line = packet_read_line(0, &len);
if (!line)
break;
if (len == 48 && starts_with(line, "shallow ")) {
unsigned char sha1[20];
if (get_sha1_hex(line + 8, sha1))
die("protocol error: expected shallow sha, got '%s'",
line + 8);
sha1_array_append(shallow, sha1);
continue;
}
linelen = strlen(line);
if (linelen < len) {
const char *feature_list = line + linelen + 1;
if (parse_feature_request(feature_list, "report-status"))
report_status = 1;
if (parse_feature_request(feature_list, "side-band-64k"))
use_sideband = LARGE_PACKET_MAX;
if (parse_feature_request(feature_list, "quiet"))
quiet = 1;
if (advertise_atomic_push
&& parse_feature_request(feature_list, "atomic"))
use_atomic = 1;
if (advertise_push_options
&& parse_feature_request(feature_list, "push-options"))
use_push_options = 1;
}
if (!strcmp(line, "push-cert")) {
int true_flush = 0;
char certbuf[1024];
for (;;) {
len = packet_read(0, NULL, NULL,
certbuf, sizeof(certbuf), 0);
if (!len) {
true_flush = 1;
break;
}
if (!strcmp(certbuf, "push-cert-end\n"))
break; /* end of cert */
strbuf_addstr(&push_cert, certbuf);
}
if (true_flush)
break;
continue;
}
p = queue_command(p, line, linelen);
}
if (push_cert.len)
queue_commands_from_cert(p, &push_cert);
return commands;
}
int main(int argc,char **argv)
{
start_time=time(0);
start_usec=gettime_us();
int opt;
while ((opt = getopt(argc, argv, "b:s:l:c:")) != -1) {
switch (opt) {
case 'l': strcpy(serial_port,optarg); break;
case 's':
serial_speed=atoi(optarg);
switch(serial_speed) {
case 1000000:
case 1500000:
case 4000000:
case 230400: case 2000000: break;
default: usage();
}
break;
case 'b':
bitstream=strdup(optarg); break;
case 'c':
queue_command(optarg); break;
default: /* '?' */
usage();
}
}
if (argc-optind==1) usage();
// Load bitstream if file provided
if (bitstream) {
char cmd[1024];
snprintf(cmd,1024,"fpgajtag -a %s",bitstream);
fprintf(stderr,"%s\n",cmd);
system(cmd);
fprintf(stderr,"[T+%lldsec] Bitstream loaded\n",(long long)time(0)-start_time);
}
#ifndef APPLE
// Try to set USB serial port to low latency
{
char latency_timer[1024];
int offset=strlen(serial_port);
while(offset&&serial_port[offset-1]!='/') offset--;
snprintf(latency_timer,1024,"/sys/bus/usb-serial/devices/%s/latency_timer",
&serial_port[offset]);
int old_latency=999;
FILE *f=fopen(latency_timer,"r");
if (f) { fscanf(f,"%d",&old_latency); fclose(f); }
if (old_latency!=1) {
snprintf(latency_timer,1024,"echo 1 | sudo tee /sys/bus/usb-serial/devices/%s/latency_timer",
&serial_port[offset]);
printf("Attempting to reduce USB latency via '%s'\n",latency_timer);
system(latency_timer);
}
}
// And also another way
struct serial_struct serial;
ioctl(fd, TIOCGSERIAL, &serial);
serial.flags |= ASYNC_LOW_LATENCY;
ioctl(fd, TIOCSSERIAL, &serial);
#endif
errno=0;
fd=open(serial_port,O_RDWR);
if (fd==-1) {
fprintf(stderr,"Could not open serial port '%s'\n",serial_port);
perror("open");
exit(-1);
}
fcntl(fd,F_SETFL,fcntl(fd, F_GETFL, NULL)|O_NONBLOCK);
// Set higher speed on serial interface to improve throughput
set_speed(fd,2000000);
slow_write(fd,"\r+9\r",4,5000);
set_speed(fd,4000000);
stop_cpu();
sdhc_check();
if (queued_command_count) {
for(int i=0;i<queued_command_count;i++) execute_command(queued_commands[i]);
return 0;
} else {
char *cmd=NULL;
while((cmd=readline("MEGA65 SD-card> "))!=NULL) {
execute_command(cmd);
}
}
return 0;
}
static void my_kbd_interrupt_handler(void)
{
static int extended = 0; /* Extended key count. */
static int skip_count = 0;
unsigned int kcode;
kcode = inportb(0x60);
if (skip_count > 0) {
skip_count--;
outportb(0x20, 0x20);
return;
} else if (kcode == 0xe0) {
/* Extended key: at the next interrupt we'll get its extended keycode
or 0xe0 again. */
extended++;
outportb(0x20, 0x20);
return;
} else if (kcode == 0xe1) {
/* Damn Pause key. It sends 0xe1 0x1d 0x52 0xe1 0x9d 0xd2. This is
awesome, but at least we know it's the only sequence starting by
0xe1, so we can just skip the next 5 codes. Btw, there is no
release code. */
skip_count = 5;
kcode = K_PAUSE;
}
if (!(kcode & 0x80)) { /* Key pressed. */
/* Derive the extended keycode. */
if (extended == 1) {
kcode = _kbd_extended_key_tab[kcode];
}
/* Handle modifiers. */
switch (kcode) {
case K_LEFTCTRL:
modifiers.left_ctrl = 1;
break;
case K_RIGHTCTRL:
modifiers.right_ctrl = 1;
break;
case K_LEFTSHIFT:
modifiers.left_shift = 1;
break;
case K_RIGHTSHIFT:
modifiers.right_shift = 1;
break;
case K_LEFTALT:
modifiers.left_alt = 1;
break;
case K_RIGHTALT:
modifiers.right_alt = 1;
break;
}
switch (kcode) {
case K_ESC: /* Menu */
queue_command(KCMD_MENU, (kbd_command_data_t)0);
break;
case K_SCROLLOCK: /* Warp mode on/off */
queue_command(KCMD_TOGGLE_WARP, (kbd_command_data_t)0);
break;
/* Fall through */
default:
if (modifiers.left_alt && modifiers.left_ctrl) {
switch (kcode) {
case K_F12:
/* Ctrl-Alt-F12 does a hard reset. */
queue_command(KCMD_HARD_RESET, (kbd_command_data_t)0);
break;
case K_F4:
/* Ctrl-Alt-F4 is RECORD on the datasette. */
queue_command(KCMD_DATASETTE_RECORD, (kbd_command_data_t)0);
break;
case K_F5:
/* Ctrl-Alt-F5 is PLAY on the datasette. */
queue_command(KCMD_DATASETTE_START, (kbd_command_data_t)0);
break;
case K_F6:
/* Ctrl-Alt-F6 is REWIND on the datasette. */
queue_command(KCMD_DATASETTE_REWIND, (kbd_command_data_t)0);
break;
case K_F7:
/* Ctrl-Alt-F7 is FF on the datasette. */
queue_command(KCMD_DATASETTE_FORWARD, (kbd_command_data_t)0);
break;
case K_F8:
/* Ctrl-Alt-F8 is STOP on the datasette. */
queue_command(KCMD_DATASETTE_STOP, (kbd_command_data_t)0);
break;
}
} else if (modifiers.left_alt || modifiers.right_alt) {
/* Handle Alt-... hotkeys. */
switch (kcode) {
case K_F12:
/* Alt-F12 does a reset. */
queue_command(KCMD_RESET, (kbd_command_data_t)0);
break;
case K_F1:
/* Alt-F1 Next image in flip list. */
queue_command(KCMD_FLIP_NEXT, (kbd_command_data_t)0);
break;
case K_F2:
/* Alt-F2 Previous image in flip list. */
queue_command(KCMD_FLIP_PREVIOUS, (kbd_command_data_t)0);
break;
case K_F3:
/* Alt-F3 Add image to flip list. */
queue_command(KCMD_FLIP_ADD, (kbd_command_data_t)0);
break;
case K_F4:
/* Alt-F4 remove image from flip list. */
queue_command(KCMD_FLIP_REMOVE, (kbd_command_data_t)0);
break;
case K_F5:
/* Alt-F5 toggles statusbar. */
queue_command(KCMD_TOGGLE_STATUSBAR, (kbd_command_data_t)0);
break;
case K_PAUSE:
/* Alt-Pause enables cartridge freezing. */
queue_command(KCMD_FREEZE, (kbd_command_data_t)0);
break;
default:
/* Alt-{letter,number} enters the main menu. */
if (isalnum((int)kcode_to_ascii(kcode))) {
queue_command(KCMD_MENU, (kbd_command_data_t)kcode_to_ascii(kcode));
}
}
} else {
/* "Normal" key. */
keyboard_key_pressed((signed long)kcode);
}
}
} else { /* Key released. */
/* Remove release bit. */
kcode &= 0x7f;
/* Derive the extended keycode. */
if (extended == 1) {
kcode = _kbd_extended_key_tab[kcode];
}
/* Handle modifiers. */
switch (kcode) {
case K_LEFTCTRL:
modifiers.left_ctrl = 0;
break;
case K_RIGHTCTRL:
modifiers.right_ctrl = 0;
break;
case K_LEFTSHIFT:
modifiers.left_shift = 0;
break;
case K_RIGHTSHIFT:
modifiers.right_shift = 0;
break;
case K_LEFTALT:
modifiers.left_alt = 0;
break;
case K_RIGHTALT:
modifiers.right_alt = 0;
break;
}
if (!modifiers.left_alt && !modifiers.right_alt) {
/* "Normal" key. */
keyboard_key_released((signed long)kcode);
}
}
extended = 0;
outportb(0x20, 0x20);
}
