void fastloader_fc3_send_block(uint8_t *data) {
uint32_t ticks;
unsigned int byte, pair;
fastloader_setup();
disable_interrupts();
/* start in one microsecond */
reference_time = now() + 10;
set_clock_at(0, 0, WAIT);
/* Transmit data */
ticks = 120;
for (byte = 0; byte < 4; byte++) {
uint8_t value = *data++;
for (pair = 0; pair < 4; pair++) {
set_clock_at(ticks, value & 1, NO_WAIT);
set_data_at (ticks, value & 2, WAIT);
value >>= 2;
ticks += 120;
}
ticks += 20;
}
set_clock_at(ticks, 1, NO_WAIT);
set_data_at (ticks, 1, WAIT);
// Note: Hold time is in the C part
enable_interrupts();
fastloader_teardown();
}
void turbodisk_buffer(uint8_t *data, uint8_t length) {
unsigned int pair;
uint32_t ticks;
fastloader_setup();
/* wait for handshake */
while (IEC_DATA) ;
set_clock(1);
wait_data(1, NO_ATNABORT);
ticks = 70;
while (length--) {
uint8_t byte = *data++;
ticks += 120;
for (pair = 0; pair < 4; pair++) {
ticks += 240;
set_clock_at(ticks, byte & 0x80, NO_WAIT);
set_data_at (ticks, byte & 0x40, WAIT);
ticks += 50;
byte <<= 2;
}
ticks += 100;
}
ticks += 110;
set_clock_at(ticks, 0, NO_WAIT);
set_data_at( ticks, 1, WAIT);
delay_us(5);
fastloader_teardown();
}
void uload3_send_byte(uint8_t byte) {
fastloader_setup();
disable_interrupts();
/* initial handshake */
set_data(0);
while (IEC_CLOCK && IEC_ATN) ;
if (!IEC_ATN)
goto exit;
/* wait for start signal */
set_data(1);
wait_clock(1, ATNABORT);
if (!IEC_ATN)
goto exit;
/* transmit data */
generic_load_2bit(&uload3_send_def, byte);
/* exit with clock+data high */
set_clock_at(480, 1, NO_WAIT);
set_data_at (480, 1, WAIT);
exit:
enable_interrupts();
fastloader_teardown();
}
static uint8_t fc3_oldfreeze_send(const uint8_t byte,
const generic_2bit_t *timingdef,
unsigned int busytime) {
fastloader_setup();
disable_interrupts();
/* clear busy */
set_clock(1);
set_data(1);
delay_us(15);
if (!IEC_ATN)
goto exit;
/* wait for start signal */
wait_clock(1, ATNABORT);
if (!IEC_ATN)
goto exit;
/* transmit data */
generic_load_2bit(timingdef, byte);
/* re-enable busy signal */
set_clock_at(busytime, 1, NO_WAIT);
set_data_at (busytime, 0, WAIT);
delay_us(1); // a little settle time for clock
exit:
enable_interrupts();
fastloader_teardown();
return !IEC_ATN;
}
uint8_t jiffy_send(uint8_t value, uint8_t eoi, uint8_t loadflags) {
unsigned int loadmode = loadflags & 0x80;
unsigned int skipeoi = loadflags & 0x7f;
fastloader_setup();
disable_interrupts();
/* Initial handshake */
set_data(1);
set_clock(1);
delay_us(3);
if (loadmode) {
/* LOAD mode: start marker is data low */
while (!IEC_DATA) ; // wait until data actually is high again
wait_data(0, ATNABORT);
} else {
/* single byte mode: start marker is data high */
wait_data(1, ATNABORT);
}
/* transmit data */
generic_load_2bit(&jiffy_send_def, value);
/* Send EOI info */
if (!skipeoi) {
if (eoi) {
set_clock_at(520, 1, NO_WAIT);
set_data_at (520, 0, WAIT);
} else {
/* LOAD mode also uses this for the final byte of a block */
set_clock_at(520, 0, NO_WAIT);
set_data_at (520, 1, WAIT);
}
/* wait until data is low */
delay_us(3); // allow for slow rise time
while (IEC_DATA && IEC_ATN) ;
}
/* hold time */
delay_us(10);
enable_interrupts();
fastloader_teardown();
return !IEC_ATN;
}
/**
* generic_load_2bit - generic 2-bit fastloader transmit
* @def : pointer to fastloader definition struct
* @byte: data byte
*
* This function implements generic 2-bit fastloader
* transmission based on a generic_2bit_t struct.
*/
static __attribute__((unused)) void generic_load_2bit(const generic_2bit_t *def, uint8_t byte) {
unsigned int i;
byte ^= def->eorvalue;
for (i=0;i<4;i++) {
set_clock_at(def->pairtimes[i], byte & (1 << def->clockbits[i]), NO_WAIT);
set_data_at (def->pairtimes[i], byte & (1 << def->databits[i]), WAIT);
}
}
void turbodisk_byte(uint8_t value) {
fastloader_setup();
/* wait for handshake */
while (IEC_DATA) ;
set_clock(1);
wait_data(1, NO_ATNABORT);
/* transmit data */
generic_load_2bit(&turbodisk_byte_def, value);
/* exit with clock low, data high */
set_clock_at(1470, 0, NO_WAIT);
set_data_at( 1470, 1, WAIT);
delay_us(5);
fastloader_teardown();
}
void ar6_1581_send_byte(uint8_t byte) {
fastloader_setup();
disable_interrupts();
/* wait for handshake */
set_clock(1);
wait_data(1, NO_ATNABORT);
/* transmit data */
generic_load_2bit(&ar6_1581_send_def, byte);
/* exit with clock low, data high */
set_clock_at(375, 0, NO_WAIT);
set_data_at( 375, 1, WAIT);
/* short delay to make sure bus has settled */
delay_us(10);
enable_interrupts();
fastloader_teardown();
}
uint8_t ar6_1581p_get_byte(void) {
uint8_t result;
fastloader_setup();
disable_interrupts();
set_clock(1);
/* wait for handshake */
while (IEC_DATA) ;
wait_data(1, NO_ATNABORT);
/* receive data */
result = generic_save_2bit(&ar6_1581p_get_def);
/* exit with clock low */
set_clock_at(530, 0, WAIT);
enable_interrupts();
fastloader_teardown();
return result;
}
static void set_clock(Clock *c, double pts, int serial)
{
double time = av_gettime_relative() / 1000000.0;
set_clock_at(c, pts, serial, time);
}
