/** * Link Cable Protocol (LCP) - Protocol for data exchange via SEGA Link Cable * between two Sega Mega Drive / Sega Genesis consoles connected through the second controller port * for SGDK * * BlodTor 2025 * * ************************************************************************************************* * ************************************************************************************************* * Master console function call sequence: * * 1) Initialize Link Cable Protocol. * LCP_init(); * * 2) Prepare data for transmission from master console via Link Cable Protocol. * LCP_objectToPacketForSend(transferObject, objectType, objectTypeSizes); * LCP_objectToPacketForSend(transferObject, objectType, objectTypeSizes); * ... * LCP_objectToPacketForSend(transferObject, objectType, objectTypeSizes); * * 3) Trigger external interrupt on slave console and send/receive data via Link Cable Protocol * LCP_masterCycle(); * * 4) Extract received objects from packet transmitted by slave console * objectType = LCP_getNextObjectFromReceivePacket(transferObject, objectSizes); * objectType = LCP_getNextObjectFromReceivePacket(transferObject, objectSizes); * ... * objectType = LCP_getNextObjectFromReceivePacket(transferObject, objectSizes); * until objectType becomes 0 * * 5) Close Link Cable Protocol if no further interaction with slave console is required. * LCP_close(); * * ************************************************************************************************* * ************************************************************************************************* * Slave console function call sequence: * * 1) Initialize Link Cable Protocol * LCP_init(); * * 2) Open port to enable slave console to handle external interrupts triggered by * master console. Master console can only call LCP_slaveCycle() - the external * interrupt handler on slave console - after this method is called. * LCP_open(); * * 3) Prepare data for transmission from slave console via Link Cable Protocol. * Transmission occurs in LCP_slaveCycle() after receiving data from master console * in this method. LCP_slaveCycle() is called asynchronously by suspending game code * execution on slave console when external interrupt from LCP_masterCycle() method * of master console occurs. * LCP_objectToPacketForSend(transferObject, objectType, objectTypeSizes); * LCP_objectToPacketForSend(transferObject, objectType, objectTypeSizes); * ... * LCP_objectToPacketForSend(transferObject, objectType, objectTypeSizes); * * 4) Extract received objects from packet transmitted by master console * objectType = LCP_getNextObjectFromReceivePacket(transferObject, objectSizes); * objectType = LCP_getNextObjectFromReceivePacket(transferObject, objectSizes); * ... * objectType = LCP_getNextObjectFromReceivePacket(transferObject, objectSizes); * until objectType becomes 0 * * 5) Close Link Cable Protocol if no further interaction with master console is required. * Slave console will stop responding to external interrupts from master console! * LCP_close(); * * ************************************************************************************************* * ************************************************************************************************* * IMPORTANT USAGE NOTES: * !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! * * Object types (objectType) must be defined in YOUR game's main code! * See constant declaration examples in 'Super Turbo MEGA Pac-Man 2.1' game code * starting with 'OBJECT_TYPE_' prefix * * Object sizes (objectSizes) in bytes must be defined in YOUR game's main code! * The protocol transfers 2 bytes of information per cycle, so there's no point in setting * object lengths not multiples of 2 bytes! See constant declaration examples in * 'Super Turbo MEGA Pac-Man 2.1' game code ending with '_OBJECT_LENGTH' postfix, * as well as the LINK_TYPES_LENGHT array definition example which is passed as objectSizes * parameter to LCP_objectToPacketForSend() and LCP_getNextObjectFromReceivePacket() functions * * Master/Slave console determination implementation must be in YOUR game's code! * See initControllerPort2() function example in 'Super Turbo MEGA Pac-Man 2.1' game code * which determines which of the two consoles becomes master and which becomes slave * * !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! * * For debugging, use the function that returns transmission errors via SEGA Link Cable: * LCP_getError() * */ #include "config.h" #if (MODULE_LINK_CABLE != 0) #include "ext/link_cable.h" #include "types.h" #include "sys.h" #include "vdp.h" #include "z80_ctrl.h" #include "memory.h" /** * Global variables */ // Port open or not (port CTRL 2 in SEGA documentation - second controller port) // // If 1 - open, external interrupt EX-INT (External Interrupt in SEGA documentation) should be triggered, // initiated by another console which will be master relative to ours. // I.e. we first receive data from the master console via port, // then send data to it in one data exchange cycle. // // The interrupt handler can be called at any moment on our slave console. // The executing code will be suspended at the moment of interrupt, and after the interrupt handler execution // registers will be restored and main game code execution will continue. // // Data reception and transmission are asynchronous relative to preparation of what to send and processing of what // was received by our slave console. // // If 0 - port closed, your console doesn't have EX-INT (External Interrupt) handler but can trigger // this interrupt on another console, i.e. your console is master. We first send data to slave // console, then receive data from it in one data exchange cycle. // // Data transmission and reception on our master console are synchronous, from main game code, relative to // preparation of what to send and processing of what was received from another slave console static u16 LCP_portOpen = 0; // Start index of data in LCP_sendPacket array that needs to be transmitted via Link Cable // Can transmit multiple objects, here will be the index of the first byte of the first // untransmitted object in LCP_sendPacket packet static u16 LCP_sendHead = 0; // End index of data in LCP_sendPacket array that needs to be transmitted via Link Cable // Can transmit multiple objects, here will be the last byte of the last // untransmitted object in LCP_sendPacket packet static u16 LCP_sendTail = 0; // Data transmission packet - array where LCP_objectToPacketForSend function stores objects for transmission via Link Cable. // This is done from the main loop of your game when something needs to be transmitted to another console. // First 16 bits are the object type, followed by object data, and there can be multiple such objects in the packet. // // 0 LCP_sendHead LCP_sendTail LCP_PACKET_SIZE // | 16 bits | | | // [object type 1][object1][object type 2][object2][object type 3][object3][][][][][][][][][][][][][][]][][]][] static u16 LCP_sendPacket[LCP_PACKET_SIZE]; // Start index of data in LCP_ReceivePacket array that was received via Link Cable // Can receive multiple objects at once, here will be the index of the first byte of the first // received object in LCP_ReceivePacket array static u16 LCP_ReceiveHead = 0; // End index of data in LCP_ReceivePacket array that was received via Link Cable // Can receive multiple packets at once, here will be the last byte of the last // received object in LCP_ReceivePacket array static u16 LCP_ReceiveTail = 0; // Received data packet - array from which LCP_getNextObjectFromReceivePacket function in your game's main code copies // the next received object into transferObject (pointer to byte array in your game code) and returns the type of this object. // This is done in your game's main code, while data gets into the packet during Master cycle work - LCP_masterCycle() for master console // or Slave cycle work - LCP_slaveCycle() for slave console. These functions handle data transmission via Link Cable. // LCP_masterCycle() - always called synchronously from your game's main code! And only on master console. // LCP_slaveCycle() - called asynchronously upon external interrupt - External Interrupt (EX-INT) only on slave console. // // 0 LCP_ReceiveHead LCP_ReceiveTail LCP_PACKET_SIZE // | 16 bits | | | // [object type 1][object1][object type 2][object2][object type 3][object3][][][][][][][][][][][][][][]][][]][] static u16 LCP_ReceivePacket[LCP_PACKET_SIZE]; // If non-zero, means there was a connection break during reception or transmission of lower 4 bits of LCP_Data // and a data wait timeout occurred. What exactly happened can be understood from LCP_error. static u8 LCP_timeOut = 0; // Error in data transmission via SEGA Link Cable // // If 0x0000, no errors occurred! Value ranges in binary format // Lower 4 bits of low byte - data reception errors via Link Cable (0x0001 - 0x000F) 000000000000xxxx // Upper 4 bits of low byte - data transmission errors via Link Cable (0x0010 - 0x00F0) 00000000xxxx0000 // Lower 4 bits of high byte - packet reception or transmission errors (0x0100 - 0x0F00) 0000xxxx00000000 // Upper 4 bits of high byte - object extraction errors from packet (0x1000 - 0xF000) xxxx000000000000 static u16 LCP_error = 0; /** * Start of 2-byte (16-bit) data transfer cycle via Link Cable * Reset bit 5 of LCP_Data to 0 - data not ready for reading by other console * Set LCP_Ctrl = 00101111 to enable on controller port 2: * pins 0-3 for data transmission, and pin 5 for signal that data can be read * by other console. As soon as we set it to 1, we expect pin 6 to be 0 * at function call time (if it's 1, we'll wait for 0 until timeout occurs and throw error 0xA if not received) * * Error codes (error code = LCP_error & 0x000F): * 0xA - data transmission preparation error (failed to get 0 on pin 6 of 2nd controller) * * If no errors occurred (LCP_error == 0 and LCP_timeOut == 0) */ static void LCP_startSendCycle(); /** * Main 2-byte (16-bit) data transfer cycle via Link Cable * Transmission is done through LCP_Data - shared memory area of both consoles * 4 bits at a time, i.e. in 4 iterations since 2 bytes = 16 bits * Fills the lower 4 data bits in LCP_Data that we're sending * Sets or resets bit 5 depending on iteration in LCP_Data * Waits for data reception confirmation from other console in bit 6 of LCP_Data * If confirmation is not received, saves error in LCP_error * * Error codes (error code = LCP_error & 0x000F): * 0x1 - failed to receive confirmation on 1st iteration * 0x2 - failed to receive confirmation on 2nd iteration * 0x3 - failed to receive confirmation on 3rd iteration * 0x4 - failed to receive confirmation on 4th iteration * * data - 2 bytes of data (16 bits) to transmit * Let's assume initial data = "aaaayyyybbbbxxxx" - split 2 bytes (16 bits) into 4-bit chunks: * first transmit aaaa, then yyyy, then bbbb, and in 4th iteration xxxx * * At function call time LCP_Data = "r00rrrrr" - where r is any value and doesn't matter currently * LCP_startSendCycle function must have completed successfully first, or another LCP_send must complete successfully * * If no errors occurred (LCP_error == 0 and LCP_timeOut == 0) */ static void LCP_send(u16 data); /** * End of 2-byte (16-bit) data transfer cycle via Link Cable * Set LCP_Ctrl = 00100000 to enable on controller port 2: * pins 0-3 for data reception, and pin 5 for signal that our SEGA is ready to receive data. * Reset bit 5 in LCP_Data to 0, wait for confirmation that other console is ready to send data - * until bit 6 in LCP_Data becomes 1 or timeout occurs, and throw error 0xB if not received. * * Error codes (error code = LCP_error & 0x000F): * 0xB - data transfer cycle end error (failed to get 1 in bit 6 of LCP_Data) * * If no errors occurred (LCP_error == 0 and LCP_timeOut == 0) */ static void LCP_endSendCycle(); /** * Start of 2-byte (16-bit) data reception cycle via Link Cable * Reset bit 5 in LCP_Data to 0 (ready for reading) */ static void LCP_startReceiveCycle(); /** * Main 2-byte (16-bit) data reception cycle via Link Cable * Receives 4 bits at a time over 4 iterations through LCP_Data (lower 4 bits) * Sets or resets bit 5 in LCP_Data depending on iteration, thereby * confirming successful reading to the console that sent us data * Waits for confirmation in bit 6 of LCP_Data from other console that data can be read * * Error codes (error code = LCP_error & 0x000F): * 0x5 - failed to receive confirmation that data can be read on 1st iteration * 0x6 - failed to receive confirmation that data can be read on 2nd iteration * 0x7 - failed to receive confirmation that data can be read on 3rd iteration * 0x8 - failed to receive confirmation that data can be read on 4th iteration * * return - 2 bytes of data (16 bits) received from other SEGA "aaaayyyybbbbxxxx" * if no errors occurred (LCP_error == 0 and LCP_timeOut == 0) */ static u16 LCP_Receive(); /** * End of 2-byte (16-bit) data reading cycle via Link Cable * Wait for confirmation that the other console understood the end of data reception from our console - * until bit 6 in LCP_Data becomes 0 or timeout occurs, and throw error 0x9 if not received. * Set bit 5 in LCP_Data to 1 - received confirmation from the other SEGA that it successfully transmitted everything. * * Error codes (error code = LCP_error & 0x000F): * 0x9 - failed to receive confirmation that data was received by the other SEGA * * If no errors occurred (LCP_error == 0 and LCP_timeOut == 0) */ static void LCP_endReceiveCycle(); /** * End of data transmission and reception cycle via Link Cable for SEGA master console * Set bit 5 in LCP_Ctrl to 1, others to 0, which means we no longer transmit data in bits 0-3 * Set bit 5 in LCP_Data to 1 for our master console, on the other console (slave) bit 6 will also become 1 * Enable processing of all interrupts */ static void LCP_masterCycleEnd(); /** * Data reception and then transmission cycle via Link Cable for SEGA slave console * This is an EX-INT external interrupt handler - External interrupt in SEGA documentation * It MUST NOT be called directly from game code! * * This function will be set as EX-INT external interrupt handler when LCP_open() is called from YOUR game code * and will be disabled as external interrupt handler when LCP_close() is called from YOUR game code * * Function call always occurs asynchronously, interrupting your game code execution at random, unpredictable time for main game code! * * At the very beginning, it disables all interrupt processing and resets LCP_timeOut and LCP_error to 0 * * Error codes (error code = LCP_error & 0x0F00): * 0x100 - error calling LCP_slaveCycle() - second console port not open for data exchange * 0x200 - error calling LCP_startReceiveCycle() - start of data reception from master console * 0x300 - error calling size = LCP_Receive() - receiving size of transmitted data from master console * 0x400 - error calling data = LCP_Receive() - receiving next 2 bytes of packet data from master console * 0x500 - error calling checksum = LCP_Receive() - receiving checksum from master console * 0x600 - error calling LCP_endReceiveCycle() - end of data reception from master console * 0x700 - error calling LCP_startSendCycle() - start of data transmission from slave console * 0x800 - error calling LCP_send(checksum) - transmitting checksum from slave console * 0x900 - error calling LCP_send(size) - transmitting size of packet to be sent from slave console * 0xA00 - error calling LCP_send(data) - transmitting next 2 bytes of packet data from slave console * 0xB00 - error calling LCP_send(checksum) - transmitting checksum from slave console * 0xC00 - error calling LCP_endSendCycle() - end of data transmission from slave console * 0xD00 - error calling LCP_startReceiveCycle() - start of data reception from master console * 0xE00 - error calling data = LCP_Receive() - receiving checksum from master console * * Error codes (error code = LCP_error & 0x00F0): * 0x80 - checksum calculated by slave console <> checksum received from master console * 0xC0 - checksum calculated by slave console <> checksum received from master console */ static void LCP_slaveCycle(); /** * End of data reception and then transmission cycle via Link Cable for SEGA slave console * Switches console's 2nd port to data reception mode via Link Cable, on all pins except pin 5 * Set bit 5 in LCP_Ctrl to 1, others to 0, which means we no longer transmit data in bits 0-3 * Set bit 5 in LCP_Data to 1 for our slave console, on the other console (master) bit 6 will also become 1 * Re-enables processing of all interrupts * * Error codes (error code = LCP_error & 0x0F00): * 0xF00 - error calling LCP_slaveCycleEnd() - end of data reception cycle from slave console */ static void LCP_slaveCycleEnd(); /** * Reset start and end indices of data in packet for transmission via Link Cable (LCP_sendPacket array) */ void LCP_clearSendHeadAndTail(); /** * Reset start and end indices of data in packet for reception via Link Cable (LCP_ReceivePacket array) */ void LCP_clearReceiveHeadAndTail(); /** * Library functions implementation */ /** * Opening console's 2nd port for data exchange via Link Cable * upon external interrupt occurrence - External interrupt (EX-INT) * interrupt mask level 2 for 68000 processor * setting callback function called upon EX-INT interrupt occurrence */ void LCP_open() { // capture Z80 coprocessor bus // // Write word $0100 to address $A11100 // and wait in loop until bit D8 becomes equal to 0 bool busTaken = Z80_getAndRequestBus(TRUE); // Disable interrupts via SR - Status Register, since interrupt mask level 7 will be set for 68000 processor // // Status Register looks like this: // Bit 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0 // --------------------------------------------------- // | T| -| S| -| -| I2,I1,I0 | -| -| -| X| N| Z| V| C| // --------------------------------------------------- // I2, I1, I0 - interrupt masks, define minimum level of serviced interrupt requests // // Total of 3 interrupt types: EX-INT, H-INT, V-INT // // | I2 | I1 | I0 | // // level 0 | 0 0 0 | ---------> lowest priority // level 1 | 0 0 1 | // level 2 | 0 1 0 | External interrupt (EX-INT) // level 3 | 0 1 1 | // level 4 | 1 0 0 | Horizontal interrupt (H-INT) // level 5 | 1 0 1 | // level 6 | 1 1 0 | Vertical interrupt (V-INT) // level 7 | 1 1 1 | ---------> highest priority // // When setting 7 = i.e. binary 111, I2 = 1, I1 = 1, I0 = 1 // all interrupts are ignored, since their levels are all lower SYS_setInterruptMaskLevel(7); // Set function that will be called upon occurrence of // external interrupt EX-INT - External interrupt // i.e. game code execution will be interrupted upon EX-INT interrupt occurrence, register state will be saved // then the function passed to SYS_setExtIntCallback - LCP_slaveCycle() will be called, upon completion register state is restored and // game code will continue from where it was interrupted SYS_setExtIntCallback(LCP_slaveCycle); // Enable external interrupt (interrupt mask level 2 for 68000 processor) // // Register 11 looks like this: // Bit 7 6 5 4 3 2 1 0 // | - | - | - | - | IE2 | VSCR | HSCR | LSCR | // // Setting register 11 to 8 or in binary to 00001000 // i.e. flags will take these values: // VSCR = 0 - vertical scroll mode = FULL SCROLL // HSCR = 0, LSCR = 0 - horizontal scroll mode = FULL SCROLL // IE2 = 1 - enables external interrupt (level 2 for 68000 External interrupt - EX-INT) VDP_setReg(11, 8); // ready for data exchange via console's 2nd port upon EX-INT interrupt occurrence // first reading data from port, then writing to port in external interrupt handler LCP_slaveCycle() // Interrupt on SYN line signal enabled, bit 7 = 1. // data line PC5 in output mode (transmission), bit 5 = 1. // data lines PC6, PC4, PC3, PC2, PC1, PC0 in input mode (reception). Corresponding bits = 0 // enable pins 0-3 of 2nd controller port for data reception // pin 5 for signal that data is received by our console (on other console this will be bit 6 of LCP_Data) // pin 6 signal that data was sent by other console (other console should change bit 5 of its LCP_Data) LCP_Ctrl = LCP_BIT7_AND_BIT5; // Set bit 5 to 1 in LCP_Data (on other console bit 6 will become 1 in LCP_Data) LCP_Data |= LCP_BIT5; // flag that port is open and data exchange after EX-INT interrupt occurrence is allowed LCP_portOpen = 1; // Enable all interrupts via SR - Status Register // // set level 1 for 68000 processor, which means all interrupts will be processed // since their mask is higher than 1 SYS_setInterruptMaskLevel(1); if (!busTaken) { // release Z80 bus // write word $0000 to address $A11100 Z80_releaseBus(); } } /** * Initialization of console's 2nd port for data exchange via Link Cable * for direct data writing to port and then reading data from port * EX-INT interrupts are disabled for this console * reset global variables */ void LCP_init() { // reset LCP_sendHead and LCP_sendTail to zero LCP_clearSendHeadAndTail(); // reset LCP_ReceiveHead and LCP_ReceiveTail to zero LCP_clearReceiveHeadAndTail(); // reset errors LCP_error = 0; // capture Z80 coprocessor bus bool busTaken = Z80_getAndRequestBus(TRUE); // flag that port is initialized and data exchange starts with writing to port without waiting for external interrupt occurrence // i.e. we trigger external interrupt on other console and after write cycle to port we start reading data from port LCP_portOpen = 0; // Disable all interrupts except V-INT via SR - Status Register, since interrupt mask level 5 will be set for 68000 processor // // Status Register looks like this: // Bit 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0 // --------------------------------------------------- // | T| -| S| -| -| I2,I1,I0 | -| -| -| X| N| Z| V| C| // --------------------------------------------------- // I2, I1, I0 - interrupt masks, define minimum level of serviced interrupt requests // // Total of 3 interrupt types: EX-INT, H-INT, V-INT // // | I2 | I1 | I0 | // // level 0 | 0 0 0 | ---------> lowest priority // level 1 | 0 0 1 | // level 2 | 0 1 0 | External interrupt (EX-INT) // level 3 | 0 1 1 | // level 4 | 1 0 0 | Horizontal interrupt (H-INT) // level 5 | 1 0 1 | // level 6 | 1 1 0 | Vertical interrupt (V-INT) // level 7 | 1 1 1 | ---------> highest priority SYS_setInterruptMaskLevel(5); // Disable external interrupt (interrupt mask level 2 for 68000 processor) // // Setting register 11 to 0, i.e: // VSCR = 0 - vertical scroll mode = FULL SCROLL // HSCR = 0, LSCR = 0 - horizontal scroll mode = FULL SCROLL // IE2 = 0 - disables external interrupt (level 2 for 68000 processor External interrupt - EX-INT) VDP_setReg(11, 0); // ready for data exchange via console's 2nd port not upon interrupt occurrence, but // through direct writing to port and then reading from it. For this, you need to use LCP_masterCycle() in your game code // // Interrupt on SYN line signal disabled, bit 7 = 0. // data line PC5 in output mode (transmission), bit 5 = 1. // data lines PC6, PC4, PC3, PC2, PC1, PC0 in input mode (reception). Corresponding bits = 0 // enable pins 0-3 of 2nd controller port for data reception // pin 5 for signaling events to other console (on other console bit 6 of LCP_Data will equal what we set in our 5th bit) // pin 6 signal from other console about events (other console should change bit 5 of its LCP_Data so that our 6th bit changes) LCP_Ctrl = LCP_BIT5; // Set bit 5 to 1 in LCP_Data (on other console bit 6 will become 1 in LCP_Data) LCP_Data |= LCP_BIT5; if (!busTaken) { // release Z80 bus // write word $0000 to address $A11100 Z80_releaseBus(); } } /** * Closing console port for data exchange via Link Cable * disable external interrupt handler - External interrupt (EX-INT) * interrupt mask level 2 for 68000 processor */ void LCP_close() { // disable EX-INT external interrupt handler - External interrupt in SEGA documentation SYS_setExtIntCallback(NULL); // reset LCP state LCP_init(); } /** * Reset start and end indices of data in packet for transmission via Link Cable (LCP_sendPacket array) */ void LCP_clearSendHeadAndTail() { LCP_sendHead = 0; LCP_sendTail = 0; } /** * Reset start and end indices of data in packet for reception via Link Cable (LCP_ReceivePacket array) */ void LCP_clearReceiveHeadAndTail() { LCP_ReceiveHead = 0; LCP_ReceiveTail = 0; } /** * Start of 2-byte (16-bit) data transmission cycle via Link Cable * Reset bit 5 in LCP_Data to 0 - data not ready for reading by other console * Set LCP_Ctrl = 00101111 to enable on controller's 2nd port: * pins 0-3 for data transmission, and pin 5 for signal that data can be read * by other console. As soon as we set it to 1, we expect pin 6 to be 0 * at function call time (if it's 1, we'll wait for 0 until timeout occurs and throw error 0xA if not received) * * Error codes (error code = LCP_error & 0x000F): * 0xA - data transmission preparation error (failed to get 0 on pin 6 of 2nd controller) * * If no errors occurred (LCP_error == 0 and LCP_timeOut == 0) */ static void LCP_startSendCycle() { // Reset bit 5 - data not ready for reading by other console yet LCP_Data &= ~(1 << 5); // LCP_Data = "r10rrrrr" - where r is any value and doesn't matter currently // set timeout for waiting for 0 in bit 6 of LCP_Data u16 timeout = LCP_TIME_OUT; do { timeout--; if (timeout == 0) { // failed to get 0 on pin 6 of 2nd controller LCP_timeOut++; // data transmission preparation error LCP_error = 0xA; return; } } while (LCP_Data & LCP_BIT6); // wait until bit 6 becomes 0 in LCP_Data // LCP_Data = "r00rrrrr" - where r is any value and doesn't matter currently // start data write cycle to 2nd port, write '00101111' to LCP_Ctrl // interrupt on SYN line signal disabled, bit 7 = 0. // data lines PC5, PC3, PC2, PC1, PC0 in output mode (transmission), bits 5, 3, 2, 1, 0 = 1. // data lines PC6, PC4 in input mode (reception). Corresponding bits = 0 // enable pins 0-3 of 2nd controller port for data transmission // pin 5 for signal that data can be read by other console (on other console this will be bit 6 of LCP_Data) // pin 6 signal that data was read by other console (other console should change bit 5 of its LCP_Data) LCP_Ctrl = LCP_BIT_5_3_2_1_0; } /** * Main 2-byte (16-bit) data transmission cycle via Link Cable * Transmission is done through LCP_Data - shared memory area of both consoles * 4 bits at a time, i.e. in 4 iterations since 2 bytes = 16 bits * Fills the lower 4 data bits in LCP_Data that we're sending * Sets or resets bit 5 depending on iteration in LCP_Data * Waits for data reception confirmation from other console in bit 6 of LCP_Data * If confirmation is not received, saves error in LCP_error * * Error codes (error code = LCP_error & 0x000F): * 0x1 - failed to receive confirmation on 1st iteration * 0x2 - failed to receive confirmation on 2nd iteration * 0x3 - failed to receive confirmation on 3rd iteration * 0x4 - failed to receive confirmation on 4th iteration * * data - 2 bytes of data (16 bits) to transmit * Let's assume initial data = "aaaayyyybbbbxxxx" - split 2 bytes (16 bits) into 4-bit chunks: * first transmit aaaa, then yyyy, then bbbb, and in 4th iteration xxxx * * At function call time LCP_Data = "r00rrrrr" - where r is any value and doesn't matter currently * LCP_startSendCycle function must have completed successfully first, or another LCP_send must complete successfully * * If no errors occurred (LCP_error == 0 and LCP_timeOut == 0) */ static void LCP_send(u16 data) { // timeout u16 timeout; // temporary variable for manipulations with LCP_Data content u8 tmp = 0; // i - data transmission iteration (total of four iterations) u8 i = 1; do { // cyclic shift left by 4 (now lower 4 bits contain data we want to transmit) // data = "aaaayyyybbbbxxxx" was for i = 1, for i = 3 was data = "bbbbxxxxaaaayyyy" data = (data << 4) | (data >> 12); // data = "yyyybbbbxxxxaaaa" became for i = 1, for i = 3 became data = "xxxxaaaayyyybbbb" // we'll transmit aaaa or bbbb depending on iteration 1 or 3 tmp = LCP_Data; // write 4 bits we want to transmit into lower 4 bits of LCP_Data // keep upper 4 bits from LCP_Data in place, i.e. (LCP_Data & 11110000) // and lower 4 bits of LCP_Data will be lower 4 bits from data, i.e. (data & 00001111) // LCP_Data = (LCP_Data & 11110000) | (data & 00001111) tmp = (tmp & LCP_HI_BITS) | (data & LCP_LO_BITS); LCP_Data = tmp; // after this operation: // LCP_Data = "r00raaaa" for i = 1, LCP_Data = "r00rbbbb" for i = 3 // first and third iteration of data transmission to other SEGA // set bit 5 in LCP_Data to 1 (signal that data can be read by other SEGA) LCP_Data |= (1 << 5); // LCP_Data = "r01raaaa" for i = 1, LCP_Data = "r01rbbbb" for i = 3 // On other SEGA, bit 6 in LCP_Data will change to 1, because pin 5 of our 2nd controller port // is connected to pin 6 of other SEGA's 2nd controller // set timeout timeout = LCP_TIME_OUT; // Wait for data to be read by other SEGA do { // decrease timeout value by 1 timeout--; if (timeout == 0) { // failed to receive signal from other SEGA that data was read // Increase LCP_timeOut by 1 LCP_timeOut++; // write i to LCP_error, which equals 1 or 3 (iteration) LCP_error = i; // LCP_error == 0x1 - failed to receive confirmation on 1st iteration // LCP_error == 0x3 - failed to receive confirmation on 3rd iteration // Exit function with error, LCP_error != 0 return; } // wait until bit 6 becomes 1 in LCP_Data (signal that data was read by other SEGA) // Other SEGA should set bit 5 in its LCP_Data to 1, because its pin 5 of 2nd controller port // is connected to pin 6 of our SEGA's 2nd controller, and when it sets bit 5 to 1, our bit 6 will also become 1 } while (!(LCP_Data & LCP_BIT6)); // data transmission iteration completed successfully, // transmitted via Link Cable "aaaa" for 1st iteration or "bbbb" for 3rd iteration // LCP_Data = "r11raaaa" for i = 1, LCP_Data = "r11rbbbb" for i = 3 // increase iteration number i++; // now i = 2 or i = 4 // cyclic shift left by 4 (now lower 4 bits contain next data we want to transmit) // data = "yyyybbbbxxxxaaaa" was for i = 2, for i = 4 was data = "xxxxaaaayyyybbbb" data = (data << 4) | (data >> 12); // data = "bbbbxxxxaaaayyyy" became for i = 2, for i = 4 became data = "aaaayyyybbbbxxxx" tmp = LCP_Data; // write 4 bits we want to transmit into lower 4 bits of LCP_Data // Keep upper 4 bits from LCP_Data in place, i.e. (LCP_Data & 11110000) // and lower 4 bits of LCP_Data will be lower 4 bits from data, i.e. (data & 00001111) // LCP_Data = (LCP_Data & 11110000) | (data & 00001111) tmp = (tmp & LCP_HI_BITS) | (data & LCP_LO_BITS); LCP_Data = tmp; // after this operation: // LCP_Data = "r11ryyyy" for i = 2, LCP_Data = "r00rxxxx" for i = 4 // second and fourth iteration of data transmission to other SEGA // set bit 5 in LCP_Data to 0 (signal that data can be read by other SEGA) LCP_Data &= ~(1 << 5); // LCP_Data = "r10ryyyy" for i = 2, LCP_Data = "r10rxxxx" for i = 4 // set timeout again timeout = LCP_TIME_OUT; // Wait for data to be read by other SEGA do { // decrease timeout value by 1 timeout--; if (timeout == 0) { // failed to receive signal from other SEGA that data was read // Increase LCP_timeOut by 1 LCP_timeOut++; // write i to LCP_error, which equals 2 or 4 (iteration) LCP_error = i; // LCP_error == 0x2 - failed to receive confirmation on 2nd iteration // LCP_error == 0x4 - failed to receive confirmation on 4th iteration // Exit function with error, LCP_error != 0 return; } // wait until bit 6 becomes 0 in LCP_Data (signal that data was read by other SEGA) } while (LCP_Data & LCP_BIT6); // data transmission iteration completed successfully, // transmitted via Link Cable "yyyy" for 2nd iteration or "xxxx" for 4th iteration // LCP_Data = "r00ryyyy" for i = 2, LCP_Data = "r00rxxxx" for i = 4 // increase iteration number i++; // now i = 3 for 2nd iteration or i = 5 for 4th iteration // continue until i becomes 5, meaning everything transmitted, exit (2 cycles total - 2 transmission iterations each) } while (i < 5); } /** * End of 2-byte (16-bit) data transmission cycle via Link Cable * Set LCP_Ctrl = 00100000 to enable on controller's 2nd port: * pins 0-3 for data reception, and pin 5 for signal that our SEGA is ready to receive data. * Reset bit 5 in LCP_Data to 0, wait for confirmation that other console is ready to send data - * until bit 6 in LCP_Data becomes 1 or timeout occurs, and throw error 0xB if not received. * * Error codes (error code = LCP_error & 0x000F): * 0xB - data transmission cycle end error (failed to get 1 in bit 6 of LCP_Data) * * If no errors occurred (LCP_error == 0 and LCP_timeOut == 0) */ static void LCP_endSendCycle() { // set timeout u16 timeout = LCP_TIME_OUT; // switch port to data reception mode // Interrupt on SYN line signal disabled, bit 7 = 0. // data line PC5 in output mode (transmission), bit 5 = 1. // data lines PC6, PC4, PC3, PC2, PC1, PC0 in input mode (reception). Corresponding bits = 0 // enable pins 0-3 of 2nd controller port for data reception // pin 5 for signaling events to other console (on other console bit 6 of LCP_Data will equal what we set in our 5th bit) // pin 6 signal from other console about events (other console should change bit 5 of its LCP_Data so that our 6th bit changes) LCP_Ctrl = LCP_BIT5; // Reset bit 5 to 0 in LCP_Data LCP_Data &= ~(1 << 5); // LCP_Data = "r00rrrrr" - where r is any value and doesn't matter currently // Wait for bit 6 in LCP_Data to become 1, other SEGA is ready to send data // and our console is ready to receive do { // decrease timeout value by 1 timeout--; if (timeout == 0) { // failed to get 1 in bit 6 of LCP_Data, meaning second SEGA is not ready to send data LCP_timeOut++; // 0xB - data transmission cycle end error LCP_error = 0xB; // Exit function with error, LCP_error != 0 return; } // wait until bit 6 becomes 1 in LCP_Data (signal that other SEGA is ready to send data to our SEGA) } while (!(LCP_Data & LCP_BIT6)); // LCP_Data = "r10rrrrr" - where r is any value and doesn't matter currently // It is assumed that after executing this function, if we want to read data via Link Cable // we should call LCP_startReceiveCycle() } /** * Start of 2-byte (16-bit) data reception cycle via Link Cable * Reset bit 5 in LCP_Data to 0 (ready for reading) */ static void LCP_startReceiveCycle() { // Reset bit 5 in LCP_Data (ready for reading) LCP_Data &= ~(1 << 5); // LCP_Data = "r00rrrrr" - where r is any value and doesn't matter currently } /** * Main 2-byte (16-bit) data reception cycle via Link Cable * Receives 4 bits at a time over 4 iterations through LCP_Data (lower 4 bits) * Sets or resets bit 5 in LCP_Data depending on iteration, thereby * confirming successful reading to the console that sent us data * Waits for confirmation in bit 6 of LCP_Data from other console that data can be read * * Error codes (error code = LCP_error & 0x000F): * 0x5 - failed to receive confirmation that data can be read on 1st iteration * 0x6 - failed to receive confirmation that data can be read on 2nd iteration * 0x7 - failed to receive confirmation that data can be read on 3rd iteration * 0x8 - failed to receive confirmation that data can be read on 4th iteration * * return - 2 bytes of data (16 bits) received from other SEGA "aaaayyyybbbbxxxx" * if no errors occurred (LCP_error == 0 and LCP_timeOut == 0) */ static u16 LCP_Receive() { // here will be data read from other SEGA, 16-bit variable (2 bytes) u16 data = 0; // data = "0000000000000000" // temporary variable for manipulations with LCP_Data content u8 tmp = 0; // timeout u16 timeout; // data transmission iteration (total of four iterations) // starting from 5 so reception errors differ from transmission errors // 5 - 1st reception iteration, 6 - 2nd, 7 - 3rd, 8 - 4th reception iteration u8 i = 5; do { // set timeout timeout = LCP_TIME_OUT; // Wait for bit 6 in LCP_Data to become 1, other SEGA has sent data do { // decrease timeout value by 1 timeout--; if (timeout == 0) { // failed to receive signal from other SEGA that data was sent to us // Increase LCP_timeOut LCP_timeOut++; // write i to LCP_error, which equals 5 or 7 (1st or 3rd iteration) LCP_error = i; // LCP_error == 0x5 - failed to receive confirmation that data can be read on 1st iteration // LCP_error == 0x7 - failed to receive confirmation that data can be read on 3rd iteration // If timeout reached 0, exit loop and return current data return data; // data = "0000000000000000" for 1st iteration (i = 5) // or data = "00000000aaaayyyy" for 3rd iteration (i = 7) } // loop continues until bit 6 becomes 1 - signal from other SEGA that data can be read by us // Other SEGA should set bit 5 in its LCP_Data to 1, because its pin 5 of 2nd controller port // is connected to pin 6 of our SEGA's 2nd controller, and when it sets bit 5 to 1, our bit 6 will also become 1 } while (!(LCP_Data & LCP_BIT6)); // data reception iteration completed successfully, // received via Link Cable "aaaa" for 1st iteration or "bbbb" for 3rd iteration // LCP_Data = "r10raaaa" for i = 5, LCP_Data = "r10rbbbb" for i = 7 // temporary variable for manipulations with LCP_Data content tmp = LCP_Data; // now we need to save received 4 bits to data // for this we shift all bits in data left by 4 bits (data << 4) // for 1st iteration this doesn't matter since it's 0, but for 3rd (i = 7) we transform "00000000aaaayyyy" into "0000aaaayyyy0000" // now take only lower 4 bits from LCP_Data (LCP_Data & 00001111) and combine with result from first expression data = (data << 4) | (tmp & LCP_LO_BITS); // data = "000000000000aaaa" for 1st iteration (i == 5), "0000aaaayyyybbbb" for 3rd iteration (i == 7) // 1st or 2nd iteration of data reception from other SEGA completed, data saved to data // set bit 5 in LCP_Data to 1 (read data, notify other SEGA about this) LCP_Data |= (1 << 5); // LCP_Data = "r11raaaa" for 1st iteration (i == 5) or LCP_Data = "r11rbbbb" for 3rd iteration (i == 7) // increase iteration number i++; // now i = 6 for 2nd iteration or i = 8 for 4th // Set timeout again timeout = LCP_TIME_OUT; // Wait for bit 6 in LCP_Data to become 0, other SEGA has sent data do { // decrease timeout value by 1 timeout--; if (timeout == 0) { // failed to receive signal from other SEGA that data was sent to us // Increase LCP_timeOut LCP_timeOut++; // write i to LCP_error, which equals 6 or 8 (2nd or 4th iteration) LCP_error = i; // LCP_error == 0x6 - failed to receive confirmation that data can be read on 2nd iteration // LCP_error == 0x8 - failed to receive confirmation that data can be read on 4th iteration // If timeout reached 0, exit loop and return current data return data; // data = "000000000000aaaa" for 1st iteration (i = 6) // or data = "0000aaaayyyybbbb" for 3rd iteration (i = 8) } // loop continues until bit 6 becomes 0 - signal from other SEGA that data can be read by us // Other SEGA should set bit 5 in its LCP_Data to 0, because its pin 5 of 2nd controller port // is connected to pin 6 of our SEGA's 2nd controller, and when it sets bit 5 to 0, our bit 6 will also become 0 } while (LCP_Data & LCP_BIT6); // data reception iteration completed successfully, // received via Link Cable "yyyy" for 2nd iteration or "xxxx" for 4th iteration // LCP_Data = "r01ryyyy" for i = 6, LCP_Data = "r01rxxxx" for i = 8 tmp = LCP_Data; // now we need to save received 4 bits to data // for this we shift all bits in data left by 4 bits (data << 4) // for 2nd iteration (i == 6) we transform "000000000000aaaa" into "00000000aaaa0000" // for 4th iteration (i = 8) we transform "0000aaaayyyybbbb" into "aaaayyyybbbb0000" // take only lower 4 bits from LCP_Data (LCP_Data & 00001111) and combine with result from first expression data = (data << 4) | (tmp & LCP_LO_BITS); // data = "00000000aaaayyyy" for 2nd iteration (i == 6), "aaaayyyybbbbxxxx" for 4th iteration (i == 8) // 2nd or 4th iteration of data reception from other SEGA completed, data saved to data // set bit 5 in LCP_Data to 0 (read data, notify other SEGA about this) LCP_Data &= ~(1 << 5); // LCP_Data = "r00ryyyy" for 2nd iteration (i == 6) or LCP_Data = "r00rxxxx" for 4th iteration (i == 8) // increase iteration number i++; // now i = 7 for 2nd iteration or i = 9 for 4th // continue until i becomes 9, meaning everything received, exit (2 cycles total - 2 reception iterations each) } while( i < 9); // return read 2 bytes (16 bits) via Link Cable return data; } /** * End of 2-byte (16-bit) data reading cycle via Link Cable * Wait for confirmation that the other console understood the end of data reception from our console - * until bit 6 in LCP_Data becomes 0 or timeout occurs, and throw error 0x9 if not received. * Set bit 5 in LCP_Data to 1 - received confirmation from the other SEGA that it successfully transmitted everything. * * Error codes (error code = LCP_error & 0x000F): * 0x9 - failed to receive confirmation that data was received by the other SEGA * * If no errors occurred (LCP_error == 0 and LCP_timeOut == 0) */ static void LCP_endReceiveCycle() { // set timeout u16 timeout = LCP_TIME_OUT; // wait for the other SEGA console to understand that we successfully read all 2 bytes of data from it do { // decrease timeout value by 1 timeout--; if (timeout == 0) { LCP_timeOut++; // 0x9 - failed to receive confirmation that data was received by the other SEGA LCP_error = 0x9; // exit function with error in LCP_error and LCP_timeOut > 0 return; } // loop continues until bit 6 in LCP_Data becomes 0 - signal from other SEGA that data was read } while (LCP_Data & LCP_BIT6); // after exiting the loop // LCP_Data = "r00rxxxx" // set bit 5 in LCP_Data to 1 - received confirmation from other SEGA that it successfully transmitted everything // LCP_Data = "r10rxxxx" LCP_Data |= (1 << 5); } /** * Function for copying transferObject - as byte array * into LCP_sendPacket for packet transmission via Link Cable * first 2 bytes in packet contain type of transmitted object (cannot be 0) * then packet contains object data (2 bytes each), according to object sizes table objectTypeSizes * multiple objects can be transmitted at once, main thing is they fit in buffer * i.e. function can be called multiple times in row, until we get * errors described below * * Error codes (error code = LCP_error & 0x000F): * 0xC - transmitted object size is negative or equal to 0 * 0xD - transmitted object size exceeds remaining space in packet * 0xF - packet data start index is greater than data end index * * transferObject - transmitted object as byte array via Link Cable * objectType - type of transmitted object (number equal to index in object sizes array) * objectTypeSizes - array of object sizes (defined in main code of YOUR game) */ void LCP_objectToPacketForSend(u8 *transferObject, u16 objectType , u16 *objectTypeSizes) { // size of transmitted object from object sizes array u16 objectSize = objectTypeSizes[objectType]; // end index of data in transmission packet LCP_sendPacket u16 tail = LCP_sendTail; // start index of data in transmission packet LCP_sendPacket u16 head = LCP_sendHead; // check that transmitted object size is greater than 0 if (objectSize <= 0) { // 0xC - transmitted object size is negative or equal to 0 LCP_error = 0xC; // exit function with error in LCP_error return; } // check that we won't exceed LCP_sendPacket array bounds when transmitting object if (objectSize > LCP_PACKET_SIZE - head) { // 0xD - transmitted object size exceeds remaining space in packet LCP_error = 0xD; // exit function with error in LCP_error return; } // check that data start index is not greater than data end index in packet if (head > tail) { // 0xF - packet data start index is greater than data end index LCP_error = 0xF; LCP_clearSendHeadAndTail(); // exit function with error in LCP_error return; } // first 2 bytes (16 bits) of packet data will contain type of transmitted object LCP_sendPacket[tail] = objectType; // need to increase packet data end index by 1 tail++; // copy transmitted object transferObject into data transmission packet - LCP_sendPacket, starting from index // tail with size objectSize memcpy(LCP_sendPacket + tail, transferObject, objectSize); // update value of data end index in LCP_sendPacket packet LCP_sendTail = tail + objectSize; } /** * Function extracts next object as byte array transferObject from received packet LCP_ReceivePacket * via Link Cable and returns type of this object or 0 if object couldn't be extracted from LCP_ReceivePacket * since we can transmit multiple objects at once, it's assumed possible to call this function multiple times * in row until we get 0, which means - all objects have been extracted from transmitted packet * * first 2 bytes of packet in LCP_ReceivePacket contain type of transmitted object (cannot be 0) * then packet contains object data (2 bytes each), according to object sizes table objectSizes * multiple objects can be transmitted at once, main thing is they fit in LCP_ReceivePacket array * * Error codes (error code = LCP_error & 0xF000): * 0x1000 - no object in received packet, all already extracted from packet or nothing was transmitted to us * 0x2000 - size of extracted object from read packets buffer - negative or equal to 0 * 0x3000 - size of extracted object exceeds remaining data in received data packet * 0x4000 - size of extracted object exceeds remaining size of LCP_ReceivePacket array * * transferObject - next received object as byte array via Link Cable * objectSizes - array of object sizes (defined in main code of YOUR game) * * return - type of received object or 0 if couldn't extract object from received packet */ u16 LCP_getNextObjectFromReceivePacket(u8 *transferObject, u16 *objectSizes) { // current index in received packet from which we'll start reading data u16 head = LCP_ReceiveHead; // end index of data in received packet u16 tail = LCP_ReceiveTail; // object type that function will return, or 0 if no object was found in received packet u16 objectType; // object size from object sizes array according to object type u16 objectSize = 0; // Check for data presence in received packet (that data start doesn't match data end) if (head >= tail) { // 0x1000 - no object in received packet, all already extracted from packet or nothing was transmitted to us LCP_error |= 0x1000; // No data, return 0 (couldn't extract any object) return 0; } // read first byte - object type // it's assumed that objectSizes is declared somewhere in code of YOUR game !!! objectType = LCP_ReceivePacket[head]; // since we read object type, we need to shift data start index by 1 head++; // get object size by its type from object sizes table objectSize = objectSizes[objectType]; // if object size is negative or equal to 0 - error! if (objectSize <= 0) { // 0x2000 - size of extracted object from read packets buffer - negative or equal to 0 LCP_error |= 0x2000; // No data, return 0 (couldn't extract any object) return 0; } // If object size exceeds remaining data in read buffer - error! if (objectSize > tail - head) { // 0x3000 - size of extracted object exceeds remaining data in received data packet LCP_error |= 0x3000; // No data, return 0 (couldn't extract any object) return 0; } // If object size exceeds remaining size of array for data reception packet if (objectSize > LCP_PACKET_SIZE - head) { // 0x4000 - size of extracted object exceeds remaining size of LCP_ReceivePacket array LCP_error |= 0x4000; // No data, return 0 (couldn't extract any object) return 0; } // copy to byte array transferObject from received packet LCP_ReceivePacket starting from index head // objectSize bytes, i.e. entire object from LCP_ReceivePacket to transferObject memcpy(transferObject, LCP_ReceivePacket + head, objectSize); // since we extracted next object from packet, move start index of non-extracted objects in packet // to head + objectSize, from where on next call of LCP_getNextObjectFromReceivePacket we'll extract // next object LCP_ReceiveHead = head + objectSize; if (LCP_ReceiveHead == LCP_ReceiveTail) { // if everything was read, we can reset LCP_ReceiveHead and LCP_ReceiveTail to 0 LCP_clearReceiveHeadAndTail(); } // return type of object read into transferObject from received packet LCP_ReceivePacket return objectType; } /** * Transmission and then reception cycle via Link Cable for SEGA master console * at the very beginning disables all interrupt processing and resets LCP_timeOut and LCP_error to 0 * both in case of error and in case of successful function completion, i.e. always call LCP_masterCycleEnd() at the end * to switch console's 2nd port to correct state and enable all interrupt processing. * * Error codes (error code = LCP_error & 0x00F0): * 0x10 - error calling LCP_startSendCycle() - start of data transmission from master console * 0x20 - error calling LCP_send(size) - transmission of 2 bytes (packet size) from master console * 0x30 - error calling LCP_send(data) - transmission of 2 bytes (packet data) from master console * 0x40 - error calling LCP_send(checksum) - transmission of 2 bytes (checksum) from master console * 0x50 - error calling LCP_endSendCycle() - end of main packet transmission cycle from master to slave console * 0x60 - error calling LCP_startReceiveCycle() - start of data reception cycle from slave console to master * 0x70 - error calling data = LCP_Receive() - reception of 2 bytes (packet checksum) from slave console * 0x80 - checksum calculated by master console <> checksum received from slave console * 0x90 - error calling size = LCP_Receive() - reception of 2 bytes (packet size) from slave console * 0xA0 - error calling data = LCP_Receive() - reception of 2 bytes (packet data) from slave console * 0xB0 - error calling data = LCP_Receive() - main cycle of receiving 2 bytes (checksum) from slave console * 0xC0 - checksum calculated by master console <> checksum received from slave console * 0xD0 - error calling LCP_endReceiveCycle() - end of data reception cycle from slave console * 0xE0 - error calling LCP_startSendCycle() - start of checksum transmission from master to slave console * 0xF0 - error calling LCP_send(checksum) - transmission of checksum from master to slave */ void LCP_masterCycle() { // size of transmitted or received data s16 size; // checksum for verifying transmitted data u16 checksum; // current index of transmitted or received data u16 head; // transmitted or received 2 bytes (16 bits) via Link Cable Protocol u16 data; // disable interrupt processing SYS_disableInts(); // Clear timeout LCP_timeOut = 0; // Clear errors LCP_error = 0; // start of data transmission cycle via Link Cable from main console (master) to slave console // trigger external interrupt External interrupt (EX-INT) on slave console LCP_startSendCycle(); if (LCP_timeOut) { // 0x10 - error calling LCP_startSendCycle() - start of data transmission from master console LCP_error |= 0x10; LCP_masterCycleEnd(); // Exit function with error, LCP_error != 0 return; } // calculate size of data to transmit based on end and start indices in transmission packet size = LCP_sendTail - LCP_sendHead; if (size < 0) { // if size less than 0, reset both indices and size of transmitted data LCP_clearSendHeadAndTail(); size = 0; } // send packet size to slave console via Link Cable from master console LCP_send(size); if (LCP_timeOut) { // 0x20 - error calling LCP_send(size) - transmission of 2 bytes (packet size) from master console LCP_error |= 0x20; LCP_masterCycleEnd(); // Exit function with error, LCP_error != 0 return; } // reset checksum checksum = 0; // set index in transmission buffer to start of data in LCP_sendPacket head = LCP_sendHead; // transmit data if size greater than 0 (there is something to transmit) for (u16 i = 0; i < size; i++) { // extract next 2 bytes from packet data for transmission data = LCP_sendPacket[head]; // increase index in transmission buffer by 1 head++; // calculate checksum to verify successful data transmission checksum += data; // send next 2 bytes via Link Cable to slave console LCP_send(data); if (LCP_timeOut) { // 0x30 - error calling LCP_send(data) - transmission of 2 bytes (packet data) from master console LCP_error |= 0x30; LCP_masterCycleEnd(); // Exit function with error, LCP_error != 0 return; } } // send checksum to other console to verify previously transmitted data LCP_send(checksum); if (LCP_timeOut) { // 0x40 - error calling LCP_send(checksum) - transmission of 2 bytes (checksum) from master console LCP_error |= 0x40; LCP_masterCycleEnd(); // Exit function with error, LCP_error != 0 return; } // completion of data transmission cycle via Link Cable from master to slave console LCP_endSendCycle(); if (LCP_timeOut) { // 0x50 - error calling LCP_endSendCycle() - end of main packet transmission cycle from master to slave console LCP_error |= 0x50; LCP_masterCycleEnd(); // Exit function with error, LCP_error != 0 return; } // start of data reception from slave SEGA in main cycle LCP_startReceiveCycle(); if (LCP_timeOut) { // 0x60 - error calling LCP_startReceiveCycle() - start of data reception cycle from slave console to master LCP_error |= 0x60; LCP_masterCycleEnd(); // Exit function with error, LCP_error != 0 return; } // read first 2 bytes from slave console data = LCP_Receive(); if (LCP_timeOut) { // 0x70 - error calling data = LCP_Receive() - reception of 2 bytes (packet checksum) from slave console LCP_error |= 0x70; LCP_masterCycleEnd(); // Exit function with error, LCP_error != 0 return; } // check that sum received from slave console equals checksum calculated in main cycle if (data == checksum) { // data successfully received by slave SEGA // reset start index of data to transmit and end index in buffer // since slave console received all data successfully LCP_clearSendHeadAndTail(); } else { // 0x80 - checksum calculated by master console <> checksum received from slave console LCP_error |= 0x80; // don't interrupt function since no timeout occurred, try to receive data from slave console // next time data will be sent again! } // reset checksum checksum = 0; // receive first 2 bytes from slave console // size contains 2 bytes received from slave console since packet data size is stored there size = LCP_Receive(); if (LCP_timeOut) { // 0x90 - error calling size = LCP_Receive() - reception of 2 bytes (packet size) from slave console LCP_error |= 0x90; LCP_masterCycleEnd(); // Exit function with error, LCP_error != 0 return; } // current index to start of data in LCP_ReceivePacket head = LCP_ReceiveTail; // receive data if size greater than 0 (there is something to receive) for (u16 i = 0; i < size; i++) { // receive next 2 bytes from slave console via Link Cable data = LCP_Receive(); if (LCP_timeOut) { // 0xA0 - error calling data = LCP_Receive() - reception of 2 bytes (packet data) from slave console LCP_error |= 0xA0; LCP_masterCycleEnd(); // Exit function with error, LCP_error != 0 return; } // calculate checksum checksum += data; // save read 2 bytes into received objects data packet LCP_ReceivePacket[head] = data; // change current position index in received objects data packet head++; } // receive checksum from slave console data = LCP_Receive(); if (LCP_timeOut) { // 0xB0 - error calling data = LCP_Receive() - main cycle of receiving 2 bytes (checksum) from slave console LCP_error |= 0xB0; LCP_masterCycleEnd(); // Exit function with error, LCP_error != 0 return; } // check that received checksum from slave console equals calculated one if (data == checksum) { // set data end index to current index in received data buffer LCP_ReceiveTail = head; } else { // 0xC0 - checksum calculated by master console <> checksum received from slave console LCP_error |= 0xC0; // therefore don't move end index for received data packet LCP_ReceivePacket // but since no timeouts occurred, continue function execution } // completion of data reception from slave console LCP_endReceiveCycle(); if (LCP_timeOut) { // 0xD0 - error calling LCP_endReceiveCycle() - end of data reception cycle from slave console LCP_error |= 0xD0; LCP_masterCycleEnd(); // Exit function with error, LCP_error != 0 return; } // start of data transmission to slave console from master LCP_startSendCycle(); if (LCP_timeOut) { // 0xE0 - error calling LCP_startSendCycle() - start of checksum transmission from master to slave console LCP_error |= 0xE0; LCP_masterCycleEnd(); // Exit function with error, LCP_error != 0 return; } // send checksum to slave console from master LCP_send(checksum); if (LCP_timeOut) { // 0xF0 - error calling LCP_send(checksum) - transmission of checksum from master to slave LCP_error |= 0xF0; LCP_masterCycleEnd(); // Exit function with error, LCP_error != 0 return; } // finish data transmission LCP_endSendCycle(); // finish packet transmission/reception LCP_masterCycleEnd(); } /** * End of data transmission and reception cycle via Link Cable for SEGA master console * switches console's 2nd port to data reception mode via Link Cable, on all pins except pin 5 * Set bit 5 in LCP_Ctrl to 1, others to 0, which means we no longer transmit data in bits 0-3 * Set bit 5 in LCP_Data to 1 for our master console, on the other console (slave) bit 6 will also become 1 * re-enables processing of all interrupts */ static void LCP_masterCycleEnd() { // switch port to data reception mode // Interrupt on SYN line signal disabled, bit 7 = 0. // data line PC5 in output mode (transmission), bit 5 = 1. // data lines PC6, PC4, PC3, PC2, PC1, PC0 in input mode (reception). Corresponding bits = 0 // enable pins 0-3 of 2nd controller port for data reception // pin 5 for signaling events to other console (on other console bit 6 of LCP_Data will equal what we set in our 5th bit) // pin 6 signal from other console about events (other console should change bit 5 of its LCP_Data so that our 6th bit changes) LCP_Ctrl = LCP_BIT5; // set bit 5 in LCP_Data to 1 LCP_Data |= (1 << 5); // enable processing of all interrupts SYS_enableInts(); } /** * Reception and then transmission cycle via Link Cable for SEGA slave console * This is an EX-INT external interrupt handler - External interrupt in SEGA documentation * It MUST NOT be called directly from game code! * * This function will be set as EX-INT external interrupt handler when LCP_open() is called from YOUR game code * and will be disabled as external interrupt handler when LCP_close() is called from YOUR game code * * Function call always occurs asynchronously, interrupting your game code execution at random, unpredictable time for main game code! * * At the very beginning, it disables all interrupt processing and resets LCP_timeOut and LCP_error to 0 * * Error codes (error code = LCP_error & 0x0F00): * 0x100 - error calling LCP_slaveCycle() - second console port not open for data exchange * 0x200 - error calling LCP_startReceiveCycle() - start of data reception from master console * 0x300 - error calling size = LCP_Receive() - receiving size of transmitted data from master console * 0x400 - error calling data = LCP_Receive() - receiving next 2 bytes of packet data from master console * 0x500 - error calling data = LCP_Receive() - receiving checksum from master console * 0x600 - error calling LCP_endReceiveCycle() - end of data reception from master console * 0x700 - error calling LCP_startSendCycle() - start of data transmission from slave console * 0x800 - error calling LCP_send(checksum) - transmitting checksum from slave console * 0x900 - error calling LCP_send(size) - transmitting size of packet to be sent from slave console * 0xA00 - error calling LCP_send(data) - transmitting next 2 bytes of packet data from slave console * 0xB00 - error calling LCP_send(checksum) - transmitting checksum from slave console * 0xC00 - error calling LCP_endSendCycle() - end of data transmission from slave console * 0xD00 - error calling LCP_startReceiveCycle() - start of data reception from master console * 0xE00 - error calling data = LCP_Receive() - receiving checksum from master console * * Error codes (error code = LCP_error & 0x00F0): * 0x80 - checksum calculated by slave console <> checksum received from master console * 0xC0 - checksum calculated by slave console <> checksum received from master console */ static void LCP_slaveCycle() { // size of transmitted or received data s16 size; // checksum for verifying transmitted data u16 checksum = 0; // current index of transmitted or received data u16 head = LCP_ReceiveTail; // transmitted or received 2 bytes (16 bits) via Link Cable u16 data; LCP_error = 0; LCP_timeOut = 0; // switch port to data reading mode // Interrupt on SYN line signal disabled, bit 7 = 0. // data line PC5 in output mode (transmission), bit 5 = 1. // data lines PC6, PC4, PC3, PC2, PC1, PC0 in input mode (reception). Corresponding bits = 0 // enable pins 0-3 of 2nd controller port for data reception // pin 5 for signaling events to other console (on other console bit 6 of LCP_Data will equal what we set in our 5th bit) // pin 6 signal from other console about events (other console should change bit 5 of its LCP_Data so that our 6th bit changes) LCP_Ctrl = LCP_BIT5; if (!LCP_portOpen) { // port not open // 0x100 - error calling LCP_slaveCycle() - second console port not open for data exchange LCP_error |= 0x100; return; } // disable all interrupt processing SYS_disableInts(); // start data reception cycle for our slave console via Link Cable from master console LCP_startReceiveCycle(); if (LCP_timeOut) { // 0x200 - error calling LCP_startReceiveCycle() - start of data reception from master console LCP_error |= 0x200; LCP_slaveCycleEnd(); return; } // first 2 bytes of data - size of packet transmitted to our console (slave) via Link Cable from master console size = LCP_Receive(); if (LCP_timeOut) { // 0x300 - error calling size = LCP_Receive() - receiving size of transmitted data from master console LCP_error |= 0x300; LCP_slaveCycleEnd(); return; } // receive packet body from master console via Link Cable by our console (slave) for (u16 i = 0; i < size; i++) { // get 2 bytes of data into data by our slave console via Link Cable from master console data = LCP_Receive(); if (LCP_timeOut) { // 0x400 - error calling data = LCP_Receive() - receiving next 2 bytes of packet data from master console LCP_error |= 0x400; LCP_slaveCycleEnd(); return; } // calculate verification sum checksum += data; // save received 2 bytes into reception packet at index head LCP_ReceivePacket[head] = data; // increase head - start index of data in LCP_ReceivePacket by 1 head++; } // after packet body, receive checksum of sent data in data from master console data = LCP_Receive(); if (LCP_timeOut) { // 0x500 - error calling data = LCP_Receive() - receiving checksum from master console LCP_error |= 0x500; LCP_slaveCycleEnd(); return; } // if verification sum received from master console in data equals our calculated one, // then save head index into global variable LCP_ReceiveTail - end index of received packet data // from master console if (data == checksum) { LCP_ReceiveTail = head; } else { // if LCP_error & 0x00F0 = 0x80 - checksum calculated by slave console <> checksum received from master console LCP_error |= 0x80; // don't interrupt function since no timeout occurred, try to send data from our slave console to master // and checksum calculated by our console, so master understands that data needs to be sent again } // end of data reception cycle for our slave console from master console via Link Cable LCP_endReceiveCycle(); if (LCP_timeOut) { // 0x600 - error calling LCP_endReceiveCycle() - end of data reception from master console LCP_error |= 0x600; LCP_slaveCycleEnd(); return; } // start data transmission cycle from our slave console via Link Cable to master console LCP_startSendCycle(); if (LCP_timeOut) { // 0x700 - error calling LCP_startSendCycle() - start of data transmission from slave console LCP_error |= 0x700; LCP_slaveCycleEnd(); return; } // transmit calculated checksum to master console from our slave console via Link Cable LCP_send(checksum); if (LCP_timeOut) { // 0x800 - error calling LCP_send(checksum) - transmitting checksum from slave console LCP_error |= 0x800; LCP_slaveCycleEnd(); return; } // calculate size of packet to transmit size = LCP_sendTail - LCP_sendHead; if (size < 0) { size = 0; LCP_clearSendHeadAndTail(); } // transmit packet body size from our slave console via Link Cable to master console LCP_send(size); if (LCP_timeOut) { // 0x900 - error calling LCP_send(size) - transmitting size of packet to be sent from slave console LCP_error |= 0x900; LCP_slaveCycleEnd(); return; } // reset checksum value checksum = 0; // set head index to start of packet to be transmitted head = LCP_sendHead; // transmit packet body from our console (slave) via Link Cable to master console for (u16 i = 0; i < size; i++) { // write 2 bytes to data that we'll transmit from slave console packet data = LCP_sendPacket[head]; // increase head index by 1 for start of data in LCP_sendPacket to be sent head++; // calculate verification sum checksum += data; // transmit 2 bytes of packet body from our slave console via Link Cable to master console LCP_send(data); if (LCP_timeOut) { // 0xA00 - error calling LCP_send(data) - transmitting next 2 bytes of packet data from slave console LCP_error |= 0xA00; LCP_slaveCycleEnd(); return; } } // after packet body, transmit checksum of sent packet data // from our slave console via Link Cable to master console LCP_send(checksum); if (LCP_timeOut) { // 0xB00 - error calling LCP_send(checksum) - transmitting checksum from slave console LCP_error |= 0xB00; LCP_slaveCycleEnd(); return; } // complete data transmission cycle from our slave console via Link Cable to master console LCP_endSendCycle(); if (LCP_timeOut) { // 0xC00 - error calling LCP_endSendCycle() - end of data transmission from slave console LCP_error |= 0xC00; LCP_slaveCycleEnd(); return; } // start data reception cycle for our slave console via Link Cable from master console LCP_startReceiveCycle(); if (LCP_timeOut) { // 0xD00 - error calling LCP_startReceiveCycle() - start of data reception from master console LCP_error |= 0xD00; LCP_slaveCycleEnd(); return; } // receive checksum of received data by master console via Link Cable from our slave console data = LCP_Receive(); if (LCP_timeOut) { // 0xE00 - error calling data = LCP_Receive() - receiving checksum from master console LCP_error |= 0xE00; LCP_slaveCycleEnd(); return; } if (data == checksum) { // if received checksum in data from master console equals transmitted and calculated by our console (slave), // then set packet start index and packet end index to 0 (everything successfully sent) LCP_clearSendHeadAndTail(); } else { // 0xC0 - checksum calculated by slave console <> checksum received from master console LCP_error |= 0xC0; // therefore don't move start index for received data packet LCP_sendPacket // but since no timeouts occurred, continue function execution } // end of data reception cycle for our slave console from master console via Link Cable LCP_endReceiveCycle(); // end of console interaction in this cycle from our slave side LCP_slaveCycleEnd(); } /** * End of data reception and then transmission cycle via Link Cable for SEGA slave console * switches console's 2nd port to data reception mode via Link Cable, on all pins except pin 5 * Set bit 5 in LCP_Ctrl to 1, others to 0, which means we no longer transmit data in bits 0-3 * Set bit 5 in LCP_Data to 1 for our slave console, on the other console (master) bit 6 will also become 1 * re-enables processing of all interrupts * * Error codes (error code = LCP_error & 0x0F00): * 0xF00 - error calling LCP_slaveCycleEnd() - end of data reception cycle from slave console */ static void LCP_slaveCycleEnd() { // switch port to data reading mode // Interrupt on SYN line signal disabled, bit 7 = 0. // data line PC5 in output mode (transmission), bit 5 = 1. // data lines PC6, PC4, PC3, PC2, PC1, PC0 in input mode (reception). Corresponding bits = 0 // enable pins 0-3 of 2nd controller port for data reception // pin 5 for signaling events to other console (on other console bit 6 of LCP_Data will equal what we set in our 5th bit) // pin 6 signal from other console about events (other console should change bit 5 of its LCP_Data so that our 6th bit changes) LCP_Ctrl = LCP_BIT5; // set bit 5 in LCP_Data to 1 LCP_Data |= (1 << 5); u16 timeout = LCP_TIME_OUT; do { timeout--; // Subtract 1 from timeout if (timeout == 0) { LCP_timeOut++; // 0xF00 - error calling LCP_slaveCycleEnd() - end of data reception cycle from slave console LCP_error |= 0xF00; // If timeout reached 0, exit loop break; } // wait until bit 6 becomes 1 } while (!(LCP_Data & (1 << 6))); // ready for data exchange via console's 2nd port upon EX-INT interrupt occurrence // first reading data from port, then writing to port in external interrupt handler LCP_slaveCycle() // Interrupt on SYN line signal enabled, bit 7 = 1. // data line PC5 in output mode (transmission), bit 5 = 1. // data lines PC6, PC4, PC3, PC2, PC1, PC0 in input mode (reception). Corresponding bits = 0 // enable pins 0-3 of 2nd controller port for data reception // pin 5 for signal that data is received by our console (on other console this will be bit 6 of LCP_Data) // pin 6 signal that data was sent by other console (other console should change bit 5 of its LCP_Data) LCP_Ctrl = LCP_BIT7_AND_BIT5; // enable processing of all interrupts SYS_enableInts(); } /** * Error in data transmission via SEGA Link Cable * * If 0x0000, no errors occurred! Value ranges in binary format * Lower 4 bits of low byte - data reception errors via Link Cable (0x0001 - 0x000F) 000000000000xxxx * Upper 4 bits of low byte - data transmission errors via Link Cable (0x0010 - 0x00F0) 00000000xxxx0000 * Lower 4 bits of high byte - packet reception or transmission errors (0x0100 - 0x0F00) 0000xxxx00000000 * Upper 4 bits of high byte - object extraction errors from packet (0x1000 - 0xF000) xxxx000000000000 * * return LCP_error */ u16 LCP_getError() { return LCP_error; } #endif // MODULE_LINK_CABLE