korg/bluez
0
0
Fork 0
mirror of https://git.kernel.org/pub/scm/bluetooth/bluez.git synced 2024-12-02 00:24:25 +08:00
Code Issues Packages Projects Releases Wiki Activity
d9b27da3cc
bluez/tools/ubcsp.c
Marcel Holtmann 1dd19eef3b Remove unused functions
2008-12-23 05:42:44 +01:00

1181 lines
35 KiB
C
Raw Blame History

/*
*
* 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;
}
Reference in New Issue View Git Blame Copy Permalink