void test_mutability()
{
GstStructure *s1;
GstCaps *c1;
gint ret;
//xmlfile = "test_mutability";
std_log(LOG_FILENAME_LINE, "Test Started test_mutability");
c1 = gst_caps_new_any ();
s1 = gst_structure_from_string ("audio/x-raw-int,rate=44100", NULL);
gst_structure_set (s1, "rate", G_TYPE_INT, 48000, NULL);
gst_caps_append_structure (c1, s1);
gst_structure_set (s1, "rate", G_TYPE_INT, 22500, NULL);
gst_caps_ref (c1);
ASSERT_CRITICAL (gst_structure_set (s1, "rate", G_TYPE_INT, 11250, NULL));
fail_unless (gst_structure_get_int (s1, "rate", &ret));
fail_unless (ret == 22500);
ASSERT_CRITICAL (gst_caps_set_simple (c1, "rate", G_TYPE_INT, 11250, NULL));
fail_unless (gst_structure_get_int (s1, "rate", &ret));
fail_unless (ret == 22500);
gst_caps_unref (c1);
gst_structure_set (s1, "rate", G_TYPE_INT, 11250, NULL);
fail_unless (gst_structure_get_int (s1, "rate", &ret));
fail_unless (ret == 11250);
gst_caps_set_simple (c1, "rate", G_TYPE_INT, 1, NULL);
fail_unless (gst_structure_get_int (s1, "rate", &ret));
fail_unless (ret == 1);
gst_caps_unref (c1);
std_log(LOG_FILENAME_LINE, "Test Successful");
create_xml(0);
}
struct i2c_engine *dal_i2c_sw_engine_dce110_create(
const struct i2c_sw_engine_dce110_create_arg *arg)
{
struct i2c_sw_engine_dce110 *engine_dce110;
if (!arg) {
ASSERT_CRITICAL(false);
return NULL;
}
engine_dce110 = dm_alloc(sizeof(struct i2c_sw_engine_dce110));
if (!engine_dce110) {
ASSERT_CRITICAL(false);
return NULL;
}
if (construct(engine_dce110, arg))
return &engine_dce110->base.base;
ASSERT_CRITICAL(false);
dm_free(engine_dce110);
return NULL;
}
struct i2c_engine *dal_i2c_hw_engine_dce110_create(
const struct i2c_hw_engine_dce110_create_arg *arg)
{
struct i2c_hw_engine_dce110 *engine_dce10;
if (!arg) {
ASSERT_CRITICAL(false);
return NULL;
}
if (!arg->reference_frequency) {
ASSERT_CRITICAL(false);
return NULL;
}
engine_dce10 = kzalloc(sizeof(struct i2c_hw_engine_dce110),
GFP_KERNEL);
if (!engine_dce10) {
ASSERT_CRITICAL(false);
return NULL;
}
construct(engine_dce10, arg);
return &engine_dce10->base.base;
}
static bool construct(
struct hw_hpd_dce110 *pin,
enum gpio_id id,
uint32_t en,
struct dc_context *ctx)
{
const struct hw_gpio_generic_dce110_init *init;
if (id != GPIO_ID_HPD) {
ASSERT_CRITICAL(false);
return false;
}
if ((en < GPIO_HPD_MIN) || (en > GPIO_HPD_MAX)) {
ASSERT_CRITICAL(false);
return false;
}
if (!dal_hw_hpd_construct(&pin->base, id, en, ctx)) {
ASSERT_CRITICAL(false);
return false;
}
pin->base.base.base.funcs = &funcs;
init = hw_gpio_generic_dce110_init + en;
pin->base.base.pin_reg = init->hw_gpio_data_reg;
pin->addr = init->addr;
return true;
}
/* audio_dce110 is derived from audio directly, not via dce80 */
struct hw_ctx_audio *dal_hw_ctx_audio_dce110_create(
struct dal_context *dal_context,
uint32_t azalia_stream_id)
{
/* allocate memory for struc hw_ctx_audio_dce110 */
struct hw_ctx_audio_dce110 *hw_ctx_dce110 =
dal_alloc(sizeof(struct hw_ctx_audio_dce110));
if (!hw_ctx_dce110) {
ASSERT_CRITICAL(hw_ctx_dce110);
return NULL;
}
/*return pointer to hw_ctx_audio back to caller -- audio object */
if (construct(
hw_ctx_dce110, azalia_stream_id, dal_context))
return &hw_ctx_dce110->base;
dal_logger_write(
dal_context->logger,
LOG_MAJOR_ERROR,
LOG_MINOR_COMPONENT_AUDIO,
"Failed to create hw_ctx_audio for DCE11\n");
dal_free(hw_ctx_dce110);
return NULL;
}
bool dce112_clk_src_construct(
struct dce112_clk_src *clk_src,
struct dc_context *ctx,
struct dc_bios *bios,
enum clock_source_id id,
const struct dce112_clk_src_reg_offsets *reg_offsets)
{
struct firmware_info fw_info = { { 0 } };
clk_src->base.ctx = ctx;
clk_src->bios = bios;
clk_src->base.id = id;
clk_src->base.funcs = &dce112_clk_src_funcs;
clk_src->offsets = *reg_offsets;
if (clk_src->bios->funcs->get_firmware_info(
clk_src->bios, &fw_info) != BP_RESULT_OK) {
ASSERT_CRITICAL(false);
goto unexpected_failure;
}
clk_src->ext_clk_khz = fw_info.external_clock_source_frequency_for_dp;
return true;
unexpected_failure:
return false;
}
struct graphics_object_id wireless_get_src_obj_id(
struct adapter_service *as,
struct graphics_object_id id,
uint8_t index)
{
if (index < wireless_get_srcs_num(as, id)) {
switch (id.type) {
case OBJECT_TYPE_CONNECTOR:
return dal_graphics_object_id_init(
ENCODER_ID_INTERNAL_WIRELESS,
ENUM_ID_1,
OBJECT_TYPE_ENCODER);
break;
case OBJECT_TYPE_ENCODER:
return dal_graphics_object_id_init(
0,
ENUM_ID_1,
OBJECT_TYPE_GPU);
break;
default:
ASSERT_CRITICAL(false);
break;
}
}
return dal_graphics_object_id_init(
0,
ENUM_ID_UNKNOWN,
OBJECT_TYPE_UNKNOWN);
}
static void
check_wrapped (gpointer data)
{
GstGLContext *wrapped_context = data;
GError *error = NULL;
gint i = 0;
gboolean ret;
/* check that scheduling on an unactivated wrapped context asserts */
ASSERT_CRITICAL (gst_gl_context_thread_add (wrapped_context,
(GstGLContextThreadFunc) accum_true, &i));
fail_if (i != 0);
/* check that scheduling on an activated context succeeds */
gst_gl_context_activate (wrapped_context, TRUE);
gst_gl_context_thread_add (wrapped_context,
(GstGLContextThreadFunc) accum_true, &i);
fail_if (i != 1);
/* check filling out the wrapped context's info */
fail_if (wrapped_context->gl_vtable->TexImage2D != NULL);
ret = gst_gl_context_fill_info (wrapped_context, &error);
fail_if (!ret, "error received %s\n",
error ? error->message : "Unknown error");
fail_if (wrapped_context->gl_vtable->TexImage2D == NULL);
gst_gl_context_activate (wrapped_context, FALSE);
}
/**
* Clears all cached information about subsets
* supported. We keep information about
* supporting single displays separately,
* and there may be no need to wipe that cache too.
*
* \param
* [in] singles_too : whether to invalidate
* the cache keeping info about individual displays
*/
void dal_invalidate_subsets_cache(
struct tm_subsets_cache *tm_subset_cache,
bool singles_too)
{
uint32_t cache_size_in_bytes;
if (tm_subset_cache->cofunc_cache == NULL) {
ASSERT_CRITICAL(0);
return;
}
/* need 2 bits per combination, also need
* to align to the size of uint32_t
* e.g. 53 combinations require 106 bits,
* this is 53/4 = 106/8 = 13.25, rounded down
* by default to 13 so we add 1 byte to get 14
*/
/* but because we store in uint32_t* we
* actually need 16 bytes assuming 32/64-bit int
*/
cache_size_in_bytes = sizeof(uint32_t) *
(1 + tm_subset_cache->max_num_combinations/
(4 * sizeof(uint32_t)));
dal_memset(tm_subset_cache->cofunc_cache, 0, cache_size_in_bytes);
tm_subset_cache->all_connected_supported = CQR_UNKNOWN;
if (singles_too) {
tm_subset_cache->cofunc_cache_single = 0;
tm_subset_cache->cofunc_cache_single_valid = 0;
}
}
static unsigned int pixel_format_to_bpp(enum surface_pixel_format format)
{
switch (format) {
case SURFACE_PIXEL_FORMAT_VIDEO_420_YCbCr:
case SURFACE_PIXEL_FORMAT_VIDEO_420_YCrCb:
return 12;
case SURFACE_PIXEL_FORMAT_GRPH_ARGB1555:
case SURFACE_PIXEL_FORMAT_GRPH_RGB565:
case SURFACE_PIXEL_FORMAT_VIDEO_420_10bpc_YCbCr:
case SURFACE_PIXEL_FORMAT_VIDEO_420_10bpc_YCrCb:
return 16;
case SURFACE_PIXEL_FORMAT_GRPH_ARGB8888:
case SURFACE_PIXEL_FORMAT_GRPH_ABGR8888:
case SURFACE_PIXEL_FORMAT_GRPH_ARGB2101010:
case SURFACE_PIXEL_FORMAT_GRPH_ABGR2101010:
return 32;
case SURFACE_PIXEL_FORMAT_GRPH_ARGB16161616:
case SURFACE_PIXEL_FORMAT_GRPH_ARGB16161616F:
case SURFACE_PIXEL_FORMAT_GRPH_ABGR16161616F:
return 64;
default:
ASSERT_CRITICAL(false);
return -1;
}
}
struct audio *dce_audio_create(
struct dc_context *ctx,
unsigned int inst,
const struct dce_audio_registers *reg,
const struct dce_audio_shift *shifts,
const struct dce_aduio_mask *masks
)
{
struct dce_audio *audio = kzalloc(sizeof(*audio), GFP_KERNEL);
if (audio == NULL) {
ASSERT_CRITICAL(audio);
return NULL;
}
audio->base.ctx = ctx;
audio->base.inst = inst;
audio->base.funcs = &funcs;
audio->regs = reg;
audio->shifts = shifts;
audio->masks = masks;
return &audio->base;
}
static void
_test_query_timestamp_gl (GstGLContext * context, gpointer data)
{
GstGLQuery q2;
gst_gl_query_init (&q2, context, GST_GL_QUERY_TIMESTAMP);
/* GST_GL_QUERY_TIMESTAMP doesn't supported start()/end() */
ASSERT_CRITICAL (gst_gl_query_start (&q2));
ASSERT_CRITICAL (gst_gl_query_end (&q2));
gst_gl_query_counter (&q2);
gst_gl_query_result (&q2);
gst_gl_query_unset (&q2);
}
/**
* Returns (n choose k).
* For k<=3 we do direct computation, and for
* k>3 we use the cached values stored in
* m_pBinomCoeffs and created in
* computeBinomCoeffs at class initialization
*
* \param [in] n
* \param [in] k
*
* \return
* (n choose k)
*/
static uint32_t get_binom_coeff(
struct tm_subsets_cache *tm_subsets_cache,
uint32_t n,
uint32_t k)
{
/* use direct formula for 0-3 as it's
* more efficient and doesn't use caching space
* for all others, use cache
*/
if (k > n)
return 0;
if (k == n || k == 0)
return 1;
if (k == 1)
return n;
if (k == 2)
return n*(n-1)/2;
if (k == 3)
return n*(n-1)*(n-2)/6;
/* should not happen*/
if (tm_subsets_cache->binom_coeffs == NULL) {
ASSERT_CRITICAL(0);
return 0;
}
/* read from table*/
return tm_subsets_cache->binom_coeffs[
(n-4)*(tm_subsets_cache->max_num_cofunc_targets-3)+k-4];
}
static void
_test_query_init_invalid_query_gl (GstGLContext * context, gpointer data)
{
GstGLQuery q1;
/* no usage */
ASSERT_CRITICAL (gst_gl_query_init (&q1, context, GST_GL_QUERY_NONE));
}
struct csc_grph *dal_csc_grph_dce110_create(
struct csc_grph_init_data *init_data)
{
struct csc_grph *cg = dal_alloc(sizeof(*cg));
if (!cg) {
ASSERT_CRITICAL(false);
return NULL;
}
if (construct(cg, init_data))
return cg;
ASSERT_CRITICAL(false);
dal_free(cg);
return NULL;
}
static void
_test_query_end_gl (GstGLContext * context, gpointer data)
{
GstGLQuery *q1;
/* test mismatched end() */
q1 = gst_gl_query_new (context, GST_GL_QUERY_TIME_ELAPSED);
fail_if (q1 == NULL);
ASSERT_CRITICAL (gst_gl_query_end (q1));
gst_gl_query_free (q1);
}
static void unref_session_on_src_pad_added (FsStream *stream,
GstPad *pad, FsCodec *codec, struct SimpleTestStream *st)
{
TEST_LOCK ();
ASSERT_CRITICAL (fs_session_destroy (st->dat->session));
TEST_UNLOCK ();
g_main_loop_quit (loop);
}
struct hw_gpio_pin *dal_hw_hpd_dce110_create(
struct dc_context *ctx,
enum gpio_id id,
uint32_t en)
{
struct hw_hpd_dce110 *pin = dm_alloc(sizeof(struct hw_hpd_dce110));
if (!pin) {
ASSERT_CRITICAL(false);
return NULL;
}
if (construct(pin, id, en, ctx))
return &pin->base.base.base;
ASSERT_CRITICAL(false);
dm_free(pin);
return NULL;
}
/*construct wireless data*/
bool wireless_data_init(struct wireless_data *data,
struct dc_bios *dcb,
struct wireless_init_data *init_data)
{
struct firmware_info info;
if (data == NULL || dcb == NULL || init_data == NULL) {
ASSERT_CRITICAL(false);
return false;
}
data->miracast_connector_enable = false;
data->wireless_disp_path_enable = false;
data->wireless_enable = false;
/* Wireless it not supported if VCE is not supported */
if (!init_data->vce_supported)
return true;
if (init_data->miracast_target_required)
data->miracast_connector_enable = true;
/*
* If override is in place for platform support, we will both
* enable wireless display as a feature (i.e. CCC aspect) and
* enable the wireless display path without any further checks.
*/
if (init_data->platform_override) {
data->wireless_enable = true;
data->wireless_disp_path_enable = true;
} else {
/*
* Check if SBIOS sets remote display enable, exposed
* through VBIOS. This is only valid for APU, not dGPU
*/
dcb->funcs->get_firmware_info(dcb, &info);
if ((REMOTE_DISPLAY_ENABLE == info.remote_display_config) &&
init_data->fusion) {
data->wireless_enable = true;
data->wireless_disp_path_enable = true;
}
}
/*
* If remote display path override is enabled, we enable just the
* remote display path. This is mainly used for testing purposes
*/
if (init_data->remote_disp_path_override)
data->wireless_disp_path_enable = true;
return true;
}
void dal_gpio_destroy(
struct gpio **gpio)
{
if (!gpio || !*gpio) {
ASSERT_CRITICAL(false);
return;
}
dal_gpio_close(*gpio);
dm_free(*gpio);
*gpio = NULL;
}
enum gpio_result dal_gpio_open_ex(
struct gpio *gpio,
enum gpio_mode mode,
void *options)
{
if (gpio->pin) {
ASSERT_CRITICAL(false);
return GPIO_RESULT_ALREADY_OPENED;
}
gpio->mode = mode;
return dal_gpio_service_open(
gpio->service, gpio->id, gpio->en, mode, options, &gpio->pin);
}
struct irq *dal_gpio_service_create_irq(
struct gpio_service *service,
uint32_t offset,
uint32_t mask)
{
enum gpio_id id;
uint32_t en;
if (!service->translate.funcs->offset_to_id(offset, mask, &id, &en)) {
ASSERT_CRITICAL(false);
return NULL;
}
return dal_gpio_create_irq(service, id, en);
}
void test_double_append()
{
GstStructure *s1;
GstCaps *c1;
//xmlfile = "test_double_append";
std_log(LOG_FILENAME_LINE, "Test Started test_double_append");
c1 = gst_caps_new_any ();
s1 = gst_structure_from_string ("audio/x-raw-int,rate=44100", NULL);
gst_caps_append_structure (c1, s1);
ASSERT_CRITICAL (gst_caps_append_structure (c1, s1));
gst_caps_unref (c1);
std_log(LOG_FILENAME_LINE, "Test Successful");
create_xml(0);
}
static void
_test_query_time_elapsed_gl (GstGLContext * context, gpointer data)
{
GstGLQuery *q1;
q1 = gst_gl_query_new (context, GST_GL_QUERY_TIME_ELAPSED);
fail_if (q1 == NULL);
gst_gl_query_start (q1);
gst_gl_query_end (q1);
/* GST_GL_QUERY_TIME_ELAPSED doesn't supported counter() */
ASSERT_CRITICAL (gst_gl_query_counter (q1));
gst_gl_query_result (q1);
gst_gl_query_free (q1);
}
uint8_t wireless_get_srcs_num(
struct adapter_service *as,
struct graphics_object_id id)
{
switch (id.type) {
case OBJECT_TYPE_CONNECTOR:
return wireless_get_encoders_num(as);
case OBJECT_TYPE_ENCODER:
return 1;
default:
ASSERT_CRITICAL(false);
break;
}
return 0;
}
static void set_drive_settings(struct dc *dc,
struct link_training_settings *lt_settings,
const struct dc_link *link)
{
int i;
for (i = 0; i < dc->link_count; i++) {
if (dc->links[i] == link)
break;
}
if (i >= dc->link_count)
ASSERT_CRITICAL(false);
dc_link_dp_set_drive_settings(dc->links[i], lt_settings);
}
struct clock_source *dal_clock_source_create(
struct clock_source_init_data *clk_src_init_data)
{
enum dce_version dce_ver =
dal_adapter_service_get_dce_version(clk_src_init_data->as);
enum clock_source_id clk_src_id =
dal_graphics_object_id_get_clock_source_id(
clk_src_init_data->clk_src_id);
switch (dce_ver) {
#if defined(CONFIG_DRM_AMD_DAL_DCE11_0)
break;
case DCE_VERSION_11_0:
{
switch (clk_src_id) {
case CLOCK_SOURCE_ID_PLL0:
/* fall through */
case CLOCK_SOURCE_ID_PLL1:
/* fall through */
case CLOCK_SOURCE_ID_PLL2:
return dal_pll_clock_source_dce110_create(
clk_src_init_data);
case CLOCK_SOURCE_ID_EXTERNAL:
return dal_ext_clock_source_dce110_create(
clk_src_init_data);
case CLOCK_SOURCE_ID_VCE:
return dal_vce_clock_source_dce110_create(
clk_src_init_data);
default:
return NULL;
}
}
break;
#endif
default:
dal_logger_write(clk_src_init_data->dal_ctx->logger,
LOG_MAJOR_ERROR,
LOG_MINOR_COMPONENT_GPU,
"Clock Source: not supported DCE version %d", dce_ver);
ASSERT_CRITICAL(false);
break;
}
return NULL;
}
/*
* store_max_clocks_state
*
* @brief
* Cache the clock state
*
* @param
* struct display_clock *base - [out] cach the state in this structure
* enum clocks_state max_clocks_state - [in] state to be stored
*/
static void store_max_clocks_state(
struct display_clock *base,
enum clocks_state max_clocks_state)
{
struct display_clock_dce110 *dc = DCLCK110_FROM_BASE(base);
switch (max_clocks_state) {
case CLOCKS_STATE_LOW:
case CLOCKS_STATE_NOMINAL:
case CLOCKS_STATE_PERFORMANCE:
case CLOCKS_STATE_ULTRA_LOW:
dc->max_clks_state = max_clocks_state;
break;
case CLOCKS_STATE_INVALID:
default:
/*Invalid Clocks State!*/
ASSERT_CRITICAL(false);
break;
}
}
void dal_gpio_service_close(
struct gpio_service *service,
struct hw_gpio_pin **ptr)
{
struct hw_gpio_pin *pin;
if (!ptr) {
ASSERT_CRITICAL(false);
return;
}
pin = *ptr;
if (pin) {
set_pin_free(service, pin->id, pin->en);
pin->funcs->close(pin);
pin->funcs->destroy(ptr);
}
}
static uint8_t disp_power_gating_action_to_atom(
enum bp_pipe_control_action action)
{
uint8_t atom_pipe_action = 0;
switch (action) {
case ASIC_PIPE_DISABLE:
atom_pipe_action = ATOM_DISABLE;
break;
case ASIC_PIPE_ENABLE:
atom_pipe_action = ATOM_ENABLE;
break;
case ASIC_PIPE_INIT:
atom_pipe_action = ATOM_INIT;
break;
default:
ASSERT_CRITICAL(false); /* Unhandle action in driver! */
break;
}
return atom_pipe_action;
}
