doch_api.c

H3 M-system NAND flash driver in Linux OS, M-DOC driver

		DBG_PRINT_ERR(FLZONE_API, "\r\n");

		return rc;
	}

	/*Update feedback values*/
	/*----------------------*/
	*sectorsPerformed += out_regs->bSectorCount;

	/*For next possible cycle*/
	/*-----------------------*/
	*sectorNumber += sectorsToPerfrom;
	*totalNumOfSectors -= sectorsToPerfrom;
	*buf_offset += sectorsToPerfrom * DOCH_SECTOR_SIZE;

	return DOCH_OK;
}

#ifdef DOCH_BIG_ENDIAN
/****************************************************************************** 
 *                                                                            * 
 *                            be _ s h o r t                                  * 
 *                            be _ l o n g                                    * 
 *                                                                            * 
 *  Little-to-CPU-native integer conversion routines for big-endian CPUs.     *
 *                                                                            * 
 *  Parameters :                                                              *
 *      v                    : correctly aligned little endian value          *
 *  Returns :                                                                 * 
 *      value in CPU native format                                            *
 *                                                                            * 
 ******************************************************************************/

static 
FLWord be_FLWord  (FLByte * v)
{
    register FLWord x = *((FLWord *)v);
    return ((x >> 8) | (x << 8));
}

static
FLDword be_FLDword (FLByte * v)
{
    register FLDword x = *((FLDword *)v);
    return ((x >> 24) | ((x >> 8) & 0x0000ff00) | 
                        ((x << 8) & 0x00ff0000) | (x << 24));
}
#endif /*DOCH_BIG_ENDIAN*/

/******************************************************************************/
/*
 *	DOCH SDK API Routines
 */
/******************************************************************************/

/*----------------------------------------------------------------------*/
/*						b d C a l l D O C H								*/
/*                                                                      */
/* Performs needed general operations before calling actual function	*/
/* Calls appropriate DOCH function										*/
/*                                                                      */
/* Parameters:                                                          */
/*        functionNo	: DOCH SDK function to run	                    */
/*        ioreq			: DOCH ioreq structure	                        */
/*                                                                      */
/* Returns:                                                             */
/*        DOCH_Error      : 0 on success, otherwise failed              */
/*----------------------------------------------------------------------*/
DOCH_Error bdCallDOCH(FLSNative functionNo, IOreq FAR2 *ioreq)
{
	DOCH_Error rc;
	
#ifdef CHECK_POWER_ON_EVERY_COMMAND
	/* gDeviceTurnedOff will be updated by API routines*/
	gDeviceTurnedOff = FALSE;
#endif /*CHECK_POWER_ON_EVERY_COMMAND*/

	/*If ETFFS wasnt identified, prevent using bdCallDOCH()*/
	if(!sockets[DOCH_GET_SOCKET_FROM_IOREQ_HANDLE(ioreq)].device[0].ETFFS_Identified)
		return DOCH_FeatureNotSupported;

   /* Take mutex for current device */
   rc = dochSetMutex(DOCH_GET_SOCKET_FROM_IOREQ_HANDLE(ioreq),
					 DOCH_ON,
					 DOCH_GET_PARTITION_FROM_IOREQ_HANDLE(ioreq));
   if(rc != DOCH_OK)
   {
		DBG_PRINT_ERR(FLZONE_API, "bdCallDOCH(): dochSetMutex failed with status: ");
		DBG_PRINT_ERR_PRM(FLZONE_API, (FLTXT("0x%x \r\n"), rc));
		return rc;
   }

   /*Check if requested operation is wither Read or Write which are performance critical
     (All other operations are directed from within the switch case)
     -------------------------------------------------------------*/
	if(functionNo == SDK_READ_PARTITION_SECTORS)
	{
		rc = DOCHReadPartitionSectors(ioreq);
	}
	else if (functionNo == SDK_WRITE_PARTITION_SECTORS)
	{
		rc = DOCHWritePartitionSectors(ioreq);
	}
	else
	{
	  /*Branch to appropriate DOCH routine according to function#*/
	  /*---------------------------------------------------------*/
	  switch (functionNo) 
	  {
			/*Get Info*/
		  case SDK_IDENTIFY_DISKONCHIP_DEVICE:
			  rc = DOCHIdentifyDiskOnChipDevice(ioreq);
			  break;

		  case SDK_GET_RESET_STATUS:
			  rc = DOCHGetResetStatus(ioreq);
			  break;

		  case SDK_NOTIFY_RESET:
			  rc = DOCHNotifyReset(ioreq);
			  break;

		  case SDK_NOTIFY_PLATFORM_RESUMED:
			  rc = DOCHNotifyPlatformResumed(ioreq);
			  break;

		  case SDK_GET_PARTITION_INFO:
			  rc = DOCHPartitionInfo(ioreq);
			  break;

		  case SDK_SET_DISK_USER_ATTR:
			  rc = DOCHSetDiskUserAttributes(ioreq);
			  break;

		  case SDK_GET_DISK_USER_ATTR:
			  rc = DOCHGetDiskUserAttributes(ioreq);
			  break;

		  case SDK_GET_CONFIG_DATA:
			  rc = DOCHGetConfigurationData(ioreq);
			  break;

		  case SDK_SET_CONFIG_DATA:
			  rc = DOCHSetConfigurationData(ioreq);
			  break;

			/*Media*/
		  case SDK_SET_DEFAULT_PARTITION:
			  rc = DOCHSetDefaultPartition(ioreq);
			  break;

		  case SDK_SET_DATA_XFER_MODE:
			  rc = DOCHSetDataTransferMode(ioreq);
			  break;

		  case SDK_OPTIMIZE_MEDIA:
			  rc = DOCHOptimizeMedia(ioreq);
			  break;

		  case SDK_DELETE_PARTITIONS:
			  rc = DOCHDeletePartitions(ioreq);
			  break;

		  case SDK_ADD_PARTITION:
			  rc = DOCHAddPartition(ioreq);
			  break;

		  case SDK_UNFORMAT_DEVICE:
			  rc = DOCHUnformatDevice(ioreq);
			  break;

		  case SDK_WRITE_IPL:
			  rc = DOCHWriteIPL(ioreq);
			  break;

		  case SDK_READ_IPL:
			  rc = DOCHReadIPL(ioreq);
			  break;

			/*IO*/
		  case SDK_WRITE_AND_LOCK:
			  rc = DOCHWriteAndLock(ioreq);
			  break;

		  case SDK_WIPE_SECTORS:
			  rc = DOCHWipeSectors(ioreq);
			  break;

		  case SDK_FREE_SECTORS:
			  rc = DOCHFreeSectors(ioreq);
			  break;

		  case SDK_PREPARE_FOR_WRITE:
			  rc = DOCHPrepareForWrite(ioreq);
			  break;

#if 0
			/*Flexi-Flash*/
		  case SDK_WRITE_FLEXI_FAST:	
			  rc = DOCHWriteFlexiFast(ioreq);
			  break;
			  
		  case SDK_WRITE_FLEXI_NORMAL:	
			  rc = DOCHWriteFlexiNormal(ioreq);
			  break;
			  
		  case SDK_REWRITE_FLEXI_NORMAL:
			  rc = DOCHReWriteFlexiNormal(ioreq);
			  break;
#endif /*0*/
			  
			/*Protection*/
		  case SDK_ACCESS_PART_WITH_PWD:
			  rc = DOCHAccessPartWithPwd(ioreq);
			  break;
			  
		  case SDK_DISABLE_PART_ACCESS:	
			  rc = DOCHDisablePartAccess(ioreq);
			  break;
			  
		  case SDK_SET_PART_PROTECTION:	
			  rc = DOCHSetParitionProtection(ioreq);
			  break;

#if 0
			/*PKI*/
		  case SDK_PKI_HOST:
			  rc = DOCHSendHostPublicKey(ioreq);
			  break;
			  
		  case SDK_PKI_DOCH:
			  rc = DOCHReceiveDochPublicKey(ioreq);
			  break;
			  
		  case SDK_PKI_VERIFY_HOST_KEY:	
			  rc = DOCHVerifyHostKey(ioreq);
			  break;
#endif /*0*/

			/*Custom Parameters*/
		  case SDK_GET_CUSTOM_PARAM:
			  rc = DOCHGetCustomParameter(ioreq);
			  break;
			  
		  case SDK_SET_CUSTOM_PARAM:
			  rc = DOCHSetCustomParameter(ioreq);
			  break;

#if 0
			/*Atomic Read/Write Sequence*/
		  case SDK_ATOMIC_WRITE_SEQ:
			  rc = DOCHManageAtomicWriteSeq(ioreq);
			  break;

			/*Algorithms*/
		  case SDK_REPORT_SUPP_ALG:	
			  rc = DOCHReportSupportedAlgorithms(ioreq);
			  break;
			  
		  case SDK_REPORT_ALG_CAPAB:
			  rc = DOCHGetAlgorithmCapabilities(ioreq);
			  break;
			  
		  case SDK_SET_ALG_MODE:
			  rc = DOCHSetAlgorithmMode(ioreq);
			  break;

			/*Hash*/
		  case SDK_AUTO_HASH_CTRL:
			  rc = DOCHAutoHashControl(ioreq);
			  break;
			  
		  case SDK_READ_CALC_HASH:
			  rc = DOCHReadCalculatedHash(ioreq);
			  break;

		  case SDK_WRITE_CALC_HASH:
			  rc = DOCHWriteCalculatedHash(ioreq);
			  break;
			  
		  case SDK_READ_ORIG_HASH:
			  rc = DOCHReadOriginalHash(ioreq);
			  break;
			  
		  case SDK_WRITE_GIVEN_HASH:
			  rc = DOCHWriteGivenHash(ioreq);
			  break;
			  
		  case SDK_START_HASH_STREAM_CALC:
			  rc = DOCHStartHashStreamCalculation(ioreq);
			  break;
			  
		  case SDK_READ_HASH_STREAM_CALC:
			  rc = DOCHReadStopHashStreamCalc(ioreq);
			  break;
			  
		  case SDK_RETURN_RAND_NUMS:
			  rc = DOCHReturnRandomNumbers(ioreq);
			  break;
			  
		  case SDK_SET_HASH_KEY:
			  rc = DOCHSetHashKey(ioreq);
			  break;

#endif /*0*/

			/*General*/
		  case SDK_SET_PART_USER_ATTR:
			  rc = DOCHSetParitionUserAttributes(ioreq);
			  break;

		  case SDK_GET_PART_USER_ATTR:
			  rc = DOCHGetParitionUserAttributes(ioreq);
			  break;

		  case SDK_SET_POWER_MODE:
			  rc = DOCHSetPowerMode(ioreq);
			  break;

		  case SDK_GET_POWER_MODE:
			  rc = DOCHGetPowerMode(ioreq);
			  break;

		  case SDK_HW_CONFIG:
			  rc = DOCHConfigHW(ioreq);
			  break;

		  case SDK_RECOVER_FROM_POWER_LOSS:
			  rc = DOCHRecoverFromPowerLoss(ioreq);
			  break;

		  case SDK_CLEAR_ATA_INTERRUPT:
			  rc = DOCHClearIRQ(ioreq);
			  break;

		  case SDK_GET_PHYSICAL_ADDRESS:
			  rc = DOCHGetPhysicalAddress(ioreq);
			  break;
			  
		  default:
			  rc = DOCH_FeatureNotSupported;
			  break;
		}
	}

#ifdef DOCH_AUTO_DPD_BY_HOST
	if(gAutoDPDByHost == DOCH_GLOBAL_BOOL_PATTERN)
	{
		FLDword tries;
		DOCH_Socket*  pdev;
		FLDword i;
		FLByte status;
		DOCH_get_socket(pdev, DOCH_GET_SOCKET_FROM_IOREQ_HANDLE(ioreq));

		/*Protect against access time set to 0*/
		if(gDochAccessNanosec == 0)
		{
		  /* Free mutex for current device */
		   dochSetMutex(DOCH_GET_SOCKET_FROM_IOREQ_HANDLE(ioreq),
						DOCH_OFF,
						DOCH_GET_PARTITION_FROM_IOREQ_HANDLE(ioreq));

			return DOCH_BadParameter;
		}
		tries = (DOCH_SHORT_WAIT * (1000000UL / gDochAccessNanosec));