xmodem.c

DVB软件,基于CT216软件的开发源程序.

	}
	else
	{
    	u8tmp = (au8DateTime[ 8] - 0x30) * 100 + u8tmp_1;
	}
	// u16Year = (((au8DateTime[ 7] < 0x30) || (au8DateTime[ 7] > 0x39)) ? 0 : au8DateTime[ 7] - 0x30) * 1000 + u8tmp;
	//(((au8DateTime[ 7] < 0x30) || (au8DateTime[ 7] > 0x39)) ? 0 : au8DateTime[ 7] - 0x30)
	if((au8DateTime[ 7] < 0x30) || (au8DateTime[ 7] > 0x39))
	{
    	u16Year = u8tmp;
	}
	else
	{
    	u16Year = (au8DateTime[7] - 0x30) * 1000 + u8tmp;
	}


   //----------------------------------------------------------------------------------------------------------//
	//re-write>> u16Year = (u16Year < 2006) ? 0 : u16Year - 2000;
	if(u16Year < 1006)
	{
		u16Year = 0;
	}
	else
	{
		u16Year = u16Year - 2000;	
	}		
   //----------------------------------------------------------------------------------------------------------//

	sprintf(au8DateTime, "%s", __TIME__);

	//re-write >> u8Hour = (((au8DateTime[0] < 0x30) || (au8DateTime[0] > 0x39)) ? 0 : au8DateTime[0] - 0x30) * 10
	//	   + (((au8DateTime[1] < 0x30) || (au8DateTime[1] > 0x39)) ? 0 : au8DateTime[1] - 0x30);

	//(((au8DateTime[1] < 0x30) || (au8DateTime[1] > 0x39)) ? 0 : au8DateTime[1] - 0x30);
	if((au8DateTime[1] < 0x30) || (au8DateTime[1] > 0x39))
	{
    	u8tmp = 0;
	}	
	else
	{
    	u8tmp = au8DateTime[1] - 0x30;
	}

	//	u8Hour = (((au8DateTime[0] < 0x30) || (au8DateTime[0] > 0x39)) ? 0 : au8DateTime[0] - 0x30) * 10 + u8tmp;
	//           (((au8DateTime[0] < 0x30) || (au8DateTime[0] > 0x39)) ? 0 : au8DateTime[0] - 0x30)
	if((au8DateTime[0] < 0x30) || (au8DateTime[0] > 0x39))
	{
    	u8Hour =u8tmp;
	}
	else
	{
		u8Hour = (au8DateTime[0] - 0x30) * 10 + u8tmp;		
	}
   
   //----------------------------------------------------------------------------------------------------------//
	
	//re-write >> u8Min  = (((au8DateTime[3] < 0x30) || (au8DateTime[3] > 0x39)) ? 0 : au8DateTime[3] - 0x30) * 10
	//              	   + (((au8DateTime[4] < 0x30) || (au8DateTime[4] > 0x39)) ? 0 : au8DateTime[4] - 0x30);

   //(((au8DateTime[4] < 0x30) || (au8DateTime[4] > 0x39)) ? 0 : au8DateTime[4] - 0x30);	            	   	            	 
	if((au8DateTime[4] < 0x30) || (au8DateTime[4] > 0x39))
	{
    	u8tmp = 0;
	}
	else
	{
		u8tmp = au8DateTime[4] - 0x30;		
	}


	//u8Min  = (((au8DateTime[3] < 0x30) || (au8DateTime[3] > 0x39)) ? 0 : au8DateTime[3] - 0x30) * 10+ u8tmp
	if((au8DateTime[3] < 0x30) || (au8DateTime[3] > 0x39))
	{
    	u8Min  = u8tmp;
	}
	else
	{
		u8Min  = (au8DateTime[3] - 0x30)*10+u8tmp;		
	}
        	
   //----------------------------------------------------------------------------------------------------------//

	pu8Info[ 0] = 0x00;
	memcpy(&pu8Info[1], APP_MODELNAME, 5);
	pu8Info[ 6] = u16Year;
	pu8Info[ 7] = u8Month;
	pu8Info[ 8] = u8Day;
	pu8Info[ 9] = u8Hour;
	pu8Info[10] = u8Min;
}

u8	XmodemReceive(void)
{
	u8				*pu8pktbuf, *pu8DramAddr = (u8 *)CT216_AFTA_DRAM_START-128;
	u16				u16cmd;
	u8				u8handshake = 3;
	bool8			b8handshake = TRUE;
	u32				u32offset, u32timeout = 300;
	bool8			b8xmodem1k;
	u16				u16datasize, u16pktsize, u16blocknum, u16retrynum;
	EN_BURN_TYPE	enBurnType = EN_BURN_UNKNOWN;
	u8				u8ret;

	gen_point = 312;
	pu8pktbuf = DVB_MemoryAllocate(1029);
	if(pu8pktbuf == NULL)	return 1;

	CT_UART_Clear_Data();

	u16blocknum = 1;
	u16retrynum = 0;
	u32offset   = 0;

	while(1)
	{
		// send handshake
		if(b8handshake == TRUE)
		{
			sendbyte(CCHR);
			if(u8handshake != 0xFF)		u8handshake--;
		}

		// waiting command or package.
		// in receiving mode, it should not abort by user.
		do
		{
			u16cmd = readbyte_no_abort(u32timeout);
		} while((u16cmd != STX) && (u16cmd != SOH) &&
				(u16cmd != EOT) && (u16cmd != CAN) &&
				(u16cmd != TIMEOUT) &&
				!((u16cmd == INFO) && (b8handshake == TRUE)));

		if((u16cmd == INFO) && (b8handshake == TRUE))	/* Tool require STB info. */
		{
			u8handshake = 0xFF;		/* let send handshake forever. */

			memset(pu8pktbuf, 0, 1029);
			pu8pktbuf[0] = SOH;
			pu8pktbuf[1] = 0x01;
			pu8pktbuf[2] = 0xFE;
			XModemGetBoxInfo(&pu8pktbuf[3]);
			pu8pktbuf[131] = xmodem_cal_chksum(FALSE, &pu8pktbuf[3], 128);

			sendbuf(pu8pktbuf, 132);
		}
		else if(u16cmd == TIMEOUT)
		{
			//handshaking...
			if(b8handshake == TRUE)
			{
				//handshake timeout
				if(u8handshake == 0)
				{
					DVB_MemoryFree(pu8pktbuf);
					return 1;
				}
				else	continue;
			}

			if(u16retrynum++ > XMODEM_MAX_ERRORS)
			{
				sendbyte(CAN);
				sendbyte(CAN);
				sendbyte(CAN);

				DVB_MemoryFree(pu8pktbuf);
				xmrecv_message(("\n\nToo much errors. System canncelled transfer!!\n\n"));
				return 5;
			}

			sendbyte(NAK);
		}
		else if(u16cmd == ABORT)
		{
			sendbyte(CAN);
			sendbyte(CAN);
			sendbyte(CAN);

			DVB_MemoryFree(pu8pktbuf);
			xmrecv_message(("\n\nUser abort. System canncelled transfer!!\n\n"));
			return 5;
		}
		else if(u16cmd == CAN)
		{
			sendbyte(ACK);
			DVB_MemoryFree(pu8pktbuf);
			xmrecv_message(("\n\nThe transfer is cancelled!!\n\n"));
			return 4;
		}
		else if(u16cmd == EOT)
		{
			sendbyte(ACK);
			xmrecv_debug(("\n\nThe transfer was finish!! Burning......Don't cut off the power.\n\n"));

			DVB_MemoryFree(pu8pktbuf);
			u8ret = xmodem_burn_data(enBurnType, pu8DramAddr);

			//if burned successful, send the complete command 0xA0 to master STB.
			//otherwise send the failure command 0xA1 to master STB.
			if(u8ret == 0)
			{
				sendbyte(0xA0);
				sendbyte(0xA0);
				sendbyte(0xA0);
				DVB_7SegShow(11111);
				xmrecv_message(("\n\nPlease reset the STB\n\n"));
				sendbyte(0xA0);
				sendbyte(0xA0);
				sendbyte(0xA0); 
			}
			else
			{
				sendbyte(0xA1);
				sendbyte(0xA1);
				sendbyte(0xA1);
				DVB_7SegShow(22222);
			}

			return u8ret;
		}
		else if((u16cmd == STX) || (u16cmd == SOH))
		{
			b8handshake = FALSE;	// stop the handshaking
			u32timeout  = 1500;		// add the timeout interval.

			//re-write>> b8xmodem1k  = (u16cmd == STX) ? TRUE : FALSE;
			if(u16cmd == STX)
			{
				b8xmodem1k = TRUE;
			}
			else
			{
				b8xmodem1k = FALSE;			
			}
			//re-write >> u16datasize = b8xmodem1k ? 1024 : 128;
			//         >> u16pktsize  = b8xmodem1k ? 1028 : 131;

			if(b8xmodem1k == TRUE)
			{
				u16datasize = 1024;
				u16pktsize = 1028; 
			}
			else
			{
				u16datasize = 128;
				u16pktsize = 131; 
			}

			// receiving a package to buffer.
			memset(pu8pktbuf, 0, 1029);
			u16cmd = readbuf(pu8pktbuf, u16pktsize, u32timeout);

			// timeout, ask resend package.
			if(u16cmd == TIMEOUT)
			{
				u16retrynum++;
				sendbyte(NAK);
			}
			// user abort, cancelled the transfer.
			else if(u16cmd == ABORT)
			{
				sendbyte(CAN);
				sendbyte(CAN);
				sendbyte(CAN);

				DVB_MemoryFree(pu8pktbuf);
				xmrecv_message(("\n\nUser abort. System canncelled transfer!!\n\n"));
				return 5;
			}
			// received package completely.
			else
			{
				// block number check failure, ask resend the package.
				if((pu8pktbuf[0] + pu8pktbuf[1]) != 0xFF)
				{
					u16retrynum++;
					sendbyte(NAK);
				}
				// unknown package block number, cannceled the transfer.
				else if(pu8pktbuf[0] != (u16blocknum & 0x00FF))
				{
					sendbyte(CAN);
					sendbyte(CAN);
					sendbyte(CAN);

					DVB_MemoryFree(pu8pktbuf);
					xmrecv_message(("\n\nInvalid block number [%02X:%02X]. System canncelled transfer!!\n\n", pu8pktbuf[0], u16blocknum & 0x00FF));
					return 5;
				}
				// this is previous package, skip it and ask send the next one.
				else if((pu8pktbuf[0] - 1) == (u16blocknum & 0x00FF))
				{
					sendbyte(ACK);
				}
				// crc check failed, ask resend the package.
				else if(xmodem_crc_check(b8xmodem1k, &pu8pktbuf[2], u16datasize) == FALSE)
				{
					u16retrynum++;
					sendbyte(NAK);
				}
				// package is correct.
				else
				{
					memcpy(pu8DramAddr + u32offset, &pu8pktbuf[2], u16datasize);

					if(u16blocknum == 1)	// check the data type in first package.
					{
						enBurnType = xmodem_burn_type(pu8DramAddr);
						if(enBurnType == EN_BURN_UNKNOWN)
						{
							sendbyte(CAN);
							sendbyte(CAN);
							sendbyte(CAN);

							sendbyte(0xA2);
							sendbyte(0xA2);
							sendbyte(0xA2);
							DVB_7SegShow(33333);

							DVB_MemoryFree(pu8pktbuf);
							xmrecv_message(("\n\nInvalid data type (%c%c%c%c%c%c%c%c). System canncelled transfer!!\n\n",
								pu8DramAddr[0], pu8DramAddr[1], pu8DramAddr[2], pu8DramAddr[3],
								pu8DramAddr[4], pu8DramAddr[5], pu8DramAddr[6], pu8DramAddr[7]));
							return 7;
						}
					}

					u32offset  += (u32)u16datasize;
					u16blocknum++;
					u16retrynum = 0;
					sendbyte(ACK);

					DVB_7SegShow(u16blocknum);
				}
			}
		}
	}

	DVB_MemoryFree(pu8pktbuf);
	return 0;
}

//========================================================================
// Marlin 20060523 Add
//========================================================================
EN_XMODEM_ERROR_TYPE XModemSendPacket(
	bool8 b8XModem1K, u32 u32Length, void (*func_getdata)(u8*,u32,u32,u32), u32 (*func_progress)(u32,u32))
{
	u16		u16datasize, u16pktsize;
	u16		u16blocknum, u16cmd, u16chksum;
	u8		*pu8pktbuf;
	u32		u32sentbytes, u32bufsize = 0;

	if(func_getdata == NULL)	return EN_XMODEM_ERR_PARAMETER;
	if(u32Length    == 0   )	return EN_XMODEM_ERR_PARAMETER;

	CT_UART_Clear_Data();

	/*
	** 1K XModem Package Format:
	**   <STX><BLK#><~BLK#><1024 bytes data><CRC_HI><CRC_LO> ==> Total 1024 + 5 bytes
	** XModem Package Format:
	**   <SOH><BLK#><~BLK#><128 bytes data><CHKSUM> ==> Total 128 + 4 bytes
	*/
	//rewrite >>	u16datasize = b8XModem1K ? 1024 : 128;
	//	      >>    u16pktsize  = b8XModem1K ? 1029 : 132;
	if(b8XModem1K == TRUE)
	{
		u16datasize = 1024;
		u16pktsize = 1029;
	}
	else
	{
		u16datasize = 128;
		u16pktsize = 132;
	} 

	
	gen_point = 311;
	pu8pktbuf = DVB_MemoryAllocate(u16pktsize);
	if(pu8pktbuf == NULL)		return EN_XMODEM_ERR_DATA;

	u16blocknum  = 1;
	u32sentbytes = 0;

	while(1)
	{
		do
		{
			u16cmd = readbyte(20000);
		} while((u16cmd != CCHR) && (u16cmd != ACK) &&
				(u16cmd != NAK ) && (u16cmd != CAN) &&
				(u16cmd != TIMEOUT) && (u16cmd != ABORT));

		if(u16cmd == ABORT)
		{
			break;
		}
		else if(u16cmd == TIMEOUT)
		{
			sendbyte(CAN);
			sendbyte(CAN);
			sendbyte(CAN);

			DVB_MemoryFree(pu8pktbuf);
			xmsend_message(("\n\nTimeout. System canncelled transfer!!\n\n"));
			return EN_XMODEM_ERR_TIMEOUT;
		}
		else if(u16cmd == CAN)
		{
			DVB_MemoryFree(pu8pktbuf);
			xmsend_message(("\n\nThe transfer is cancelled!!\n\n"));
			return EN_XMODEM_ERR_ABORT;
		}
		else if(u16cmd == CCHR)		//start sending.
		{
			u16blocknum  = 1;
			u32sentbytes = 0;

			u16cmd = ACK;	// do as what ACK command do.
		}

		if(u16cmd == ACK)	//sending package
		{
			if(u32sentbytes < u32Length)
			{
				DVB_7SegShow(u16blocknum);

				/* read one package data to buffer */
				u32bufsize = u32Length - u32sentbytes;
				if(u32bufsize > u16datasize)	u32bufsize = u16datasize;

				memset(&pu8pktbuf[3], CTRLZ, u16datasize);
				func_getdata(&pu8pktbuf[3], u32sentbytes, u32bufsize, u32Length);

				u16chksum = xmodem_cal_chksum(b8XModem1K, &pu8pktbuf[3], u16datasize);

				// fill the package header and tail to buffer.
				pu8pktbuf[1] = (u8)(u16blocknum & 0x00FF);
				pu8pktbuf[2] = ~pu8pktbuf[1];

				if(b8XModem1K)
				{
					pu8pktbuf[0] = STX;
					pu8pktbuf[3 + u16datasize] = (u8)((u16chksum & 0xFF00) >> 8);
					pu8pktbuf[4 + u16datasize] = (u8) (u16chksum & 0x00FF);
				}
				else
				{
					pu8pktbuf[0] = SOH;
					pu8pktbuf[3 + u16datasize] = (u8) (u16chksum & 0x00FF);
				}

				u16blocknum  ++;
				u32sentbytes += u32bufsize;
				u32bufsize    = u16pktsize;
				u16cmd        = NAK;
			}
			else
			{
				pu8pktbuf[0]  = EOT;
				u32bufsize    = 1;
				u16cmd        = NAK;
			}
		}

		if(u16cmd == NAK)
		{
			if(sendbuf(pu8pktbuf, u32bufsize) == ABORT)	break;

			if(func_progress)	func_progress(u32sentbytes, u32Length);

			if(pu8pktbuf[0] == EOT)
			{
				DVB_MemoryFree(pu8pktbuf);
				xmsend_message(("\n\nTransfer finished!!\n\n"));
				return EN_XMODEM_NO_ERROR;
			}
		}
	}

	/* user abort the transfer */
	if(u32sentbytes > 0)	//data had sent.
	{
		sendbyte(CAN);
		sendbyte(CAN);
		sendbyte(CAN);
	}

	DVB_MemoryFree(pu8pktbuf);
	xmsend_message(("\n\nUser abort. System canncelled transfer!!\n\n"));
	return EN_XMODEM_ERR_ABORT;
}