| /* |
| * |
| * 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 occurred */ |
| |
| 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 coming 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; |
| } |
