bluraycps.c

Sigma SMP8634 Mrua v. 2.8.2.0

		cps_context->bdplus_disabled = TRUE;
	}
	
	if (aacs_flags & AACS_PASSTHROUGH )
		cps_context->aacs_passthrough = TRUE;
	
	if((flags & CPS_FLAGS_LAYER_MASK) == CPS_FLAGS_DUAL_LAYER)
			cps_context->media_info_bits_0 |= SPDC_MEDIAINFOBITS0_DUAL_LAYER;

	cps_context->aacs_context = aacs_instantiate(cps_context->aacs,
	                                            aacs_flags, 
	                                            &g_aacs_callbacks,
	                                            cps_context);
	if (cps_context->aacs_context == NULL) {
		RMDBGLOG((ENABLE, "AACS Media Initialize Failed (instantiation)\n"));
		return RM_ERROR;
	}

	if (!cps_context->aacs_passthrough) {
		RMstatus status;
		status = aacs_authenticate(cps_context->aacs_context);
		if (RMFAILED(status)) {
			RMDBGLOG((ENABLE, "AACS Media Initialize Failed (authentication)\n"));
			return RM_ERROR;
		}
	}
	
	if (cps_context->svm!=NULL && !cps_context->bdplus_disabled) {
		/* Do BD+ stuff */
		union SVMINTRP Intrp;
		RMstatus err;

		Intrp.initmedia.InterruptID=INTRP_InitializeMedia;
		
		err = do_svm_interrupt(cps_context, &Intrp);
		if (RMFAILED(err)){
			if (cps_context->extended_bdplus_check && 
			    media_type != CPS_FLAGS_MEDIA_TYPE_BD_ROM) {
				RMDBGLOG((ENABLE,"SVM Interrupt failed!  BD+ extended check for non-BDROM "
				                 "enabled, continuing w/ disabled BD+!\n"));
				cps_context->bdplus_disabled = TRUE;
			}
			else {
				RMDBGLOG((ENABLE,"SVM Interrupt Failed!\n"));
				return err;
			}
		}
	}

	return RM_OK;
}

RMstatus cps_media_finalize(struct cps_context_s *cps_context)
{
	RMstatus err = RM_OK;

	if (cps_context->svm!=NULL && !cps_context->bdplus_disabled) {
		/* Do BD+ stuff */
		union SVMINTRP Intrp;
		RMstatus err;
		
		Intrp.shutdown.InterruptID=INTRP_Shutdown;
		
		err = do_svm_interrupt(cps_context, &Intrp);
		if (RMFAILED(err)){
			RMDBGLOG((ENABLE,"SVM Interrupt Failed!\n"));
			return err;
		}
	}
	
	err = aacs_finalize(cps_context->aacs_context);
	
	return err;

}

RMstatus cps_content_revocation(struct cps_context_s *cps_context)
{
	if (!cps_context->aacs_passthrough) {
		return aacs_content_revocation(cps_context->aacs_context);
	}
	else
		return RM_OK;
}

RMstatus cps_title_ready(struct cps_context_s *cps_context,
			 RMuint32 title_id,
			 struct aacs_cci_info **aacs_cci)
{
	RMstatus status;
	RMuint8 basic_cci[AACS_BCCI_SIZE];

	if (cps_context->svm!=NULL && !cps_context->bdplus_disabled) {
		/* Do BD+ Title Initialize */
		union SVMINTRP Intrp;
		
		Intrp.inittitle.InterruptID=INTRP_InitializeTitle;
		Intrp.inittitle.TitleNumber=title_id;

		status = do_svm_interrupt(cps_context, &Intrp);
		if (RMFAILED(status)){
			return status;
		}
	}
	
	if (!cps_context->aacs_passthrough) {
		status = aacs_title_ready(cps_context->aacs_context, title_id, basic_cci);
		if( RMFAILED(status) )
			return status;

		if (NULL != aacs_cci) {
			*aacs_cci = aacs_bcci2rmcci(basic_cci);
			if(*aacs_cci == NULL )
				return RM_ERROR;
		}
	}

	return RM_OK;

}

RMstatus cps_clip_ready(struct cps_context_s *cps_context, RMuint16 clip_id, RMuint8 bd_directory,
		struct aacs_cci_info **aacs_cci) {
	RMstatus status;
	RMuint8 cci[AACS_SCCI_SIZE];

	if (!cps_context->aacs_passthrough) {
		status = aacs_clip_ready(cps_context->aacs_context, clip_id, bd_directory, cci);
		if (RMFAILED(status)) {
			return status;
		}

		if (NULL != aacs_cci) {
			*aacs_cci = aacs_scci2rmcci(cci);
			if (NULL == *aacs_cci) {
				return RM_ERROR;
			}
		}
	}

	return RM_OK;
}

RMstatus cps_clips_ready(struct cps_context_s *cps_context, struct clip_info *clip_info, 
		RMuint32 no_clips) {
	RMstatus status;
	
	if (!cps_context->aacs_passthrough) {
		status = aacs_clips_ready(cps_context->aacs_context, clip_info, no_clips);
		if (RMFAILED(status)) {
			return status;
		}		
	}

	return RM_OK;
}

RMstatus cps_decrypt_thumbnail(struct cps_context_s *cps_context,
		enum bdav_tn_type tn_type,
		RMuint8 bd_directory,
		RMuint8 *tn_sub_in,
		RMuint8 *tn_sub_out,
		RMuint32 n_tn_sub,
		struct aacs_cci_info **aacs_cci) {
	RMstatus status = RM_OK;
	RMuint8 cci[AACS_BCCI_SIZE];

	if (!cps_context->aacs_passthrough) {
		status = aacs_decrypt_thumbnail(cps_context->aacs_context, tn_type, bd_directory,
				tn_sub_in, tn_sub_out, n_tn_sub, cci);
		if (RMFAILED(status)) {
			RMDBGLOG((ENABLE, "Error: failed to decrypt thumbnail data.\n"));
		}
		else {
			if (NULL != aacs_cci) {
				*aacs_cci = aacs_scci2rmcci(cci);
				if (NULL == *aacs_cci) {
					RMDBGLOG((ENABLE, "Error: failed to convert CCI "
								"information.\n"));
					status = RM_ERROR;
				}
			}
		}
	}
	else {
		RMDBGLOG((ENABLE, "Warning: called, but AACS is disabled. Doing nothing.\n"));
	}
	return status;
}

RMstatus cps_bd_segment_ready(struct cps_context_s *cps_context,
			      RMuint16 sp_id, RMuint32 clip_id, RMuint8 slot_id)
{
	if (cps_context->svm!=NULL && !cps_context->bdplus_disabled) {
		/* Do BD+ Compute SP */
		union SVMINTRP Intrp;
		RMstatus err;

		Intrp.computesp.InterruptID=INTRP_ComputeSP;
		Intrp.computesp.ClipID=clip_id;
		Intrp.computesp.SP_ID=sp_id;
		
		err = do_svm_interrupt(cps_context, &Intrp);
		if (RMFAILED(err)){
			return err;
		}
		
		if (cps_context->aacs_context) {
			return aacs_set_sp(cps_context->aacs_context, slot_id, clip_id, sp_id,
			                   Intrp.computesp.SP, Intrp.computesp.FM_ID);
		}
		return RM_OK;
	}
	
	return RM_ERROR;
}

RMstatus cps_get_aacs_psr(struct cps_context_s *cps_context,
			  RMuint32 psr,
			  RMuint32 *psr_value)
{
	if (!cps_context->aacs_passthrough) {
		return aacs_get_psr(cps_context->aacs_context, psr, psr_value);
	}
	return RM_ERROR;
}

RMstatus cps_get_bdj_hash(struct cps_context_s *cps_context,
		          RMuint16 *aid, RMuint32 *csn, RMuint8 *hash)
{
	if (!cps_context->aacs_passthrough) {
		return aacs_get_bdj_hash(cps_context->aacs_context, aid, csn, hash);
	}
	return RM_ERROR;
}

RMstatus cps_bdp_psr_update(struct cps_context_s *cps_context,
			    RMuint32 resource)
{
	if (cps_context->svm!=NULL && !cps_context->bdplus_disabled) {
		/* Do BD+ Application Layer */
		union SVMINTRP Intrp;
		RMstatus err;

		Intrp.applayer.InterruptID=INTRP_ApplicationLayer;
		Intrp.applayer.Resource=resource;

		err = do_svm_interrupt(cps_context, &Intrp);
		return err;
	}
	
	return RM_NOTIMPLEMENTED;
}

RMstatus cps_bdp_run_vm(struct cps_context_s *cps_context,
			RMint32 *cycles)
{
	if (cps_context->svm!=NULL && !cps_context->bdplus_disabled) {
		/* Give more cycles to the BD+ VM Background process*/
		return do_svm_background(cps_context, cycles);
	}
	return RM_OK;
}

RMstatus term_cps(struct cps_context_s *cps_context)
{
	RMstatus rc = RM_OK;
	// Sanity check:
	if(cps_context!=&g_cps_context) 
		return RM_ERROR;

	/* TODO : Check out error handling */
	if (cps_context->svm!=NULL) {
		rc=SVM_Term(cps_context->svm);
	}
	g_cps_context.callbacks = NULL;

	if (cps_context->aacs) {
		rc=aacs_close(cps_context->aacs);
	}
	return rc;
}

/**
 * Get decryption information
 *
 * @param cps_context - cps_context initialized with init_cps
 * @param xtask_pid - returned PID of the xtask
 * @param cookie - decryption cookie, returned
 * @return RM_OK on success, RM_ERROR on error and aacs_error is set
 */
RMstatus cps_get_decrypt_info(struct cps_context_s *cps_context,
			      RMuint32 *xtask_pid, void **cookie)
{
	if (cps_context->aacs_context) {
		return aacs_get_decrypt_info(cps_context->aacs_context, xtask_pid, cookie);
	}

	return RM_NOTIMPLEMENTED;
}

/**
 * Enable BD+ extended support 
 *
 * Enables extended authentication and use of BD+ for non BDROM media
 * (Enabled by default)
 *
 * @param cps_context - cps_context initialized with init_cps
 * @param enable - Boolean value where TRUE enables extended BD+ check.
 * @return RM_OK on success, RM_ERROR on parameter error.
 */
RMstatus cps_enable_extended_bdplus(struct cps_context_s *cps_context,
                                 RMbool enable)
{
	if (!cps_context) {
		return RM_ERROR;
	}
	cps_context->extended_bdplus_check = enable;
	return RM_OK;
}