hal_sim.c

电子盘DEMO板程序

															
														}
													}
												}
											}
										}
									}
								}
							}
						}
					}
					DOCH_FREE( (pSimH3+bDev)->bStorage ); /* free allocated buffer */
				}/* for master and slave devices */
			}/* cfg regs written */
		}/* slave indication written */
	}
	fclose( pSimSock->pSimFile );

	return status;
#endif /*DOCH_MEMMAP_FILE*/
#else /*DOCH_RAM_SIMULATION*/
	return flOK;
#endif /*DOCH_RAM_SIMULATION*/
}/*doch_sys_release_sim()*/

/****************************************************************************** 
 *                                                                            * 
 *                   d o c h_ s y s _ g e t _ r e g X                         * 
 *                                                                            * 
 *  Reads DOCH register.                                                      * 
 *                                                                            * 
 *  Parameters :                                                              *
 *      base                 : pointer to the base of DOCH register set       *
 *      reg                  : ATA register number						      *
 *                                                                            * 
 *  Returns :                                                                 * 
 *      value of specified register                                           *
 *                                                                            * 
 ******************************************************************************/
FLByte hal_get_ata_reg_sim (volatile FLByte *base, FLSNative  reg)
{
	FLWord access16 = getSimReg(reg);

    return (FLByte)(access16);
}


FLWord hal_get_ctrl_reg_sim ( volatile FLByte * base, 
                              FLSNative         reg )
{
    return getSimReg(reg);
}

FLWord hal_read_data_16Bit_sim(DOCH_SimDevice* simDev)
{
	FLWord val;
	DOCH_SimSocket * pSimSock = getSimSocket();

#ifdef DOCH_MEMMAP_FILE
	if(pSimSock->in_regs.bStatusCommand == DOCH_VSCMD_READ_PARTITION)
	{
		FLWord readLen = 0;

		/* Read value from file */
		readLen = fread( (void*)&(val), 1, 
							sizeof(val), pSimSock->pSimFile );
		if( readLen != sizeof(val) )
			return val;
	}
	else
#endif /*DOCH_MEMMAP_FILE*/
	{
		tffscpy(&val, pSimSock->cmdBuffer.sbCurrentPosition, sizeof(val));
	}

	pSimSock->cmdBuffer.sbCurrentPosition +=2;

	return val;
}

/****************************************************************************** 
 *                                                                            * 
 *                  d o c h _ s y s _ s e t _ r e g X                         * 
 *                                                                            * 
 *  Writes DOCH register.                                                     * 
 *                                                                            * 
 *  Parameters :                                                              *
 *      base                 : pointer to the base of DOCH register set       *
 *      reg                  : ATA register number						      *
 *      val                  : value to write to register                     *
 *                                                                            * 
 *  Returns :                                                                 * 
 *      value of specified register                                           *
 *                                                                            * 
 ******************************************************************************/

void hal_set_ata_reg_sim ( volatile FLByte *   base, 
                           FLSNative           reg,
                           FLNative            val )
{
	setSimReg(reg, val);
}

void hal_set_ctrl_reg_sim ( volatile FLByte *   base, 
                         FLSNative           reg,
                         FLNative            val )
{
	setSimReg(reg, val);
}

void hal_write_data_16Bit_sim(DOCH_SimDevice* simDev, FLWord val)
{
	DOCH_SimSocket * pSimSock = getSimSocket();

#ifdef DOCH_MEMMAP_FILE
	if(pSimSock->in_regs.bStatusCommand == DOCH_VSCMD_WRITE_PARTITION)
	{
		FLWord writeLen = 0;

		/* Write value to simulation file */
		writeLen = fwrite( (void*)&(val), 1, 
						sizeof(val), pSimSock->pSimFile );
		if( writeLen != sizeof(val) )
			return;
	}
	else
#endif /*DOCH_MEMMAP_FILE*/
	{
		tffscpy(pSimSock->cmdBuffer.sbCurrentPosition, &val, sizeof(val));
	}

	pSimSock->cmdBuffer.sbCurrentPosition +=2;
}


/****************************************************************************** 
 *                                                                            * 
 *                  d o c h _ s y s _ b l k _ r e a d                         * 
 *                                                                            * 
 *  Read 'sectors' sectors from DOCH										  *
 *                                                                            * 
 *  Parameters :                                                              *
 *      base                 : pointer to the base of DOCH register set       *
 *      buf                  : buffer to read to                              *
 *      sectors              : number of sectors to read					  *
 *                                                                            * 
 *  Returns :                                                                 * 
 *      always zero (success)                                                 *
 *                                                                            * 
 ******************************************************************************/

FLSNative hal_blk_read_sim ( volatile FLByte   * base, 
							 FLByte            * buf, 
							 FLSNative           sectors )
{
	FLSNative  rc = 0;
	register int i;
    FLWord          * buf16 = (FLWord *) buf;
	DOCH_Socket* pdev;
	DOCH_SimDevice			* simDev;
	DOCH_SimSocket* simSocket = getSimSocket();
	FLSNative ata_dev = simSocket->selDevNum;

	DOCH_get_socket(pdev, 0);

	/*If socket is not registered, return error*/
	if(pdev == NULL)
		return DOCH_DiskNotFound;

	simDev = getSimDev(ata_dev);

    /* use 16-bit access */
	/* retrieve data */
	for(i=0; i<((sectors << DOCH_SECTOR_SIZE_BITS)/2); i++)
	{
		/*Protect against reading too much data !!!*/
		if((i*2) >= simSocket->cmdBuffer.nBufferLen)
			return -1;
		buf16[i] = hal_read_data_16Bit_sim(simDev);
	}

	if(/*(simSocket->cmdBuffer.nBufferLen + simSocket->cmdBuffer.sbBuffer) */
		simSocket->cmdBuffer.sbPositionToReach
		== simSocket->cmdBuffer.sbCurrentPosition)
		rc = doch_sim_finish_data_xfer(simSocket);

    return rc;
}




/****************************************************************************** 
 *                                                                            * 
 *                  d o c h _ s y s _ b l k _ w r i t e                       * 
 *                                                                            * 
 *  Write 'sectors' sectors to DOCH											  *
 *                                                                            * 
 *  Parameters :                                                              *
 *      base                 : pointer to the base of DOCH register set       *
 *      buf                  : buffer to write from                           *
 *      sectors              : number of sectors to write					  *
 *                                                                            * 
 *  Returns :                                                                 * 
 *      always zero (success)                                                 *
 *                                                                            * 
 ******************************************************************************/

FLSNative hal_blk_write_sim ( volatile FLByte * base, 
							  FLByte          * buf, 
							  FLSNative         sectors )
{
	FLSNative  rc = 0;
	register int i;
    FLWord          * buf16 = (FLWord *) buf;
	DOCH_Socket* pdev;
	DOCH_SimDevice			* simDev;
	DOCH_SimSocket* simSocket = getSimSocket();
	FLSNative ata_dev = simSocket->selDevNum;

	DOCH_get_socket(pdev, 0);

	/*If socket is not registered, return error*/
	if(pdev == NULL)
		return DOCH_DiskNotFound;

	simDev = getSimDev(ata_dev);

    /* use 16-bit access */
	/* write data */
	for(i=0; i<((sectors << DOCH_SECTOR_SIZE_BITS)/2); i++)
	{
		/*Protect against reading too much data !!!*/
		if((i*2) >= simSocket->cmdBuffer.nBufferLen)
			return -1;
		hal_write_data_16Bit_sim(simDev, buf16[i]);
	}

	if(/*(simSocket->cmdBuffer.nBufferLen + simSocket->cmdBuffer.sbBuffer) */
		simSocket->cmdBuffer.sbPositionToReach
		== simSocket->cmdBuffer.sbCurrentPosition)
		rc = doch_sim_finish_data_xfer(simSocket);

    return rc;
}


#ifdef __cplusplus
}
#endif