| /* | |
| * | |
| * BlueZ - Bluetooth protocol stack for Linux | |
| * | |
| * Copyright (C) 2000-2005 CSR Ltd. | |
| * | |
| * | |
| * Permission is hereby granted, free of charge, to any person obtaining | |
| * a copy of this software and associated documentation files (the | |
| * "Software"), to deal in the Software without restriction, including | |
| * without limitation the rights to use, copy, modify, merge, publish, | |
| * distribute, sublicense, and/or sell copies of the Software, and to | |
| * permit persons to whom the Software is furnished to do so, subject to | |
| * the following conditions: | |
| * | |
| * The above copyright notice and this permission notice shall be included | |
| * in all copies or substantial portions of the Software. | |
| * | |
| * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, | |
| * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF | |
| * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. | |
| * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY | |
| * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, | |
| * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE | |
| * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. | |
| * | |
| */ | |
| #ifdef HAVE_CONFIG_H | |
| #include <config.h> | |
| #endif | |
| /*****************************************************************************/ | |
| /*****************************************************************************/ | |
| /*****************************************************************************/ | |
| /** **/ | |
| /** ubcsp,c **/ | |
| /** **/ | |
| /** MicroBCSP - a very low cost implementation of the BCSP protocol **/ | |
| /** **/ | |
| /*****************************************************************************/ | |
| #include "ubcsp.h" | |
| #if SHOW_PACKET_ERRORS || SHOW_LE_STATES | |
| #include <stdio.h> | |
| #include <windows.h> | |
| #endif | |
| static uint16 ubcsp_calc_crc (uint8 ch, uint16 crc); | |
| static uint16 ubcsp_crc_reverse (uint16); | |
| /*****************************************************************************/ | |
| /** **/ | |
| /** Constant Data - ROM **/ | |
| /** **/ | |
| /*****************************************************************************/ | |
| /* This is the storage for the link establishment messages */ | |
| static const uint8 ubcsp_le_buffer[4][4] = | |
| { | |
| { 0xDA, 0xDC, 0xED, 0xED }, | |
| { 0xAC, 0xAF, 0xEF, 0xEE }, | |
| { 0xAD, 0xEF, 0xAC, 0xED }, | |
| { 0xDE, 0xAD, 0xD0, 0xD0 }, | |
| }; | |
| /* These are the link establishment headers */ | |
| /* The two version are for the CRC and non-CRC varients */ | |
| #if UBCSP_CRC | |
| static const uint8 ubcsp_send_le_header[4] = | |
| { | |
| 0x40, 0x41, 0x00, 0x7E | |
| }; | |
| #else | |
| static const uint8 ubcsp_send_le_header[4] = | |
| { | |
| 0x00, 0x41, 0x00, 0xBE | |
| }; | |
| #endif | |
| /*****************************************************************************/ | |
| /** **/ | |
| /** Static Data - RAM **/ | |
| /** **/ | |
| /*****************************************************************************/ | |
| /* This is the storage for all state data for ubcsp */ | |
| static struct ubcsp_configuration ubcsp_config; | |
| /* This is the ACK packet header - this will be overwritten when | |
| we create an ack packet */ | |
| static uint8 ubcsp_send_ack_header[4] = | |
| { | |
| 0x00, 0x00, 0x00, 0x00 | |
| }; | |
| /* This is the deslip lookup table */ | |
| static const uint8 ubcsp_deslip[2] = | |
| { | |
| SLIP_FRAME, SLIP_ESCAPE, | |
| }; | |
| /* This is a state machine table for link establishment */ | |
| static uint8 next_le_packet[16] = | |
| { | |
| ubcsp_le_sync, // uninit | |
| ubcsp_le_conf, // init | |
| ubcsp_le_none, // active | |
| ubcsp_le_none, | |
| ubcsp_le_sync_resp, // sync_resp | |
| ubcsp_le_sync_resp, | |
| ubcsp_le_none, | |
| ubcsp_le_none, | |
| ubcsp_le_none, // conf_resp | |
| ubcsp_le_conf_resp, | |
| ubcsp_le_conf_resp, | |
| ubcsp_le_none, | |
| }; | |
| /* This is the storage required for building send and crc data */ | |
| static uint8 ubcsp_send_header[4]; | |
| static uint8 ubcsp_send_crc[2]; | |
| /* This is where the receive header is stored before the payload arrives */ | |
| static uint8 ubcsp_receive_header[4]; | |
| /*****************************************************************************/ | |
| /** **/ | |
| /** Code - ROM or RAM **/ | |
| /** **/ | |
| /*****************************************************************************/ | |
| /*****************************************************************************/ | |
| /** **/ | |
| /** ubcsp_initialize **/ | |
| /** **/ | |
| /** This initializes the state of the ubcsp engine to a known values **/ | |
| /** **/ | |
| /*****************************************************************************/ | |
| void ubcsp_initialize (void) | |
| { | |
| ubcsp_config.ack_number = 0; | |
| ubcsp_config.sequence_number = 0; | |
| ubcsp_config.send_ptr = 0; | |
| ubcsp_config.send_size = 0; | |
| ubcsp_config.receive_index = -4; | |
| ubcsp_config.delay = 0; | |
| #if SHOW_LE_STATES | |
| printf ("Hello Link Uninitialized\n"); | |
| #endif | |
| ubcsp_config.link_establishment_state = ubcsp_le_uninitialized; | |
| ubcsp_config.link_establishment_packet = ubcsp_le_sync; | |
| } | |
| /*****************************************************************************/ | |
| /** **/ | |
| /** ubcsp_send_packet **/ | |
| /** **/ | |
| /** This sends a packet structure for sending to the ubcsp engine **/ | |
| /** This can only be called when the activity indication from ubcsp_poll **/ | |
| /** indicates that a packet can be sent with UBCSP_PACKET_SENT **/ | |
| /** **/ | |
| /*****************************************************************************/ | |
| void ubcsp_send_packet (struct ubcsp_packet *send_packet) | |
| { | |
| /* Initialize the send data to the packet we want to send */ | |
| ubcsp_config.send_packet = send_packet; | |
| /* we cannot send the packet at the moment | |
| when we can at the moment, just set things to 0 */ | |
| ubcsp_config.send_size = 0; | |
| ubcsp_config.send_ptr = 0; | |
| } | |
| /*****************************************************************************/ | |
| /** **/ | |
| /** ubcsp_receive_packet **/ | |
| /** **/ | |
| /** This sends a packet structure for receiving to the ubcsp engine **/ | |
| /** This can only be called when the activity indication from ubcsp_poll **/ | |
| /** indicates that a packet can be sent with UBCSP_PACKET_RECEIVED **/ | |
| /** **/ | |
| /*****************************************************************************/ | |
| void ubcsp_receive_packet (struct ubcsp_packet *receive_packet) | |
| { | |
| /* Initialize the receive data to the packet we want to receive */ | |
| ubcsp_config.receive_packet = receive_packet; | |
| /* setup to receive the header first */ | |
| ubcsp_config.receive_index = -4; | |
| } | |
| /*****************************************************************************/ | |
| /** **/ | |
| /** ubcsp_calc_crc **/ | |
| /** **/ | |
| /** Takes the next 8 bit value ch, and updates the crc with this value **/ | |
| /** **/ | |
| /*****************************************************************************/ | |
| #ifdef UBCSP_CRC | |
| static uint16 ubcsp_calc_crc (uint8 ch, uint16 crc) | |
| { | |
| /* Calculate the CRC using the above 16 entry lookup table */ | |
| static const uint16 crc_table[] = | |
| { | |
| 0x0000, 0x1081, 0x2102, 0x3183, | |
| 0x4204, 0x5285, 0x6306, 0x7387, | |
| 0x8408, 0x9489, 0xa50a, 0xb58b, | |
| 0xc60c, 0xd68d, 0xe70e, 0xf78f | |
| }; | |
| /* Do this four bits at a time - more code, less space */ | |
| crc = (crc >> 4) ^ crc_table[(crc ^ ch) & 0x000f]; | |
| crc = (crc >> 4) ^ crc_table[(crc ^ (ch >> 4)) & 0x000f]; | |
| return crc; | |
| } | |
| /*****************************************************************************/ | |
| /** **/ | |
| /** ubcsp_crc_reverse **/ | |
| /** **/ | |
| /** Reserves the bits in crc and returns the new value **/ | |
| /** **/ | |
| /*****************************************************************************/ | |
| static uint16 ubcsp_crc_reverse (uint16 crc) | |
| { | |
| int32 | |
| b, | |
| rev; | |
| /* Reserse the bits to compute the actual CRC value */ | |
| for (b = 0, rev=0; b < 16; b++) | |
| { | |
| rev = rev << 1; | |
| rev |= (crc & 1); | |
| crc = crc >> 1; | |
| } | |
| return rev; | |
| } | |
| #endif | |
| /*****************************************************************************/ | |
| /** **/ | |
| /** ubcsp_put_slip_uart **/ | |
| /** **/ | |
| /** Outputs a single octet to the uart **/ | |
| /** If the octet needs to be escaped, then output the escape value **/ | |
| /** and then store the second octet to be output later **/ | |
| /** **/ | |
| /*****************************************************************************/ | |
| static void ubcsp_put_slip_uart (uint8 ch) | |
| { | |
| /* output a single UART octet */ | |
| /* If it needs to be escaped, then output the escape octet | |
| and set the send_slip_escape so that the next time we | |
| output the second octet for the escape correctly. | |
| This is done right at the top of ubcsp_poll */ | |
| if (ch == SLIP_FRAME) | |
| { | |
| put_uart (SLIP_ESCAPE); | |
| ubcsp_config.send_slip_escape = SLIP_ESCAPE_FRAME; | |
| } | |
| else if (ch == SLIP_ESCAPE) | |
| { | |
| put_uart (SLIP_ESCAPE); | |
| ubcsp_config.send_slip_escape = SLIP_ESCAPE_ESCAPE; | |
| } | |
| else | |
| { | |
| /* Not escaped, so just output octet */ | |
| put_uart (ch); | |
| } | |
| } | |
| /*****************************************************************************/ | |
| /** **/ | |
| /** ubcsp_which_le_payload **/ | |
| /** **/ | |
| /** Check the payload of this packet, and determine which of the four **/ | |
| /** link establishment packets this was. **/ | |
| /** Can return 5 if it is not a valid link establishment packet **/ | |
| /** **/ | |
| /*****************************************************************************/ | |
| static uint32 ubcsp_which_le_payload (const uint8 *payload) | |
| { | |
| static int32 | |
| octet, | |
| loop; | |
| /* Search through the various link establishment payloads to find | |
| which one we have received */ | |
| for (loop = 0; loop < 4; loop ++) | |
| { | |
| for (octet = 0; octet < 4; octet ++) | |
| { | |
| if (payload[octet] != ubcsp_le_buffer[loop][octet]) | |
| { | |
| /* Bad match, just to loop again */ | |
| goto bad_match_loop; | |
| } | |
| } | |
| /* All the octets matched, return the value */ | |
| return loop; | |
| /* Jumps out of octet loop if we got a bad match */ | |
| bad_match_loop: | |
| {} | |
| } | |
| /* Non of the link establishment payloads matched - return invalid value */ | |
| return 5; | |
| } | |
| /*****************************************************************************/ | |
| /** **/ | |
| /** ubcsp_recevied_packet **/ | |
| /** **/ | |
| /** This function is called when we have a SLIP END octet and a full **/ | |
| /** packet header and possibly data in the receive packet **/ | |
| /** **/ | |
| /*****************************************************************************/ | |
| static uint8 ubcsp_recevied_packet (void) | |
| { | |
| static uint8 | |
| receive_crc, | |
| receive_seq, | |
| receive_ack, | |
| activity; | |
| #if UBCSP_CRC | |
| static int32 | |
| loop; | |
| static uint16 | |
| crc; | |
| #endif | |
| static uint16 | |
| length; | |
| /* Keep track of what activity this received packet will cause */ | |
| activity = 0; | |
| /*** Do all error checks that we can ***/ | |
| /* First check the header checksum */ | |
| if (((ubcsp_receive_header[0] + ubcsp_receive_header[1] + ubcsp_receive_header[2] + ubcsp_receive_header[3]) & 0xff) != 0xff) | |
| { | |
| /* Header Checksum Error */ | |
| #if SHOW_PACKET_ERRORS | |
| printf ("\n######################## Header Checksum Error %02X %02X %02X %02X\n", | |
| ubcsp_receive_header[0], | |
| ubcsp_receive_header[1], | |
| ubcsp_receive_header[2], | |
| ubcsp_receive_header[3]); | |
| #endif | |
| /* If we have a header checksum error, send an ack in return | |
| this gets a packet to be resent as quickly as possible */ | |
| ubcsp_config.send_ack = 1; | |
| return activity; | |
| } | |
| /* Decode the received packets header */ | |
| ubcsp_config.receive_packet->reliable = (ubcsp_receive_header[0] & 0x80) >> 7; | |
| receive_crc = (ubcsp_receive_header[0] & 0x40) >> 6; | |
| receive_ack = (ubcsp_receive_header[0] & 0x38) >> 3; | |
| receive_seq = (ubcsp_receive_header[0] & 0x07); | |
| ubcsp_config.receive_packet->channel = (ubcsp_receive_header[1] & 0x0f); | |
| length = | |
| ((ubcsp_receive_header[1] & 0xf0) >> 4) | | |
| (ubcsp_receive_header[2] << 4); | |
| #if SHOW_PACKET_ERRORS | |
| if (ubcsp_config.receive_packet->reliable) | |
| { | |
| printf (" : %10d Recv SEQ: %d ACK %d\n", | |
| GetTickCount () % 100000, | |
| receive_seq, | |
| receive_ack); | |
| } | |
| else if (ubcsp_config.receive_packet->channel != 1) | |
| { | |
| printf (" : %10d Recv ACK %d\n", | |
| GetTickCount () % 100000, | |
| receive_ack); | |
| } | |
| #endif | |
| /* Check for length errors */ | |
| #if UBCSP_CRC | |
| if (receive_crc) | |
| { | |
| /* If this packet had a CRC, then the length of the payload | |
| should be 2 less than the received size of the payload */ | |
| if (length + 2 != ubcsp_config.receive_index) | |
| { | |
| /* Slip Length Error */ | |
| #if SHOW_PACKET_ERRORS | |
| printf ("\n######################## Slip Length Error (With CRC) %d,%d\n", length, ubcsp_config.receive_index - 2); | |
| #endif | |
| /* If we have a payload length error, send an ack in return | |
| this gets a packet to be resent as quickly as possible */ | |
| ubcsp_config.send_ack = 1; | |
| return activity; | |
| } | |
| /* We have a CRC at the end of this packet */ | |
| ubcsp_config.receive_index -= 2; | |
| /* Calculate the packet CRC */ | |
| crc = 0xffff; | |
| /* CRC the packet header */ | |
| for (loop = 0; loop < 4; loop ++) | |
| { | |
| crc = ubcsp_calc_crc (ubcsp_receive_header[loop], crc); | |
| } | |
| /* CRC the packet payload - without the CRC bytes */ | |
| for (loop = 0; loop < ubcsp_config.receive_index; loop ++) | |
| { | |
| crc = ubcsp_calc_crc (ubcsp_config.receive_packet->payload[loop], crc); | |
| } | |
| /* Reverse the CRC */ | |
| crc = ubcsp_crc_reverse (crc); | |
| /* Check the CRC is correct */ | |
| if | |
| ( | |
| (((crc & 0xff00) >> 8) != ubcsp_config.receive_packet->payload[ubcsp_config.receive_index]) || | |
| ((crc & 0xff) != ubcsp_config.receive_packet->payload[ubcsp_config.receive_index + 1]) | |
| ) | |
| { | |
| #if SHOW_PACKET_ERRORS | |
| printf ("\n######################## CRC Error\n"); | |
| #endif | |
| /* If we have a packet crc error, send an ack in return | |
| this gets a packet to be resent as quickly as possible */ | |
| ubcsp_config.send_ack = 1; | |
| return activity; | |
| } | |
| } | |
| else | |
| { | |
| #endif | |
| /* No CRC present, so just check the length of payload with that received */ | |
| if (length != ubcsp_config.receive_index) | |
| { | |
| /* Slip Length Error */ | |
| #if SHOW_PACKET_ERRORS | |
| printf ("\n######################## Slip Length Error (No CRC) %d,%d\n", length, ubcsp_config.receive_index); | |
| #endif | |
| /* If we have a payload length error, send an ack in return | |
| this gets a packet to be resent as quickly as possible */ | |
| ubcsp_config.send_ack = 1; | |
| return activity; | |
| } | |
| #if UBCSP_CRC | |
| } | |
| #endif | |
| /*** We have a fully formed packet having passed all data integrity checks ***/ | |
| /* Check if we have an ACK for the last packet we sent */ | |
| if (receive_ack != ubcsp_config.sequence_number) | |
| { | |
| /* Since we only have a window size of 1, if the ACK is not equal to SEQ | |
| then the packet was sent */ | |
| if | |
| ( | |
| (ubcsp_config.send_packet) && | |
| (ubcsp_config.send_packet->reliable) | |
| ) | |
| { | |
| /* We had sent a reliable packet, so clear this packet | |
| Then increament the sequence number for the next packet */ | |
| ubcsp_config.send_packet = 0; | |
| ubcsp_config.sequence_number ++; | |
| ubcsp_config.delay = 0; | |
| /* Notify the caller that we have SENT a packet */ | |
| activity |= UBCSP_PACKET_SENT; | |
| } | |
| } | |
| /*** Now we can concentrate of the packet we have received ***/ | |
| /* Check for Link Establishment packets */ | |
| if (ubcsp_config.receive_packet->channel == 1) | |
| { | |
| /* Link Establishment */ | |
| ubcsp_config.delay = 0; | |
| /* Find which link establishment packet this payload means | |
| This could return 5, meaning none */ | |
| switch (ubcsp_which_le_payload (ubcsp_config.receive_packet->payload)) | |
| { | |
| case 0: | |
| { | |
| /* SYNC Recv'd */ | |
| #if SHOW_LE_STATES | |
| printf ("Recv SYNC\n"); | |
| #endif | |
| /* If we receive a SYNC, then we respond to it with a SYNC RESP | |
| but only if we are not active. | |
| If we are active, then we have a PEER RESET */ | |
| if (ubcsp_config.link_establishment_state < ubcsp_le_active) | |
| { | |
| ubcsp_config.link_establishment_resp = 1; | |
| } | |
| else | |
| { | |
| /* Peer reset !!!! */ | |
| #if SHOW_LE_STATES | |
| printf ("\n\n\n\n\nPEER RESET\n\n"); | |
| #endif | |
| /* Reinitialize the link */ | |
| ubcsp_initialize (); | |
| /* Tell the host what has happened */ | |
| return UBCSP_PEER_RESET; | |
| } | |
| break; | |
| } | |
| case 1: | |
| { | |
| /* SYNC RESP Recv'd */ | |
| #if SHOW_LE_STATES | |
| printf ("Recv SYNC RESP\n"); | |
| #endif | |
| /* If we receive a SYNC RESP, push us into the initialized state */ | |
| if (ubcsp_config.link_establishment_state < ubcsp_le_initialized) | |
| { | |
| #if SHOW_LE_STATES | |
| printf ("Link Initialized\n"); | |
| #endif | |
| ubcsp_config.link_establishment_state = ubcsp_le_initialized; | |
| } | |
| break; | |
| } | |
| case 2: | |
| { | |
| /* CONF Recv'd */ | |
| #if SHOW_LE_STATES | |
| printf ("Recv CONF\n"); | |
| #endif | |
| /* If we receive a CONF, and we are initialized or active | |
| then respond with a CONF RESP */ | |
| if (ubcsp_config.link_establishment_state >= ubcsp_le_initialized) | |
| { | |
| ubcsp_config.link_establishment_resp = 2; | |
| } | |
| break; | |
| } | |
| case 3: | |
| { | |
| /* CONF RESP Recv'd */ | |
| #if SHOW_LE_STATES | |
| printf ("Recv CONF RESP\n"); | |
| #endif | |
| /* If we received a CONF RESP, then push us into the active state */ | |
| if (ubcsp_config.link_establishment_state < ubcsp_le_active) | |
| { | |
| #if SHOW_LE_STATES | |
| printf ("Link Active\n"); | |
| #endif | |
| ubcsp_config.link_establishment_state = ubcsp_le_active; | |
| ubcsp_config.send_size = 0; | |
| return activity | UBCSP_PACKET_SENT; | |
| } | |
| break; | |
| } | |
| } | |
| /* We have finished processing Link Establishment packets */ | |
| } | |
| else if (ubcsp_config.receive_index) | |
| { | |
| /* We have some payload data we need to process | |
| but only if we are active - otherwise, we just ignore it */ | |
| if (ubcsp_config.link_establishment_state == ubcsp_le_active) | |
| { | |
| if (ubcsp_config.receive_packet->reliable) | |
| { | |
| /* If the packet we've just received was reliable | |
| then send an ACK */ | |
| ubcsp_config.send_ack = 1; | |
| /* We the sequence number we received is the same as | |
| the last ACK we sent, then we have received a packet in sequence */ | |
| if (receive_seq == ubcsp_config.ack_number) | |
| { | |
| /* Increase the ACK number - which will be sent in the next ACK | |
| or normal packet we send */ | |
| ubcsp_config.ack_number ++; | |
| /* Set the values in the receive_packet structure, so the caller | |
| knows how much data we have */ | |
| ubcsp_config.receive_packet->length = length; | |
| ubcsp_config.receive_packet = 0; | |
| /* Tell the caller that we have received a packet, and that it | |
| will be ACK'ed */ | |
| activity |= UBCSP_PACKET_RECEIVED | UBCSP_PACKET_ACK; | |
| } | |
| } | |
| else | |
| { | |
| /* Set the values in the receive_packet structure, so the caller | |
| knows how much data we have */ | |
| ubcsp_config.receive_packet->length = length; | |
| ubcsp_config.receive_packet = 0; | |
| /* Tell the caller that we have received a packet */ | |
| activity |= UBCSP_PACKET_RECEIVED; | |
| } | |
| } | |
| } | |
| /* Just return any activity that occured */ | |
| return activity; | |
| } | |
| /*****************************************************************************/ | |
| /** **/ | |
| /** ubcsp_setup_packet **/ | |
| /** **/ | |
| /** This function is called to setup a packet to be sent **/ | |
| /** This allows just a header, or a header and payload to be sent **/ | |
| /** It also allows the header checksum to be precalcuated **/ | |
| /** or calculated here **/ | |
| /** part1 is always 4 bytes **/ | |
| /** **/ | |
| /*****************************************************************************/ | |
| static void ubcsp_setup_packet (uint8 *part1, uint8 calc, uint8 *part2, uint16 len2) | |
| { | |
| /* If we need to calculate the checksum, do that now */ | |
| if (calc) | |
| { | |
| part1[3] = | |
| ~(part1[0] + part1[1] + part1[2]); | |
| } | |
| /* Setup the header send pointer and size so we can clock this out */ | |
| ubcsp_config.send_ptr = part1; | |
| ubcsp_config.send_size = 4; | |
| /* Setup the payload send pointer and size */ | |
| ubcsp_config.next_send_ptr = part2; | |
| ubcsp_config.next_send_size = len2; | |
| #if UBCSP_CRC | |
| /* Initialize the crc as required */ | |
| ubcsp_config.send_crc = -1; | |
| ubcsp_config.need_send_crc = 1; | |
| #endif | |
| } | |
| /*****************************************************************************/ | |
| /** **/ | |
| /** ubcsp_sent_packet **/ | |
| /** **/ | |
| /** Called when we have finished sending a packet **/ | |
| /** If this packet was unreliable, then notify caller, and clear the data **/ | |
| /** **/ | |
| /*****************************************************************************/ | |
| static uint8 ubcsp_sent_packet (void) | |
| { | |
| if (ubcsp_config.send_packet) | |
| { | |
| if (!ubcsp_config.send_packet->reliable) | |
| { | |
| /* We had a packet sent that was unreliable */ | |
| /* Forget about this packet */ | |
| ubcsp_config.send_packet = 0; | |
| /* Notify caller that they can send another one */ | |
| return UBCSP_PACKET_SENT; | |
| } | |
| } | |
| /* We didn't have a packet, or it was reliable | |
| Must wait for ACK before allowing another packet to be sent */ | |
| return 0; | |
| } | |
| /*****************************************************************************/ | |
| /** **/ | |
| /** ubcsp_poll **/ | |
| /** **/ | |
| /** This is the main function for ubcsp **/ | |
| /** It performs a number of tasks **/ | |
| /** **/ | |
| /** 1) Send another octet to the UART - escaping as required **/ | |
| /** 2) Setup the payload to be sent after the header has been sent **/ | |
| /** 3) Send the CRC for the packet if required **/ | |
| /** **/ | |
| /** 4) Calculate the next Link Establishment State **/ | |
| /** 5) Send a Link Establishment packet **/ | |
| /** 6) Send a normal packet if available **/ | |
| /** 7) Send an ACK packet if required **/ | |
| /** **/ | |
| /** 8) Receive octets from UART and deslip them as required **/ | |
| /** 9) Place received octets into receive header or receive payload buffer **/ | |
| /** 10) Process received packet when SLIP_END is received **/ | |
| /** **/ | |
| /** 11) Keep track of ability of caller to delay recalling **/ | |
| /** **/ | |
| /*****************************************************************************/ | |
| uint8 ubcsp_poll (uint8 *activity) | |
| { | |
| uint8 | |
| delay = UBCSP_POLL_TIME_IMMEDIATE; | |
| uint8 | |
| value; | |
| /* Assume no activity to start with */ | |
| *activity = 0; | |
| /* If we don't have to delay, then send something if we can */ | |
| if (!ubcsp_config.delay) | |
| { | |
| /* Do we have something we are sending to send */ | |
| if (ubcsp_config.send_size) | |
| { | |
| /* We have something to send so send it */ | |
| if (ubcsp_config.send_slip_escape) | |
| { | |
| /* Last time we send a SLIP_ESCAPE octet | |
| this time send the second escape code */ | |
| put_uart (ubcsp_config.send_slip_escape); | |
| ubcsp_config.send_slip_escape = 0; | |
| } | |
| else | |
| { | |
| #if UBCSP_CRC | |
| /* get the value to send, and calculate CRC as we go */ | |
| value = *ubcsp_config.send_ptr ++; | |
| ubcsp_config.send_crc = ubcsp_calc_crc (value, ubcsp_config.send_crc); | |
| /* Output the octet */ | |
| ubcsp_put_slip_uart (value); | |
| #else | |
| /* Just output the octet*/ | |
| ubcsp_put_slip_uart (*ubcsp_config.send_ptr ++); | |
| #endif | |
| } | |
| /* If we did output a SLIP_ESCAPE, then don't process the end of a block */ | |
| if ((!ubcsp_config.send_slip_escape) && ((ubcsp_config.send_size = ubcsp_config.send_size - 1) == 0)) | |
| { | |
| /*** We are at the end of a block - either header or payload ***/ | |
| /* setup the next block */ | |
| ubcsp_config.send_ptr = ubcsp_config.next_send_ptr; | |
| ubcsp_config.send_size = ubcsp_config.next_send_size; | |
| ubcsp_config.next_send_ptr = 0; | |
| ubcsp_config.next_send_size = 0; | |
| #if UBCSP_CRC | |
| /* If we have no successor block | |
| then we might need to send the CRC */ | |
| if (!ubcsp_config.send_ptr) | |
| { | |
| if (ubcsp_config.need_send_crc) | |
| { | |
| /* reverse the CRC from what we computed along the way */ | |
| ubcsp_config.need_send_crc = 0; | |
| ubcsp_config.send_crc = ubcsp_crc_reverse (ubcsp_config.send_crc); | |
| /* Save in the send_crc buffer */ | |
| ubcsp_send_crc[0] = (uint8) (ubcsp_config.send_crc >> 8); | |
| ubcsp_send_crc[1] = (uint8) ubcsp_config.send_crc; | |
| /* Setup to send this buffer */ | |
| ubcsp_config.send_ptr = ubcsp_send_crc; | |
| ubcsp_config.send_size = 2; | |
| } | |
| else | |
| { | |
| /* We don't need to send the crc | |
| either we just have, or this packet doesn't include it */ | |
| /* Output the end of FRAME marker */ | |
| put_uart (SLIP_FRAME); | |
| /* Check if this is an unreliable packet */ | |
| *activity |= ubcsp_sent_packet (); | |
| /* We've sent the packet, so don't need to have be called quickly soon */ | |
| delay = UBCSP_POLL_TIME_DELAY; | |
| } | |
| } | |
| #else | |
| /* If we have no successor block | |
| then we might need to send the CRC */ | |
| if (!ubcsp_config.send_ptr) | |
| { | |
| /* Output the end of FRAME marker */ | |
| put_uart (SLIP_FRAME); | |
| /* Check if this is an unreliable packet */ | |
| *activity |= ubcsp_sent_packet (); | |
| /* We've sent the packet, so don't need to have be called quickly soon */ | |
| delay = UBCSP_POLL_TIME_DELAY; | |
| } | |
| #endif | |
| } | |
| } | |
| else if (ubcsp_config.link_establishment_packet == ubcsp_le_none) | |
| { | |
| /* We didn't have something to send | |
| AND we have no Link Establishment packet to send */ | |
| if (ubcsp_config.link_establishment_resp & 2) | |
| { | |
| /* Send the start of FRAME packet */ | |
| put_uart (SLIP_FRAME); | |
| /* We did require a RESP packet - so setup the send */ | |
| ubcsp_setup_packet ((uint8*) ubcsp_send_le_header, 0, (uint8*) ubcsp_le_buffer[ubcsp_le_conf_resp], 4); | |
| /* We have now "sent" this packet */ | |
| ubcsp_config.link_establishment_resp = 0; | |
| } | |
| else if (ubcsp_config.send_packet) | |
| { | |
| /* There is a packet ready to be sent */ | |
| /* Send the start of FRAME packet */ | |
| put_uart (SLIP_FRAME); | |
| /* Encode up the packet header using ACK and SEQ numbers */ | |
| ubcsp_send_header[0] = | |
| (ubcsp_config.send_packet->reliable << 7) | | |
| #if UBCSP_CRC | |
| 0x40 | /* Always use CRC's */ | |
| #endif | |
| (ubcsp_config.ack_number << 3) | | |
| (ubcsp_config.sequence_number); | |
| /* Encode up the packet header's channel and length */ | |
| ubcsp_send_header[1] = | |
| (ubcsp_config.send_packet->channel & 0x0f) | | |
| ((ubcsp_config.send_packet->length << 4) & 0xf0); | |
| ubcsp_send_header[2] = | |
| (ubcsp_config.send_packet->length >> 4) & 0xff; | |
| /* Let the ubcsp_setup_packet function calculate the header checksum */ | |
| ubcsp_setup_packet ((uint8*) ubcsp_send_header, 1, ubcsp_config.send_packet->payload, ubcsp_config.send_packet->length); | |
| /* Don't need to send an ACK - we just place on in this packet */ | |
| ubcsp_config.send_ack = 0; | |
| #if SHOW_PACKET_ERRORS | |
| printf (" : %10d Send %d Ack %d\n", | |
| GetTickCount () % 100000, | |
| ubcsp_config.sequence_number, | |
| ubcsp_config.ack_number); | |
| #endif | |
| } | |
| else if (ubcsp_config.send_ack) | |
| { | |
| /* Send the start of FRAME packet */ | |
| put_uart (SLIP_FRAME); | |
| #if SHOW_PACKET_ERRORS | |
| printf (" : %10d Send ACK %d\n", | |
| GetTickCount () % 100000, | |
| ubcsp_config.ack_number); | |
| #endif | |
| /* The ack packet is already computed apart from the first octet */ | |
| ubcsp_send_ack_header[0] = | |
| #if UBCSP_CRC | |
| 0x40 | | |
| #endif | |
| (ubcsp_config.ack_number << 3); | |
| /* Let the ubcsp_setup_packet function calculate the header checksum */ | |
| ubcsp_setup_packet (ubcsp_send_ack_header, 1, 0, 0); | |
| /* We've now sent the ack */ | |
| ubcsp_config.send_ack = 0; | |
| } | |
| else | |
| { | |
| /* We didn't have a Link Establishment response packet, | |
| a normal packet or an ACK packet to send */ | |
| delay = UBCSP_POLL_TIME_DELAY; | |
| } | |
| } | |
| else | |
| { | |
| #if SHOW_PACKET_ERRORS | |
| // printf (" : %10d Send LE %d\n", | |
| // GetTickCount () % 100000, | |
| // ubcsp_config.link_establishment_packet); | |
| #endif | |
| /* Send A Link Establishment Message */ | |
| put_uart (SLIP_FRAME); | |
| /* Send the Link Establishment header followed by the | |
| Link Establishment packet */ | |
| ubcsp_setup_packet ((uint8*) ubcsp_send_le_header, 0, (uint8*) ubcsp_le_buffer[ubcsp_config.link_establishment_packet], 4); | |
| /* start sending immediately */ | |
| ubcsp_config.delay = 0; | |
| /* workout what the next link establishment packet should be */ | |
| ubcsp_config.link_establishment_packet = next_le_packet[ubcsp_config.link_establishment_state + ubcsp_config.link_establishment_resp * 4]; | |
| /* We have now delt with any response packet that we needed */ | |
| ubcsp_config.link_establishment_resp = 0; | |
| return 0; | |
| } | |
| } | |
| /* We now need to receive any octets from the UART */ | |
| while ((ubcsp_config.receive_packet) && (get_uart (&value))) | |
| { | |
| /* If the last octet was SLIP_ESCAPE, then special processing is required */ | |
| if (ubcsp_config.receive_slip_escape) | |
| { | |
| /* WARNING - out of range values are not detected !!! | |
| This will probably be caught with the checksum or CRC check */ | |
| value = ubcsp_deslip[value - SLIP_ESCAPE_FRAME]; | |
| ubcsp_config.receive_slip_escape = 0; | |
| } | |
| else | |
| { | |
| /* Check for the SLIP_FRAME octet - must be start or end of packet */ | |
| if (value == SLIP_FRAME) | |
| { | |
| /* If we had a full header then we have a packet */ | |
| if (ubcsp_config.receive_index >= 0) | |
| { | |
| /* process the received packet */ | |
| *activity |= ubcsp_recevied_packet (); | |
| if (*activity & UBCSP_PACKET_ACK) | |
| { | |
| /* We need to ACK this packet, then don't delay its sending */ | |
| ubcsp_config.delay = 0; | |
| } | |
| } | |
| /* Setup to receive the next packet */ | |
| ubcsp_config.receive_index = -4; | |
| /* Ok, next octet */ | |
| goto finished_receive; | |
| } | |
| else if (value == SLIP_ESCAPE) | |
| { | |
| /* If we receive a SLIP_ESCAPE, | |
| then remember to process the next special octet */ | |
| ubcsp_config.receive_slip_escape = 1; | |
| goto finished_receive; | |
| } | |
| } | |
| if (ubcsp_config.receive_index < 0) | |
| { | |
| /* We are still receiving the header */ | |
| ubcsp_receive_header[ubcsp_config.receive_index + 4] = value; | |
| ubcsp_config.receive_index ++; | |
| } | |
| else if (ubcsp_config.receive_index < ubcsp_config.receive_packet->length) | |
| { | |
| /* We are receiving the payload */ | |
| /* We might stop comming here if we are receiving a | |
| packet which is longer than the receive_packet->length | |
| given by the host */ | |
| ubcsp_config.receive_packet->payload[ubcsp_config.receive_index] = value; | |
| ubcsp_config.receive_index ++; | |
| } | |
| finished_receive: | |
| { | |
| } | |
| } | |
| if (ubcsp_config.delay > 0) | |
| { | |
| /* We were delayed so delay some more | |
| this could be cancelled if we received something */ | |
| ubcsp_config.delay --; | |
| } | |
| else | |
| { | |
| /* We had no delay, so use the delay we just decided to us */ | |
| ubcsp_config.delay = delay; | |
| } | |
| /* Report the current delay to the user */ | |
| return ubcsp_config.delay; | |
| } |