mangavalk/lcdproc
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

overhauled CFontz633io.c: doxygen'ated it, added more check for cyclical fifos, ...

Browse Source
This commit is contained in:
marschap
2005-05-26 15:00:49 +00:00
parent 0fb7404fbb
commit 8296d0b716
1 changed files with 318 additions and 335 deletions
Download Patch File Download Diff File Expand all files Collapse all files
server/drivers/CFontz633io.c
+124 -141
View File
@@ -26,15 +26,16 @@
COMMAND_PACKET incoming_command; COMMAND_PACKET incoming_command;
/* variables for circular receive buffer */
#define RECEIVEBUFFERSIZE 512 #define RECEIVEBUFFERSIZE 512
unsigned char SerialReceiveBuffer[RECEIVEBUFFERSIZE]; unsigned char SerialReceiveBuffer[RECEIVEBUFFERSIZE];
int ReceiveBufferHead; int ReceiveBufferHead = 0;
int ReceiveBufferTail; int ReceiveBufferTail = 0;
int ReceiveBufferTailPeek; int ReceiveBufferTailPeek = 0;
/* /*
* KeyRing handeling function. * KeyRing handling function.
* This separate the producer from the consumer. * This separate the producer from the consumer.
* It is just a small fifo of unsigned char. * It is just a small fifo of unsigned char.
*/ */
@@ -44,13 +45,15 @@ unsigned char KeyRing[KEYRINGSIZE];
int KeyHead = 0; int KeyHead = 0;
int KeyTail = 0; int KeyTail = 0;
/*-OK-----------------------------------------------------------------------*/
/** initialize/empty key ring by resetting its read & write pointers */
void EmptyKeyRing(void) void EmptyKeyRing(void)
{ {
KeyHead = KeyTail = 0; KeyHead = KeyTail = 0;
} }
/*-OK-----------------------------------------------------------------------*/
/** add byte to key ring; return success (byte added) / failure (key ring is full) */
int AddKeyToKeyRing(unsigned char key) int AddKeyToKeyRing(unsigned char key)
{ {
if (((KeyHead + 1) % KEYRINGSIZE) != (KeyTail % KEYRINGSIZE)) { if (((KeyHead + 1) % KEYRINGSIZE) != (KeyTail % KEYRINGSIZE)) {
@@ -64,13 +67,16 @@ int AddKeyToKeyRing(unsigned char key)
return 0; return 0;
} }
/*-OK-----------------------------------------------------------------------*/
/** get byte from key ring (or '\0' if key ring is empty) */
unsigned char GetKeyFromKeyRing(void) unsigned char GetKeyFromKeyRing(void)
{ {
int retval = 0; unsigned char retval = '\0';
if ((KeyHead % KEYRINGSIZE) != (KeyTail % KEYRINGSIZE )) { KeyTail %= KEYRINGSIZE;
retval = KeyRing[KeyTail % KEYRINGSIZE];
if ((KeyHead % KEYRINGSIZE) != KeyTail) {
retval = KeyRing[KeyTail];
KeyTail = (KeyTail + 1) % KEYRINGSIZE; KeyTail = (KeyTail + 1) % KEYRINGSIZE;
} }
@@ -81,46 +87,49 @@ unsigned char GetKeyFromKeyRing(void)
/* /** send message with arguments to the given handle */
* ----------------------------------------------------------------------------
* send_packet() send_packet() will send set the CRC in outgoing_response
* and send it to the host.
* ----------------------------------------------------------------------------
*/
void send_bytes_message(int fd, int len, int msg, char *framebuf) void send_bytes_message(int fd, int len, int msg, char *framebuf)
{ {
int i; int i;
outgoing_response.command = msg; outgoing_response.command = msg;
outgoing_response.data_length = len; outgoing_response.data_length = len;
for (i = 0; i < outgoing_response.data_length; i++) { for (i = 0; i < outgoing_response.data_length; i++)
outgoing_response.data[i] = framebuf[i]; outgoing_response.data[i] = framebuf[i];
}
/* send message & calc CRC */
send_packet(fd); send_packet(fd);
} }
/** send message with one byte argument to the given handle */
void send_onebyte_message(int fd, int msg, int value) void send_onebyte_message(int fd, int msg, int value)
{ {
outgoing_response.command = msg; outgoing_response.command = msg;
outgoing_response.data_length = 1; outgoing_response.data_length = 1;
outgoing_response.data[0] = value; outgoing_response.data[0] = value;
/* send message & calc CRC */
send_packet(fd); send_packet(fd);
} }
/** send message without data to the given handle */
void send_zerobyte_message(int fd, int msg) void send_zerobyte_message(int fd, int msg)
{ {
outgoing_response.command = msg; outgoing_response.command = msg;
outgoing_response.data_length = 0; outgoing_response.data_length = 0;
/* send message & calc CRC */
send_packet(fd); send_packet(fd);
} }
/*----------------------------------------------------------------------------*/ /** calculate CRC over given buffer with given length */
int get_crc(char *bufptr, int len, int seed) int get_crc(char *buf, int len, int seed)
{ {
/* /* CRC lookup table to avoid bit-shifting loops. */
* CRC lookup table to avoid bit-shifting loops.
*/
static const word crcLookupTable[256] = { static const word crcLookupTable[256] = {
0x00000, 0x01189, 0x02312, 0x0329B, 0x04624, 0x057AD, 0x06536, 0x074BF, 0x00000, 0x01189, 0x02312, 0x0329B, 0x04624, 0x057AD, 0x06536, 0x074BF,
0x08C48, 0x09DC1, 0x0AF5A, 0x0BED3, 0x0CA6C, 0x0DBE5, 0x0E97E, 0x0F8F7, 0x08C48, 0x09DC1, 0x0AF5A, 0x0BED3, 0x0CA6C, 0x0DBE5, 0x0E97E, 0x0F8F7,
@@ -156,54 +165,31 @@ int get_crc(char *bufptr, int len, int seed)
0x07BC7, 0x06A4E, 0x058D5, 0x0495C, 0x03DE3, 0x02C6A, 0x01EF1, 0x00F78 0x07BC7, 0x06A4E, 0x058D5, 0x0495C, 0x03DE3, 0x02C6A, 0x01EF1, 0x00F78
}; };
/* /* initialize the new crc with the given seed */
* Initial value of the CRC. int newCrc = seed;
*/
int newCrc;
/* /* This algorithm is based on the IrDA LAP example */
* seed should be 0xFFFF; while (len-- > 0)
*/ newCrc = (newCrc >> 8) ^ crcLookupTable[(newCrc ^ *buf++) & 0xff];
newCrc = seed;
/* /* Make this crc match the one's complement that is sent in the packet */
* This algorithim is based on the IrDA LAP example.
*/
while (len--)
newCrc =
(newCrc >> 8) ^ crcLookupTable[(newCrc ^ *bufptr++) & 0xff];
/*
* Make this crc match the one's complement that is sent in the packet.
*/
return (~newCrc); return (~newCrc);
} }
/** send one byte to the given handle */
void void
SendByte(int fd, unsigned char datum) SendByte(int fd, unsigned char datum)
{ {
int bytes_written; write(fd, &datum, 1);
bytes_written = 0;
bytes_written = write(fd, &datum, 1);
/* if (bytes_written != 1) {
printf("SendByte(): only %d of %d bytes sent.", bytes_written, 1);
} */
return;
} }
/*---------------------------------------------------------------------------*/
COMMAND_PACKET outgoing_response; COMMAND_PACKET outgoing_response;
/*
* ============================================================================
* send_packet() send_packet() will send set the CRC in outgoing_response
* and send it to the host.
* ----------------------------------------------------------------------------
*/
/** send outgoing_response to the given handle; calc & send CRC when doing so */
void void
send_packet(int fd) send_packet(int fd)
{ {
@@ -214,11 +200,9 @@ send_packet(int fd)
for (i = 0; i < outgoing_response.data_length; i++) { for (i = 0; i < outgoing_response.data_length; i++) {
SendByte(fd, outgoing_response.data[i]); SendByte(fd, outgoing_response.data[i]);
} }
/*
* Set the CRC /* calculate & send the CRC */
*/ outgoing_response.CRC.as_word = get_crc((unsigned char *) &outgoing_response,
outgoing_response.CRC.as_word =
get_crc((unsigned char *) & outgoing_response,
outgoing_response.data_length + 2, 0xFFFF); outgoing_response.data_length + 2, 0xFFFF);
SendByte(fd, outgoing_response.CRC.as_bytes[0]); SendByte(fd, outgoing_response.CRC.as_bytes[0]);
SendByte(fd, outgoing_response.CRC.as_bytes[1]); SendByte(fd, outgoing_response.CRC.as_bytes[1]);
@@ -226,7 +210,7 @@ send_packet(int fd)
/**** TEST STUF ****/ /**** TEST STUF ****/
// print_packet(&outgoing_response); // print_packet(&outgoing_response);
/* Every time we send a message, we also check for incomming one. */ /* Every time we send a message, we also check for an incoming one. */
test_packet(fd); test_packet(fd);
} }
@@ -254,146 +238,143 @@ send_packet(int fd)
/* -------------------------------------------------- */ /* -------------------------------------------------- */
/* ^ Tail ^ Head */ /* ^ Tail ^ Head */
/*-OK-----------------------------------------------------------------------*/
/** initialize/empty receive buffer by resetting its pointers */
void EmptyReceiveBuffer(void) void EmptyReceiveBuffer(void)
{ {
ReceiveBufferHead=ReceiveBufferTail=0; ReceiveBufferHead = ReceiveBufferTail = ReceiveBufferTailPeek = 0;
} }
/*-OK------------------------------------------------------------------------
* Gets incoming data from Window's ReadFile() and puts it into /** read given number of bytes from given file handle into receive buffer */
* SerialReceiveBuffer[].
*/
void Sync_Read_Buffer(int fd, unsigned char expected_bytes) void Sync_Read_Buffer(int fd, unsigned char expected_bytes)
{ {
unsigned char Incoming[512]; unsigned char Incoming[512];
int BytesRead; int BytesRead;
int i;
// ToDo: check that expected_bytes < sizeof(Incoming)
BytesRead = read(fd, Incoming, expected_bytes); BytesRead = read(fd, Incoming, expected_bytes);
if (BytesRead == -1){ if (BytesRead == -1){
/* printf("~~~Problem reading: %s .\n", strerror(errno)); */ /* printf("~~~Problem reading: %s .\n", strerror(errno)); */
} }
else else {
{ int i;
/* printf("Readed %d Bytes:", BytesRead); */
/* Read the incoming unsigned char, store it, */ /* printf("Read %d Bytes:", BytesRead); */
for(i=0; i<BytesRead; i++)
{ /* wrap write pointer to the receive buffer */
ReceiveBufferHead %= RECEIVEBUFFERSIZE;
/* Read the incoming byte and store it, */
for (i = 0; i < BytesRead; i++) {
/* printf(" %02x", Incoming[i]); */ /* printf(" %02x", Incoming[i]); */
SerialReceiveBuffer[ReceiveBufferHead] = Incoming[i]; SerialReceiveBuffer[ReceiveBufferHead] = Incoming[i];
/* Increment the pointer and wrap if needed. */
ReceiveBufferHead++; /* increment write pointer (wrap if needed) */
if(RECEIVEBUFFERSIZE<=ReceiveBufferHead) ReceiveBufferHead = (ReceiveBufferHead + 1) % RECEIVEBUFFERSIZE;
ReceiveBufferHead=0;
} }
/* printf("\n"); */ /* printf("\n"); */
} }
} }
/** return number of bytes available for reading in receive buffer */
/*-OK-----------------------------------------------------------------------*/
int BytesAvail(void) int BytesAvail(void)
{ {
int return_value; int avail_bytes = ReceiveBufferHead - ReceiveBufferTail;
return_value=ReceiveBufferHead-ReceiveBufferTail; if (avail_bytes < 0)
if(return_value<0) avail_bytes += RECEIVEBUFFERSIZE;
return_value+=RECEIVEBUFFERSIZE;
return(return_value); return(avail_bytes % RECEIVEBUFFERSIZE);
} }
/*-OK-----------------------------------------------------------------------*/
/** get next byte from receive buffer (return '\0' if buffer is empty) */
unsigned char GetByte(void) unsigned char GetByte(void)
{ {
unsigned char return_byte; unsigned char return_byte = '\0';
return_byte=0; /* wrap read pointer to the receive buffer */
ReceiveBufferTail %= RECEIVEBUFFERSIZE;
/* See if there are any more bytes available. */ /* See if there are any more bytes available. */
if(ReceiveBufferTail!=ReceiveBufferHead) if (ReceiveBufferTail != (ReceiveBufferHead % RECEIVEBUFFERSIZE)) {
{ /* There is at least one more byte. */
/* There is at least one more ubyte. */
return_byte = SerialReceiveBuffer[ReceiveBufferTail]; return_byte = SerialReceiveBuffer[ReceiveBufferTail];
/* Increment the pointer and wrap if needed. */ /* Increment read pointer (wrap if needed) */
ReceiveBufferTail++; ReceiveBufferTail = (ReceiveBufferTail + 1) % RECEIVEBUFFERSIZE;
if(RECEIVEBUFFERSIZE<=ReceiveBufferTail)
ReceiveBufferTail=0;
} }
return(return_byte); return(return_byte);
} }
/*-OK-----------------------------------------------------------------------*/
/** get byte from receive buffer (or '\0' if buffer is empty) */
unsigned char DiscardGetByte(void) unsigned char DiscardGetByte(void)
{ {
unsigned char return_byte; unsigned char return_byte = '\0';
return_byte=0;
/* wrap read pointer to the receive buffer */
ReceiveBufferTail %= RECEIVEBUFFERSIZE;
/* See if there are any more bytes available. */ /* See if there are any more bytes available. */
if(ReceiveBufferTail!=ReceiveBufferHead) if (ReceiveBufferTail != (ReceiveBufferHead % RECEIVEBUFFERSIZE)) {
{
/* There is at least one more ubyte. */ /* There is at least one more ubyte. */
return_byte = SerialReceiveBuffer[ReceiveBufferTail]; return_byte = SerialReceiveBuffer[ReceiveBufferTail];
/* Increment the pointer and wrap if needed. */ /* Increment read pointer (wrap if needed) */
ReceiveBufferTail++; ReceiveBufferTail = (ReceiveBufferTail + 1) % RECEIVEBUFFERSIZE;
if(RECEIVEBUFFERSIZE<=ReceiveBufferTail)
ReceiveBufferTail=0;
} }
/* printf("Discarded : /%02x/\n", return_byte); */ /* printf("Discarded : /%02x/\n", return_byte); */
return(return_byte); return(return_byte);
} }
/*-OK--------------------------------------------------------------------------*/ /** return number of bytes available for peeking in receive buffer */
int PeekBytesAvail(void) int PeekBytesAvail(void)
{ {
int return_value; int avail_bytes = ReceiveBufferHead - ReceiveBufferTailPeek;
return_value=ReceiveBufferHead-ReceiveBufferTailPeek; if (avail_bytes < 0)
avail_bytes += RECEIVEBUFFERSIZE;
if(return_value<0) return(avail_bytes % RECEIVEBUFFERSIZE);
return_value+=RECEIVEBUFFERSIZE;
return(return_value);
} }
/*-OK--------------------------------------------------------------------------*/
/** sync peek pointer with read pointer */
void Sync_Peek_Pointer(void) void Sync_Peek_Pointer(void)
{ {
ReceiveBufferTailPeek = ReceiveBufferTail; ReceiveBufferTailPeek = ReceiveBufferTail;
} }
/*-OK--------------------------------------------------------------------------*/
/** accept ppeked data by syncing the read pointer to the peek pointer */
void AcceptPeekedData(void) void AcceptPeekedData(void)
{ {
ReceiveBufferTail = ReceiveBufferTailPeek; ReceiveBufferTail = ReceiveBufferTailPeek;
} }
/*-OK--------------------------------------------------------------------------*/
/** peek next byte from receive buffer (return '\0' if buffer is empty) */
unsigned char PeekByte(void) unsigned char PeekByte(void)
{ {
unsigned char return_byte; unsigned char return_byte = '\0';
return_byte=0; /* wrap peek pointer to the receive buffer */
ReceiveBufferTailPeek %= RECEIVEBUFFERSIZE;
/* See if there are any more bytes available. */ /* See if there are any more bytes available. */
if(ReceiveBufferTailPeek!=ReceiveBufferHead) if (ReceiveBufferTailPeek != (ReceiveBufferHead % RECEIVEBUFFERSIZE)) {
{
/* There is at least one more byte. */ /* There is at least one more byte. */
return_byte = SerialReceiveBuffer[ReceiveBufferTailPeek]; return_byte = SerialReceiveBuffer[ReceiveBufferTailPeek];
/* Increment the pointer and wrap if needed. */ /* Increment the peek pointer (wrap if needed). */
ReceiveBufferTailPeek++; ReceiveBufferTailPeek = (ReceiveBufferTailPeek + 1) % RECEIVEBUFFERSIZE;
if(RECEIVEBUFFERSIZE<=ReceiveBufferTailPeek)
ReceiveBufferTailPeek=0;
} }
return(return_byte); return(return_byte);
@@ -450,19 +431,23 @@ unsigned char check_for_packet(int fd, unsigned char expected_length)
/* Look into the buffer without removing the data. */ /* Look into the buffer without removing the data. */
Sync_Peek_Pointer(); Sync_Peek_Pointer();
//Only commands 0 through MAX_COMMAND are valid. /* look at potential command byte */
if(MAX_COMMAND<(0x3F&(incoming_command.command=PeekByte()))) incoming_command.command = PeekByte();
{
/* Only commands 0 through MAX_COMMAND are valid */
if (MAX_COMMAND < (0x3F & incoming_command.command)) {
/* Throw out one byte of garbage. Next pass through should re-sync. */ /* Throw out one byte of garbage. Next pass through should re-sync. */
DiscardGetByte(); DiscardGetByte();
tossed++; tossed++;
/* printf("###: Unknown command.\n"); */ /* printf("###: Unknown command.\n"); */
return(TRY_AGAIN); return(TRY_AGAIN);
} }
/* There is a valid command byte. Get the data_length. */ /* There is a valid command byte. Get the data_length. */
incoming_command.data_length = PeekByte();
/* The data length must be within reason. */ /* The data length must be within reason. */
if(MAX_DATA_LENGTH<(incoming_command.data_length=PeekByte())) if (MAX_DATA_LENGTH < incoming_command.data_length) {
{
//Throw out one byte of garbage. Next pass through should re-sync. //Throw out one byte of garbage. Next pass through should re-sync.
DiscardGetByte(); DiscardGetByte();
tossed++; tossed++;
@@ -493,8 +478,7 @@ unsigned char check_for_packet(int fd, unsigned char expected_length)
incoming_command.data_length+2, 0xFFFF); incoming_command.data_length+2, 0xFFFF);
testcrc = testcrc & 0xFFFF; /* This is TRICKY */ testcrc = testcrc & 0xFFFF; /* This is TRICKY */
if(incoming_command.CRC.as_word==testcrc) if (incoming_command.CRC.as_word == testcrc) {
{
//This is a good packet. I'll be horn swaggled. Remove the packet //This is a good packet. I'll be horn swaggled. Remove the packet
//from the serial buffer. //from the serial buffer.
AcceptPeekedData(); AcceptPeekedData();
@@ -513,10 +497,11 @@ unsigned char check_for_packet(int fd, unsigned char expected_length)
testcrc, incoming_command.CRC.as_word); */ testcrc, incoming_command.CRC.as_word); */
return(TRY_AGAIN); return(TRY_AGAIN);
} }
//============================================================================
/* I should use the value GIVE_UP and not reenter if there is no extra /* I should use the value GIVE_UP and not reenter if there is no extra
* byte readed from the serial port * byte read from the serial port
*/ */
int test_packet(int fd) int test_packet(int fd)
{ {
@@ -524,22 +509,21 @@ int is_msg;
is_msg = check_for_packet(fd, MAX_DATA_LENGTH); is_msg = check_for_packet(fd, MAX_DATA_LENGTH);
while (is_msg != GIVE_UP) { while (is_msg != GIVE_UP) {
if (is_msg==GOOD_MSG) { if (is_msg == GOOD_MSG)
treat_packet(); treat_packet();
}
is_msg = check_for_packet(fd, MAX_DATA_LENGTH); is_msg = check_for_packet(fd, MAX_DATA_LENGTH);
} }
return 1; return 1;
} }
//============================================================================
/* /*
* This is a debuging function. * This is a debugging function.
* It should be removed or compiled in conditionaly. * It should be removed or compiled in conditionally.
* Currently it is still using printf for debuging. * Currently it is still using printf for debugging.
*/ */
void print_packet(COMMAND_PACKET *packet) void print_packet(COMMAND_PACKET *packet)
{ {
int i, cmd, top, len; int i, cmd, top, len;
@@ -556,5 +540,4 @@ void print_packet(COMMAND_PACKET *packet)
printf(" ] %02x %02x .\n", packet->CRC.as_bytes[0], packet->CRC.as_bytes[1]); printf(" ] %02x %02x .\n", packet->CRC.as_bytes[0], packet->CRC.as_bytes[1]);
} }
//============================================================================