exec.c

PIC Kit serial source code.

//    write CONTROL_BLOCK to EE
//    checksum value = 2's complement of calc checksum
//==========================================================
void exec_cb_ee_write(void)
{
   exec_count = 0;
   exec_data = EXEC_CB_CHKSUM_SEED;
   EEADR = EE_ADDR_CB_START;
   while(exec_count < EXEC_CB_LENGTH)
   {
      EEDATA = exec_control_B[exec_count++]._byte;
      exec_data += EEDATA;
      ee_write_na();
   }
   EEDATA = ~exec_data + 1;
   ee_write_na();
}

//==========================================================
//--- exec_cb_ee_read()
//    read CONTROL_BLOCK from EE
//    return:
//       ==0:  checksum OK
//       <>0:  checksum bad
//==========================================================
TD_BYTE exec_cb_ee_read(void)
{
   exec_data = EXEC_CB_CHKSUM_SEED;
   exec_count = 0;
   while(exec_count < EXEC_CB_LENGTH)
   {
      exec_control_B[exec_count]._byte = \
         ee_read(EE_ADDR_CB_START + exec_count);
      exec_data += EEDATA;
      exec_count++;
   }
   exec_data += ee_read(EE_ADDR_CB_START + exec_count);
   return(exec_data);
}

//==========================================================
//--- exec_packet_proc()
//    process USB packet
//==========================================================
void exec_packet_proc(void)
{
   EXEC_SB_DATA_ERR_FLAG = 0;
   EXEC_PROC_LOOP_FLAG = 1;

   while(EXEC_PROC_LOOP_FLAG && (not EXEC_SB_DATA_ERR_FLAG))
   {
      
      //------------------------------------------
      //--- fetch TAG
      //------------------------------------------
      if(not exec_data_get())
      {
         EXEC_PROC_LOOP_FLAG = 0;
         break;
      }
      
      //------------------------------------------
      //--- process TAG
      //------------------------------------------
      switch(exec_data)
      {

         //=======================================
         //--- EOD TAG
         //=======================================
         case EXEC_TAG_EOD:
            EXEC_PROC_LOOP_FLAG = 0;
            break;
            
         //=======================================
         //--- Immediate Command
         //=======================================
         case EXEC_TAG_COMMAND:
            if(exec_data_get())
            {
               exec_cmnd_proc(exec_data);
            }
            else
            {
               EXEC_SB_DATA_ERR_FLAG = 1;
            }
            break;
            
         //=======================================
         //--- write CONTROL_BLOCK
         //=======================================
         case EXEC_TAG_CB_WRITE:
            EXEC_CB_NEW_FLAG = 1;
            exec_count = 0;
            while(exec_count < EXEC_CB_LENGTH)
            {
               if(exec_data_get())
               {
                  exec_control_B[exec_count]._byte = exec_data;
                  exec_count++;
               }
               else
               {
                  EXEC_SB_DATA_ERR_FLAG = 1;
                  EXEC_CB_NEW_FLAG = 0;
                  break;
               }
            }
            break;
            
         //=======================================
         //--- write: CBUF1
         //=======================================
         case EXEC_TAG_CBUF1_WRITE:
            if(exec_data_get())
            {
               exec_count = exec_data;

               //debug
               exec_debug_1 = exec_count;
               exec_debug_2 = cbuf1.unused;

               while(exec_count--)
               {
                  if(exec_data_get())
                  {
                     exec_cbuf1_put();
                  }
                  else
                  {
                     EXEC_SB_DATA_ERR_FLAG = 1;
                  }  // end data byte
               }  // end while
            }
            else
            {
               EXEC_SB_DATA_ERR_FLAG = 1;
            }  // end data get - byte count
            break;

         //=======================================
         //--- write: CBUF2
         //=======================================
         case EXEC_TAG_CBUF2_WRITE:
            if(exec_data_get())
            {
               exec_count = exec_data;
               while(exec_count--)
               {
                  if(exec_data_get())
                  {
                     if(cbuf2.unused)
                     {
                        cbuf2_put(exec_data);
                     }
                     else
                     {
                        EXEC_SB_CBUF2_OVF_FLAG = 1;
                        EXEC_SB_DATA_ERR_FLAG = 1;
                     }
                  }
                  else
                  {
                     EXEC_SB_DATA_ERR_FLAG = 1;
                  }  // end data byte
               }  // end while
            }
            else
            {
               EXEC_SB_DATA_ERR_FLAG = 1;
            }  // end data get - byte count
            break;

         //=======================================
         //--- write: CBUF3
         //=======================================
         case EXEC_TAG_CBUF3_WRITE:
            if(exec_data_get())
            {
               exec_count = exec_data;
               while(exec_count--)
               {
                  if(exec_data_get())
                  {
                     if(cbuf3.unused)
                     {
                        cbuf3_put(exec_data);
                     }
                     else
                     {
                        EXEC_SB_CBUF3_OVF_FLAG = 1;
                        EXEC_SB_DATA_ERR_FLAG = 1;
                     }
                  }
                  else
                  {
                     EXEC_SB_DATA_ERR_FLAG = 1;
                  }  // end data byte
               }  // end while
            }
            else
            {
               EXEC_SB_DATA_ERR_FLAG = 1;
            }  // end data get - byte count
            break;

         //=======================================
         //--- write: LED1 configuration
         //=======================================
         case EXEC_TAG_LED1_CONFIG:
            if(exec_data_get())
            {
               led_1_config(exec_data);
            }
            else
            {
               EXEC_SB_DATA_ERR_FLAG = 1;
            }
            break;

         //=======================================
         //--- write: LED2 configuration
         //=======================================
         case EXEC_TAG_LED2_CONFIG:
            if(exec_data_get())
            {
               led_2_config(exec_data);
            }
            else
            {
               EXEC_SB_DATA_ERR_FLAG = 1;
            }
            break;

         //=======================================
         //--- CBUF1 RESET
         //=======================================
         case EXEC_TAG_CBUF1_RESET:
            cbuf1_init();
            break;

         //=======================================
         //--- CBUF2 RESET
         //=======================================
         case EXEC_TAG_CBUF2_RESET:
            cbuf2_init();
            break;

         //=======================================
         //--- CBUF3 RESET
         //=======================================
         case EXEC_TAG_CBUF3_RESET:
            cbuf3_init();
            break;

         //=======================================
         //--- boot
         //=======================================
         case EXEC_TAG_BOOT_B:
         case EXEC_TAG_BOOT_b:
            usb_detach_soft();
            EECON1 = 0;
            EECON1bits.EEPGD = 1;
            EECON1bits.WREN = 1;
            *((rom far char *) BOOT_MARKER_ADDR) = 0;
            EECON2 = 0x55;
            EECON2 = 0xAA;
            EECON1bits.WR = 1;
            timer0_A4 = EXEC_REBOOT_DLY_TA;
            while(timer0_A4)
            {
               timer0_svc();
            }
            Reset();
            break;
            
         //=======================================
         //--- write: STATUS PACKET RQ
         //=======================================
         case EXEC_TAG_EXEC_STATUS_RQ:
            if(exec_data_get())
            {
               exec_status_id = exec_data;
               EXEC_RQ_STATUS_PACKET_ID_FLAG = 1;
            }
            else
            {
               EXEC_SB_DATA_ERR_FLAG = 1;
            }
            break;

         //=======================================
         //--- ERROR
         //=======================================
         default:
            EXEC_SB_DATA_ERR_FLAG = 1;
            break;
      }
   }      
}


//==========================================================
//--- exec_packet_prep()
//    prep varbs for building USB output buffer/packet
//==========================================================
void exec_packet_prep(void)
{
   exec_data_p = USB_XMTBUF_POINTER;
   exec_data_count = 0;
}


//==========================================================
//--- exec_packet_prep()
//    prep varbs for building USB output buffer/packet
//--- exec_packet_finish()
//    complete then transmit USB output buffer/packet
//--- exec_packet_cbuf2()
//    load USB output packet/buffer with cbuf2 data
//==========================================================
void exec_packet_finish(void)
{
   if(exec_data_count < USB_XMTBUF_COUNT_MAX )
      exec_data_put(EXEC_TAG_EOD_OUT);
   USB_XMTBUF_RELEASE_FUNC();
}


//==========================================================
//--- exec_packet_cbuf2()
//    load USB output packet/buffer with cbuf2 data
//==========================================================
void exec_packet_cbuf2(void)
{
   exec_count = EXEC_DATA_LENGTH_MAX - exec_data_count - 2;
   if(exec_count > cbuf2.used)
      exec_count = cbuf2.used;
   exec_data_put(EXEC_TAG_CBUF2_DATA);
   exec_data_put(exec_count);
   while(exec_count--)
   {
      exec_data_put(cbuf2_get());
   }
}


//==========================================================
//--- exec_status_packet()
//    build status packet in USB output buffer
//==========================================================
void exec_packet_status(TD_BYTE id)
{
   exec_data_put(EXEC_TAG_PACKET_ID);
   exec_data_put(id);
   exec_data_put(EXEC_TAG_FIRMWARE_VERSION);
   exec_data_put(EXEC_FIRMWARE_VERSION_MINOR);
   exec_data_put(EXEC_FIRMWARE_VERSION_MAJOR);
   exec_data_put(EXEC_TAG_CB_DATA);
   exec_count = 0;
   while(exec_count < EXEC_CB_LENGTH)
   {
      exec_data_put(exec_control_B[exec_count]._byte);
      exec_count++;
   }
   exec_data_put(EXEC_TAG_SB_DATA);
   exec_count = 0;
   while(exec_count < EXEC_SB_LENGTH)
   {
      exec_data_put(exec_status_B[exec_count]._byte);
      exec_count++;
   }
   exec_data_put(EXEC_TAG_CBUF_STATUS);

   EXEC_GIEL_FLAG = 0;
   if(INTCONbits.GIEL)
   {
      while(INTCONbits.GIEL)
      {
         INTCONbits.GIEL = 0;
      }
      EXEC_GIEL_FLAG = 1;
   }

   exec_data_put(cbuf1.used);
   exec_data_put(cbuf1.unused);
   exec_data_put(cbuf2.used);
   exec_data_put(cbuf2.unused);
   exec_data_put(cbuf3.used);
   exec_data_put(cbuf3.unused);
   
   //debug
   exec_debug_3 = cbuf1.unused;

   if(EXEC_GIEL_FLAG)
      INTCONbits.GIEL = 1;
}
   

//==========================================================
//--- exec_data_get()
//    get data byte from USB input buffer
//==========================================================
TD_BYTE exec_data_get(void)
{
   if(exec_data_count--)
   {
      exec_data = *exec_data_p++;
      return 1;
   }
   return 0;      
}      


//==========================================================
//--- exec_data_put()
//    put data byte into USB output buffer
//==========================================================
void exec_data_put(TD_BYTE b0)
{
   exec_data_p[exec_data_count++] = b0;
}      


//==========================================================
//--- exec_data_put()
//    put data byte into USB output buffer
//==========================================================
void exec_cbuf1_put(void)
{
   EXEC_GIEL_FLAG = 0;
   if(INTCONbits.GIEL)
   {
      while(INTCONbits.GIEL)
      {
         INTCONbits.GIEL = 0;
      }
      EXEC_GIEL_FLAG = 1;
   }

   if(cbuf1.unused)
   {
      cbuf1_put(exec_data);
   }
   else
   {
      EXEC_SB_CBUF1_OVF_FLAG = 1;
      EXEC_SB_DATA_ERR_FLAG = 1;
   }

   if(EXEC_GIEL_FLAG)
      INTCONbits.GIEL = 1;
}