flaneth

@@ -62,7 +62,7 @@ SRC = $(TARGET).c

 # uncomment the following:

 SRC += arp.c bus.c cf.c checksum.c config.c dhcp.c eeprom.c \

        ethernet.c http.c icmp.c ip.c random.c rtl8019.c \

-       ser62500.c status.c tcp.c timing.c uart.c udp.c \

+       ser62500.c status.c tasks.c tcp.c timing.c uart.c udp.c \

        xtea.c

 # You can also wrap lines by appending a backslash to the end of the line:

@@ -160,14 +160,14 @@ REBUILD_DEPS = Makefile.conf

 # Type: avrdude -c ?

 # to get a full listing.

 #

-#AVRDUDE_PROGRAMMER = stk200

-AVRDUDE_PROGRAMMER = avrisp2

+AVRDUDE_PROGRAMMER = stk200

+#AVRDUDE_PROGRAMMER = avrisp2

 #AVRDUDE_PORT = com1	# programmer connected to serial device

 #AVRDUDE_PORT = lpt1	# programmer connected to parallel port

-#AVRDUDE_PORT = /dev/parport0

-AVRDUDE_PORT = usb

+AVRDUDE_PORT = /dev/parport0

+#AVRDUDE_PORT = usb

 AVRDUDE_WRITE_FLASH = -U flash:w:$(TARGET).hex

 #AVRDUDE_WRITE_EEPROM = -U eeprom:w:$(TARGET).eep

@@ -11,6 +11,7 @@

 #include "debug.h"

 #include "macros.h"

 #include "status.h"

+#include "tasks.h"

 #include "timing.h"

 // IO pins of compact flash

@@ -57,13 +58,18 @@

 #define CF_SB_IDX (1)

 #define CF_SB_ERR (0)

+// timeout value for wait for ready after reset counter (in 20ms steps)

+#define CF_RESET_READY_TIMEOUT (50)    // 1s

+

+// timeout value for wait for ready counter (in 20ms steps)

+#define CF_READY_TIMEOUT (4)    // 80ms

+

 // compact flash commands

 #define CF_CMD_IDENTIFY (0xEC)

 #define CF_CMD_READ_SEC (0x20)

 #define CF_CMD_WRITE_SEC (0x30)

 // some number of bytes

-#define CF_BYTES_AT_ONCE (32)   // number of bytes to read/write at once

 #define CF_BYTES_IDENTIFY (124) // number of bytes to read for identify

 // interesting locations in identify data

@@ -77,61 +83,24 @@

 #define CF_CAPA_BIT_LBA (9)     // bit number of the LBA bit in the CF

                                 // capabilities

-// timeout value for wait for ready after reset counter (in 20ms steps)

-#define CF_WAIT_READY_RESET_20_TIMEOUT (50)    // 1s

+// compact flash error state (0 for no error, 1 for error)

+char CfErrorState = 1;

-// timeout value for wait for ready counter (in 20ms steps)

-#define CF_WAIT_READY_20_TIMEOUT (4)    // 80ms

-

-// compact flash insertion state

-enum CfInsertionState {

-  CfInsNone,    // no compact flash inserted

-  CfInsNew,     // new compact flash has been inserted, wait for powerup

-  CfInsReset,   // resetting new compact flash

-  CfInsWait,    // waiting for new compact flash to get ready after reset

-  CfInsReady,   // compact flash inserted and ready to work with

-  CfInsError,   // compact flash error occured, compact flash deactivated

-} CfInsState = CfInsNone;

-

-// compact flash working state

-enum CfWorkingState {

-  CfWorkNone,   // no compact flash work to do

-  CfWorkIdentify,       // identification of compact flash active

-} CfWorkState = CfWorkNone;

-

-// compact flash working step

-enum CfWorkingStep {

-  CfStepNone,   // no step in progress

-  CfStepCmdStatus,      // checking command status

-  CfStepDataTransfer,   // transferring (reading/writing) data

-  CfStepDataStatus,     // checking data status

-} CfWorkStep = CfStepNone;

+// tick/timeout counter of compact flash

+// - counts down in 20ms steps, stops at zero

+unsigned char CfTickCnt = 0;

 // number of sectors on compact flash card

 // - zero if no CF card is present, CF card has not yet been identified or CF 

 // card error occured

 unsigned long CfSectorCnt = 0;

-// state of active command

-unsigned long CfSectorNo = 0;   // current sector number of compact flash

-unsigned short CfNextOffset = 0;        // next offset in sector that is

-                                        // processed (read, written, ...)

-

-// wait for ready counter of compact flash

-// - counts down in 20ms steps

-// - zero if inactive

-unsigned char CfWaitReady20 = 0;

-

 // sector buffer

-unsigned char CfSectorBuffer[CF_SECTOR_SIZE];   // (extern)

+unsigned char CfSectorBuffer[CF_SECTOR_SIZE];   // FIXME

 // write a compact flash register (returns 1 if successful or 0 on error)

 // - returns 0 on success and -1 on error

-extern inline char CfWriteReg(unsigned char reg, unsigned char val)     // force 

-                                                                        // inlining 

-                                                                        // by 

-                                                                        // using 

-                                                                        // "extern"

+extern inline char CfWriteReg(unsigned char reg, unsigned char val)

 {

   if (!CF_IS_DETECT() || !CF_IS_READY())        // check that card is present 

                                                 // and ready

@@ -157,7 +126,6 @@ extern inline char CfWriteReg(unsigned char reg, unsigned char val)     // force

 // write buffer to compact flash register

 // (returns 1 if successful or 0 on error)

 // - returns 0 on success and -1 on error

-// - force inlining  by using "extern"

 extern inline char CfWriteRegBuf(unsigned char reg, unsigned char *p_buf,

                                  unsigned short len)

 {

@@ -192,11 +160,7 @@ extern inline char CfWriteRegBuf(unsigned char reg, unsigned char *p_buf,

 // write constant value to compact flash register multiple times (returns 1

 // if successful or 0 on error)

 // - returns 0 on success and -1 on error

-extern inline char CfWriteRegConst(unsigned char reg, unsigned char val, unsigned short cnt)    // force 

-                                                                                                // inlining 

-                                                                                                // by 

-                                                                                                // using 

-                                                                                                // "extern"

+extern inline char CfWriteRegConst(unsigned char reg, unsigned char val, unsigned short cnt)

 {

   if (!CF_IS_DETECT() || !CF_IS_READY())        // check that card is present 

                                                 // and ready

@@ -226,11 +190,7 @@ extern inline char CfWriteRegConst(unsigned char reg, unsigned char val, unsigne

 // read a compact flash register (returns 1 if successful or 0 on error)

 // - returns 0 on success and -1 on error

-extern inline char CfReadReg(unsigned char reg, unsigned char *p_var)   // force 

-                                                                        // inlining 

-                                                                        // by 

-                                                                        // using 

-                                                                        // "extern"

+extern inline char CfReadReg(unsigned char reg, unsigned char *p_var)

 {

   if (!CF_IS_DETECT() || !CF_IS_READY())        // check that card is present 

                                                 // and ready

@@ -253,11 +213,7 @@ extern inline char CfReadReg(unsigned char reg, unsigned char *p_var)   // force

 // read buffer from a compact flash register (returns 1 if successful or 0 on 

 // error)

 // - returns 0 on success and -1 on error

-extern inline char CfReadRegBuf(unsigned char reg, unsigned char *p_buf, unsigned short len)    // force 

-                                                                                                // inlining 

-                                                                                                // by 

-                                                                                                // using 

-                                                                                                // "extern"

+extern inline char CfReadRegBuf(unsigned char reg, unsigned char *p_buf, unsigned short len)

 {

   if (!CF_IS_DETECT() || !CF_IS_READY())        // check that card is present 

                                                 // and ready

@@ -285,11 +241,7 @@ extern inline char CfReadRegBuf(unsigned char reg, unsigned char *p_buf, unsigne

 // read a compact flash register multiple times and throw away data (returns

 // 1 if successful or 0 on error)

 // - returns 0 on success and -1 on error

-extern inline char CfReadRegMulti(unsigned char reg, unsigned short cnt)        // force 

-                                                                                // inlining 

-                                                                                // by 

-                                                                                // using 

-                                                                                // "extern"

+extern inline char CfReadRegMulti(unsigned char reg, unsigned short cnt)

 {

   if (!CF_IS_DETECT() || !CF_IS_READY())        // check that card is present 

                                                 // and ready

@@ -313,171 +265,184 @@ extern inline char CfReadRegMulti(unsigned char reg, unsigned short cnt)

   return cnt <= 0 ? 0 : -1;     // success if everything has been read

 }

-// compact flash work done

-static void CfDone(void)

+// compact flash error occured

+static void CfError(void)

 {

-  debug_cf_printf("CF done (%lu sectors)", CfSectorCnt);

+  debug_cf_printf("CF error");

-  // set working state and step to none

-  CfWorkState = CfWorkNone;

-  CfWorkStep = CfStepNone;

+  CfErrorState = 1;

+  CfTickCnt = 0;

-  // reset state of active command

-  CfSectorNo = 0;

-  CfNextOffset = 0;

+  CfSectorCnt = 0;

-  // disable wait for ready counter

-  CfWaitReady20 = 0;

+  // report no working CF present

+  StatusInfoCfPresent = 0;

 }

-// compact flash error occured

-static void CfError(void)

+// compact flash is gone

+static void CfGone(void)

 {

-  debug_cf_printf("CF error");

-

-  // set insertion state to error

-  CfInsState = CfInsError;

+  debug_cf_printf("CF gone");

-  // set working state and step to none

-  CfWorkState = CfWorkNone;

-  CfWorkStep = CfStepNone;

+  CfError();

+}

-  // reset all information about CF card

-  CfSectorCnt = 0;

+// compact flash timeout

+static void CfTimeout(void)

+{

+  debug_cf_printf("CF timeout");

-  // reset state of active command

-  CfSectorNo = 0;

-  CfNextOffset = 0;

+  CfError();

+}

-  // disable wait for ready counter

-  CfWaitReady20 = 0;

+// initialize

+void CfInit(void)       // (extern)

+{

+  // setup ports

+  bit_clear(CF_PORT_nCD, CF_BIT_nCD);   // pull-up of card detect pin off

+                                        // (external pull-up is present)

+  bit_clear(CF_DDR_nCD, CF_BIT_nCD);    // card detect pin to input

+  bit_set(CF_PORT_nRST, CF_BIT_nRST);   // reset not active

+  bit_set(CF_DDR_nRST, CF_BIT_nRST);    // reset pin to output

+  bit_clear(CF_PORT_RDY, CF_BIT_RDY);   // pull-up of ready pin pin off

+                                        // (external pull-up is present)

+  bit_clear(CF_DDR_RDY, CF_BIT_RDY);    // ready pin to input

+  bit_set(CF_PORT_nCE, CF_BIT_nCE);     // card not enabled

+  bit_set(CF_DDR_nCE, CF_BIT_nCE);      // card enable pin to output

 }

-// process compact flash insertion

-static void CfProcIns(void)

+// tick procedure - call every 20ms

+void CfTick20(void)     // (extern)

 {

-  switch (CfInsState) {

-

-    // no compact flash inserted

-  case CfInsNone:

-    // if compact flash is detected, set state to new CF

-    if (CF_IS_DETECT()) {

-      CfInsState = CfInsNew;

-      debug_cf_printf("new CF");

-      break;

+  // count down ticks

+  if (CfTickCnt > 0)

+    --CfTickCnt;

 }

-    break;

-    // new compact flash has been inserted, wait for powerup

-  case CfInsNew:

-    // if compact flash has been removed, set state to none

+/**

+ * @brief wait for CF to become ready

+ * @param[in] timeout timeout in 20ms steps

+ * @return 0 if CF ready, -1 if CF gone or timeout

+ */

+static int CfWaitReady(unsigned char timeout)

+{

+  CfTickCnt = timeout;

+

+  while (!CF_IS_READY()) {

+

+    // card gone -> error

     if (!CF_IS_DETECT()) {

-      CfInsState = CfInsNone;

-      break;

+      CfGone();

+      return -1;

     }

-    CfInsState = CfInsReset;

-    break;

-    // resetting new compact flash

-  case CfInsReset:

-    // set reset, wait, take back reset

-    CF_RESET_ACT();

-    nop();

-    nop();

-    nop();

-    CF_RESET_IDLE();

-    debug_cf_printf("CF reset");

-    // if compact flash has been removed, set state to none

-    if (!CF_IS_DETECT()) {

-      CfInsState = CfInsNone;

-      break;

+    // timeout -> error

+    if (CfTickCnt <= 0) {

+      CfTimeout();

+      return -1;

     }

-    // wait for CF to become ready

-    CfInsState = CfInsWait;

-    CfWaitReady20 = CF_WAIT_READY_RESET_20_TIMEOUT;

-    break;

-    // waiting for new compact flash to get ready after reset

-  case CfInsWait:

-    // if compact flash has been removed, set state to none

-    if (!CF_IS_DETECT()) {

-      CfInsState = CfInsNone;

-      break;

+    // execute other tasks while waiting

+    Tasks();

+

+  } // while (!CF_IS_READY())

+

+  return 0;

 }

-    // if compact flash card is ready, set state to ready

-    if (CF_IS_READY()) {

-      CfInsState = CfInsReady;

-      CfWaitReady20 = 0;

-      debug_cf_printf("CF ready");

-      break;

+

+/**

+ * @brief read bytes from CF card

+ * @param[in] ptr pointer to data buffer

+ * @param[in] sz size of data to read

+ * @return 0 if reading was successful, -1 if CF gon, timeout or error

+ */

+static int CfReadBytes(unsigned char *ptr, unsigned int sz)

+{

+  // read bytes

+  if (CfReadRegBuf(CF_REG_DATA, ptr, sz) != 0) {

+    debug_cf_printf("reading from CF failed (offset length 0x%03X)", sz);

+    CfError();

+    return -1;

   }

-    // count down timeout

-    CfWaitReady20--;

-    if (CfWaitReady20 <= 0) {

-      debug_cf_printf("timeout waiting for CF ready");

-      // start over

-      CfInsState = CfInsNone;

-      break;

+

+  return 0;

 }

-    break;

-    // compact flash inserted and ready to work with

-  case CfInsReady:

-    // do nothing here, card work is done by task procedure

-    // (task will detect CF removal or timeout and set state to error)

-    break;

+/**

+ * @brief check if CF card is present

+ * @return 1 if CF card is present, 0 if not

+ */

+char CfIsPresent(void) // (extern)

+{

+  if (CF_IS_DETECT())

+    return 1;

+  else

+    return 0;

+}

-    // compact flash error occured, compact flash deactivated

-  case CfInsError:

-    // if compact flash has been removed, set state to none

+/**

+ * @brief reset CF card

+ * @return 0 if CF card is present and could be reset, -1 if not

+ */

+char CfReset(void) // (extern)

+{

+  // wait one tick

   if (!CF_IS_DETECT()) {

-      CfInsState = CfInsNone;

-      debug_cf_printf("CF removed");

+    CfGone();

+    return -1;

   }

-    break;

+  CfTickCnt = 1;

+  while (CfTickCnt > 0)

+    Tasks();

-  }     // switch( CfInsState )

+  // set reset, wait, take back reset

+  if (!CF_IS_DETECT()) {

+    CfGone();

+    return -1;

   }

+  CF_RESET_ACT();

+  nop();

+  nop();

+  nop();

+  CF_RESET_IDLE();

+  debug_cf_printf("CF reset");

-// detect compact flash timeout

-// - called every 20ms

-static void CfDetectTimeout20(void)

-{

-  // only detect CF timeout if insertion state is ready

-  // (otherwise, the insertion processing is still doing some work)

-  if (CfInsState != CfInsReady)

-    return;

-

-  // wait for ready counter not active

-  if (CfWaitReady20 <= 0)

-    return;

+  // wait for CF to become ready

+  if (CfWaitReady(CF_RESET_READY_TIMEOUT) != 0)

+    return -1;

-  // decrement wait for ready counter

-  CfWaitReady20--;

+  // report working CF present

+  CfErrorState = 0;

+  StatusInfoCfPresent = 1;

+  debug_cf_printf("CF ready");

-  // timeout occured

-  if (CfWaitReady20 <= 0) {

-    debug_cf_printf("timeout while waiting for CF ready");

-    CfError();

-  }

+  return 0;

 }

-// continue with identifying compact flash

-static void CfProcWorkIdentify(void)

+/**

+ * @brief identify CF card

+ * @param[out] sectors number of sectors on CF card

+ * @return 0 if CF card could be identified, -1 if not

+ */

+char CfIdentify(unsigned long *sectors) // (extern)

 {

-  unsigned char status = 0;

-  unsigned short len, val16;

+  unsigned char status, identifyBuf[CF_BYTES_IDENTIFY];

+  unsigned short val16;

-  switch (CfWorkStep) {

+  debug_cf_printf("CF identify");

+  if (CfErrorState) {

+    debug_cf_printf("CF in error state");

+    return -1;

+  }

-    // no step

-  case CfStepNone:

-    debug_cf_printf("internal error (identify, CfStepNone)");

+  // issue identify drive command

+  if (CfWriteReg(CF_REG_CMD, CF_CMD_IDENTIFY) != 0) {

     CfError();

-    break;

+    return -1;

+  }

+  if (CfWaitReady(CF_READY_TIMEOUT) != 0)

+    return -1;

-    // checking command status

-  case CfStepCmdStatus:

   // read status register

   CfReadReg(CF_REG_STATUS, &status);

   // check that BUSY=0, RDY=1, DWF=0, DSC=1, IDX=0, ERR=0

@@ -487,178 +452,100 @@ static void CfProcWorkIdentify(void)

       (1 << CF_SB_RDY | 1 << CF_SB_DSC)) {

     debug_cf_printf("unexpected status 0x%02X (identify)", status);

     CfError();

+    return -1;

   }

-    // continue with data transfer

-    CfWorkStep = CfStepDataTransfer;

-    CfNextOffset = 0;

-    break;

-    // transferring data

-  case CfStepDataTransfer:

-    // still bytes to read

-    if (CfNextOffset < CF_BYTES_IDENTIFY) {

-      // get number of bytes to read

-      len = CF_BYTES_IDENTIFY - CfNextOffset;

-      if (len > CF_BYTES_AT_ONCE)

-        len = CF_BYTES_AT_ONCE;

-      // read bytes

-      if (CfReadRegBuf(CF_REG_DATA, &CfSectorBuffer[CfNextOffset], len) != 0) {

-        debug_cf_printf

-            ("reading from CF failed (identify, offset 0x%03X, length 0x%02X)",

-             CfNextOffset, len);

-        CfError();

-        break;

-      }

-      CfNextOffset += len;

-    }

-    // all bytes read

-    if (CfNextOffset >= CF_BYTES_IDENTIFY) {

+  // read identify bytes

+  if (CfReadBytes(identifyBuf, sizeof(identifyBuf)) != 0)

+    return -1;

+

   // check identifier

-      val16 = (unsigned short)CfSectorBuffer[CF_ID_OFS_ID_16 + 0]

-          | (unsigned short)CfSectorBuffer[CF_ID_OFS_ID_16 + 1] << 8;

+  val16 = (unsigned short)identifyBuf[CF_ID_OFS_ID_16 + 0] |

+          (unsigned short)identifyBuf[CF_ID_OFS_ID_16 + 1] << 8;

   if (val16 != CF_ID) {

     debug_cf_printf("invalid CF identifier: 0x%04X", val16);

     CfError();

-        break;

+    return -1;

   }

+

   // check if LBA mode is supported

-      val16 = (unsigned short)CfSectorBuffer[CF_ID_OFS_CAPA_16 + 0]

-          | (unsigned short)CfSectorBuffer[CF_ID_OFS_CAPA_16 + 1] << 8;

+  val16 = (unsigned short)identifyBuf[CF_ID_OFS_CAPA_16 + 0]

+      | (unsigned short)identifyBuf[CF_ID_OFS_CAPA_16 + 1] << 8;

   if ((val16 & 1 << CF_CAPA_BIT_LBA) == 0) {

     debug_cf_printf("CF does not support LBA mode");

     CfError();

-        break;

+    return -1;

   }

   // get number of sectors on CF

-      CfSectorCnt = (unsigned long)CfSectorBuffer[CF_ID_OFS_SEC_CNT_32 + 0]

-          | (unsigned long)CfSectorBuffer[CF_ID_OFS_SEC_CNT_32 + 1] << 8

-          | (unsigned long)CfSectorBuffer[CF_ID_OFS_SEC_CNT_32 + 2] << 16

-          | (unsigned long)CfSectorBuffer[CF_ID_OFS_SEC_CNT_32 + 3] << 24;

+  CfSectorCnt = (unsigned long)identifyBuf[CF_ID_OFS_SEC_CNT_32 + 0]

+      | (unsigned long)identifyBuf[CF_ID_OFS_SEC_CNT_32 + 1] << 8

+      | (unsigned long)identifyBuf[CF_ID_OFS_SEC_CNT_32 + 2] << 16

+      | (unsigned long)identifyBuf[CF_ID_OFS_SEC_CNT_32 + 3] << 24;

   if (CfSectorCnt <= 0) {

     debug_cf_printf("CF does not contain any sectors");

     CfError();

-        break;

-      }

-      // done

-      CfDone();

+    return -1;

   }

-    break;

-    // checking data status

-  case CfStepDataStatus:

-    debug_cf_printf("internal error (identify, CfStepDataStatus)");

-    CfError();

-    break;

+  debug_cf_printf("CF done (%lu sectors)", CfSectorCnt);

-  }     // switch( CfWorkStep )

+  return 0;

 }

-// do normal compact flash work

-static void CfProcWork(void)

+/**

+ * @brief read from CF card

+ * @param[in] sector number of sector to read

+ * @param[out] data data read from sector

+ * @return 0 if sector could be read, -1 if not

+ */

+char CfRead(unsigned long sector, unsigned char data[CF_SECTOR_SIZE]) // (extern)

 {

-  // only do CF processing if insertion state is ready

-  // (otherwise, the insertion processing is still doing some work)

-  if (CfInsState != CfInsReady)

-    return;

+  unsigned char status;

-  // compact flash has been removed -> error

-  if (!CF_IS_DETECT()) {

-    debug_cf_printf("CF no more present");

-    CfError();

-    return;

-  }

-  // compact flash is not ready

-  if (!CF_IS_READY()) {

-    // wait for ready not active --> error

-    if (CfWaitReady20 <= 0) {

-      debug_cf_printf("CF no more ready");

-      CfError();

-    }

-    // do nothing if CF is not ready

-    return;

+  debug_cf_printf("CF read (sector %lu)", sector);

+  if (CfErrorState) {

+    debug_cf_printf("CF in error state");

+    return -1;

   }

-

-  switch (CfWorkState) {

-

-    // no compact flash work to do

-  case CfWorkNone:

-    // nothing to do here

-    break;

-

-    // identification of compact flash active

-  case CfWorkIdentify:

-    CfProcWorkIdentify();

-    break;

-

-  }     // switch( CfWorkState )

+  if (sector >= CfSectorCnt) {

+    debug_cf_printf("sector does not exist");

+    return -1;

   }

-// identify compact flash

-// - returns 0 on success, 1 if not idle and -1 on error

-static char CfIdentify(void)

-{

-  // check that no command is being worked on

-  if (CfWorkState != CfWorkNone)

-    return 1;

-

-  debug_cf_printf("CF identify");

-

-  // issue identify drive command

-  if (CfWriteReg(CF_REG_CMD, CF_CMD_IDENTIFY) != 0) {

+  // set sector number (LBA mode) and sector count (1)

+  if (CfWriteReg(CF_REG_HEAD, 0xE0 | (sector >> 24 & 0x0F)) != 0 ||

+      CfWriteReg(CF_REG_CYL_H, sector >> 16) != 0 ||

+      CfWriteReg(CF_REG_CYL_L, sector >> 8) != 0 ||

+      CfWriteReg(CF_REG_SEC_NO, sector) != 0 ||

+      CfWriteReg(CF_REG_SEC_CNT, 1) != 0) {

     CfError();

     return -1;

   }

-  // now identifying compact flash

-  CfWorkState = CfWorkIdentify;

-  CfWorkStep = CfStepCmdStatus;

-  CfNextOffset = 0;

-  CfWaitReady20 = CF_WAIT_READY_20_TIMEOUT;

-  return 0;

-}

-// initialize

-void CfInit(void)       // (extern)

-{

-  // setup ports

-  bit_clear(CF_PORT_nCD, CF_BIT_nCD);   // pull-up of card detect pin off

-                                        // (external pull-up is present)

-  bit_clear(CF_DDR_nCD, CF_BIT_nCD);    // card detect pin to input

-  bit_set(CF_PORT_nRST, CF_BIT_nRST);   // reset not active

-  bit_set(CF_DDR_nRST, CF_BIT_nRST);    // reset pin to output

-  bit_clear(CF_PORT_RDY, CF_BIT_RDY);   // pull-up of ready pin pin off

-                                        // (external pull-up is present)

-  bit_clear(CF_DDR_RDY, CF_BIT_RDY);    // ready pin to input

-  bit_set(CF_PORT_nCE, CF_BIT_nCE);     // card not enabled

-  bit_set(CF_DDR_nCE, CF_BIT_nCE);      // card enable pin to output

+  // issue read sector command

+  if (CfWriteReg(CF_REG_CMD, CF_CMD_READ_SEC) != 0) {

+    CfError();

+    return -1;

   }

+  if (CfWaitReady(CF_READY_TIMEOUT) != 0)

+    return -1;

-// tick procedure - call every 20ms

-void CfTick20(void)     // (extern)

-{

-  // process compact flash insertion

-  CfProcIns();

-

-  // detect compact flash timeout

-  CfDetectTimeout20();

+  // read status register

+  CfReadReg(CF_REG_STATUS, &status);

+  // check that BUSY=0, RDY=1, DWF=0, DSC=1, IDX=0, ERR=0

+  if ((status &

+       (1 << CF_SB_BUSY | 1 << CF_SB_RDY | 1 << CF_SB_DWF | 1 << CF_SB_DSC |

+        1 << CF_SB_IDX | 1 << CF_SB_ERR)) !=

+      (1 << CF_SB_RDY | 1 << CF_SB_DSC)) {

+    debug_cf_printf("unexpected status 0x%02X (identify)", status);

+    CfError();

+    return -1;

   }

-// task function to do the work - call from main loop

-void CfTask(void)       // (extern)

-{

-  // do nothing if no CF is inserted

-  if (CfInsState != CfInsReady)

-    return;

+  // read sector bytes

+  if (CfReadBytes(data, CF_SECTOR_SIZE) != 0)

+    return -1;

-  // compact flash is ready but not yet identified

-  if (CfSectorCnt == 0) {

-    // identify compact flash

-    CfIdentify();

+  return 0;

 }

-  // do normal compact flash work

-  CfProcWork();

-  // update status

-  StatusInfoCfPresent = CfInsState == CfInsReady;       // report working CF

-                                                        // if insertion state

-                                                        // is ready

-}

@@ -9,16 +9,38 @@

 // size of a sector in bytes

 #define CF_SECTOR_SIZE (512)

-// sector buffer

-extern unsigned char CfSectorBuffer[CF_SECTOR_SIZE];

-

 // initialize

 extern void CfInit(void);

 // tick procedure - call every 20ms

 extern void CfTick20(void);

-// task function to do the work - call from main loop

-extern void CfTask(void);

+/**

+ * @brief check if CF card is present

+ * @return 1 if CF card is present, 0 if not

+ */

+extern char CfIsPresent(void);

+

+/**

+ * @brief reset CF card

+ * @return 0 if CF card could be reset, -1 if not

+ */

+extern char CfReset(void);

+

+/**

+ * @brief identify CF card

+ * @param[out] sectors number of sectors on CF card

+ * @return 0 if CF card could be identified, -1 if not

+ */

+extern char CfIdentify(unsigned long *sectors);

+

+/**

+ * @brief read from CF card

+ * @param[in] sector number of sector to read

+ * @param[out] data data read from sector

+ * @return 0 if sector could be read, -1 if not

+ */

+extern char CfRead(unsigned long sector, unsigned char data[CF_SECTOR_SIZE]);

 #endif // #ifndef INC_cf

+

@@ -15,10 +15,56 @@

 #include "random.h"

 #include "rtl8019.h"

 #include "status.h"

+#include "tasks.h"

 #include "tcp.h"

 #include "timing.h"

 #include "uart.h"

+// try to work with CF card

+static void mainWorkCf(void)

+{

+  unsigned long sectors, s;

+  unsigned char buf[CF_SECTOR_SIZE];

+

+  // reset card

+  if (CfReset() != 0)

+    return;

+

+  // identify card

+  if (CfIdentify(&sectors) != 0)

+    return;

+

+  // dump sectors

+  for (s = 0; s < sectors; ++s) {

+    if (CfRead(s, buf) != 0)

+      return;

+#if 0

+    unsigned int i;

+    for (i = 0; i < CF_SECTOR_SIZE; ++i) {

+      printf(" %02X", buf[i]);

+      if ((i & 15) == 15)

+        printf("\r\n");

+    }

+#endif

+    Tasks();

+  } // for s

+}

+

+// wait for CF card and work with it

+static void mainWaitCf(void)

+{

+  // wait for new card

+  while (!CfIsPresent())

+    Tasks();

+

+  // work with card

+  mainWorkCf();

+

+  // wait for failing card to be removed

+  while (CfIsPresent())

+    Tasks();

+}

+

 // main code entry point

 int main(void)

 {

@@ -66,18 +112,8 @@ int main(void)

   debug_init_printf("start");

   // main loop

-  while (1) {

-    wdt_reset();

-    CfTask();

-    wdt_reset();

-    EepromTask();

-    wdt_reset();

-    RandomTask();

-    wdt_reset();

-    //RtlTask();

-    wdt_reset();

-    TimingTask();

-  }

+  while (1)

+    mainWaitCf();

   return 0;

 }

@@ -0,0 +1,35 @@

+/* flaneth - flash and ethernet

+   Copyright (C) 2007-2012 Stefan Schuermans <stefan@schuermans.info>

+   Copyleft: GNU public license V2 - http://www.gnu.org/copyleft/gpl.html

+   a BlinkenArea project - http://www.blinkenarea.org/ */

+

+#include <avr/wdt.h>

+

+#include "arp.h"

+#include "bus.h"

+#include "cf.h"

+#include "debug.h"

+#include "eeprom.h"

+#include "http.h"

+#include "random.h"

+#include "rtl8019.h"

+#include "status.h"

+#include "tasks.h"

+#include "tcp.h"

+#include "timing.h"

+#include "uart.h"

+

+// task function to call all tasks - call from main loop

+void Tasks(void) // (extern)

+{

+    wdt_reset();

+    EepromTask();

+    wdt_reset();

+    RandomTask();

+    wdt_reset();

+    RtlTask();

+    wdt_reset();

+    TimingTask();

+    wdt_reset();

+}

+

@@ -0,0 +1,12 @@

+/* flaneth - flash and ethernet

+   Copyright (C) 2007-2012 Stefan Schuermans <stefan@schuermans.info>

+   Copyleft: GNU public license V2 - http://www.gnu.org/copyleft/gpl.html

+   a BlinkenArea project - http://www.blinkenarea.org/ */

+

+#ifndef INC_tasks

+#define INC_tasks

+

+// task function to call all tasks - call from main loop

+extern void Tasks(void);

+

+#endif // #ifndef INC_tasks