Ejemplo n.º 1
0
/*
 * Get the dp uniphy transmitter link.
 * Encoder term is used for transmitter link here
 */
static long path_grphs_parse(struct ctx *ctx, u8 idx, struct path *p)
{
	u8 grphs_n;
	u16 id;
	u8 sub_id;
	u8 type;

	grphs_n = grphs_n_compute(p);	
	if (grphs_n != 1) {
		dev_err(ctx->atb->adev.dev, "atombios:error, only one encoder graphic object is supported (grphs_n=%u)\n",
								grphs_n);
		return -ATB_ERR;
	}

	id = get_unaligned_le16(&p->grph_ids);
	sub_id = id_decode_sub_id(id);
	type = id_decode_type(id);

	if (type != GRPH_TYPE_ENCODER
			&& sub_id != ENCODER_SUB_ID_INTERNAL_UNIPHY0
			&& sub_id != ENCODER_SUB_ID_INTERNAL_UNIPHY1
			&& sub_id != ENCODER_SUB_ID_INTERNAL_UNIPHY2) {
		dev_err(ctx->atb->adev.dev, "atombios:error, only uniphy link encoder graphic object is supported (id=0x%04x)\n",
									id);
		return -ATB_ERR;
	}
	ctx->dp_paths[idx].i = trans(id) * 2 + link_type(id);
	ctx->dp_paths[idx].uniphy_link_hbr2 = 0;
	uniphy_link_hbr2_get(ctx, id, &ctx->dp_paths[idx].uniphy_link_hbr2);
	return 0;
}
Ejemplo n.º 2
0
int DagDrawingTool::link_type( int source_row, int source_index, 
                               int target_row, int target_index )
{
	DagNodeTable& table = *node_table;
	if( abs( source_row - target_row ) != 1 ) return DDT_LINK_NONE;
	return link_type( table[source_row][source_index], 
	                  table[target_row][target_index], 
										source_row < target_row ? DDT_UP_DAG : DDT_DOWN_DAG );
}
Ejemplo n.º 3
0
void DagDrawingTool::one_sort_pass( int start, int end, float* val_list )
{
	int i, j, k;
	DagNodeTable& table = *node_table;
	//int row_count = table.rows();
	int cur_row_len = 0;
	if( start == end ) return;
	int dir = (start < end) ? 1 : -1;
	
	//for each parent row of the passed row of nodes...
	for( i = start; i != (end + dir); i += dir )
	{
		//populate the array with the values to sort by
		cur_row_len = table[i].length();
		for( j = 0; j < cur_row_len; j++ )
		{
			val_list[j] = 0.0;
			int link_count = 0;
			for( k = 0; k < table[i-dir].length(); k++ )
			{
				if( link_type( i, j, i - dir, k ) )
				{
					val_list[j] += (float)k;
					link_count++;
				}
			}
			if( link_count ) val_list[j] /= (float)link_count;
		}		
		
		//sort the row by the values in value_list
		for( j = 0; j < cur_row_len - 1; j++ )
		{
			int smallest = j;
			for( k = j + 1; k < cur_row_len; k++ )
			{
				if( val_list[k] < val_list[smallest] )
					smallest = k;
			}
			if( smallest != j )
			{
                                  //float temp = val_list[j];
				val_list[j] = val_list[smallest];
				val_list[smallest] = val_list[j];
				
				ModelEntity* node = table[i][j];
				table[i][j] = table[i][smallest];
				table[i][smallest] = node;
			}
		}
	}
	
}	
Ejemplo n.º 4
0
void DagDrawingTool::sort_row( int row, int wrt_dir )
{
  assert((wrt_dir == 1) || (wrt_dir == -1));
  
  DagNodeTable& table = *node_table;
  int row_len = table[row].length();
  int rel_row = row + wrt_dir;
  if( (row_len < 2) || (rel_row < 0) || (rel_row == table.rows()) )
    return;
  
  int* index_array = new int[row_len];
  int num_rels = table[rel_row].length();
  int i, j, k, l, m;
  
  //Append first node to list
  index_array[0] = 0;
  
  //For each remaining node, insert it in the location at which
  //it causes the least intersections of links.
  for( i = 1; i < row_len; i++ )
  {
    int best_index = 0;
    int intersection_count = 0;
    
    //Get the intersection count if the node were inserted first
    //in the row.

    //For each possible parent node
    for( k = 1; k < num_rels; k++ )
    {
      //Is it a parent?
      if( ! link_type( row, i, rel_row, k ) )
        continue;
      
      //Count how many other links that link intersects.
      
      //For all the other nodes in the list...
      for( l = 0; l < i; l++ )
      {
        //For each parent to the left of my parent
        for( m = 0; m < k; m++ )
        {
          if( link_type( row, index_array[l], rel_row, m ) )
            intersection_count++;
        }
      }
    }
    
    //Now check the intersection count for each additional
    //possible location of insertion.       
    for( j = 1; j <= i; j++ )
    {
      int current_count = 0;
      
      //For each possible parent node
      for( k = 0; k < num_rels; k++ )
      {
        //Is it a parent?
        if( ! link_type( row, i, rel_row, k ) )
          continue;
          
        //Count how many other links from nodes to the
        //left of me intersect with my link to this parent.
        for( l = 0; l < j; l++ )  
        {
          //For each parent to the right of my parent
          for( m = k+1; m < num_rels; m++ )
          {
            if( link_type( row, index_array[l], rel_row, m ) )
              current_count++;
          }
        }
        
        //Count how many other links from nodes to the
        //right of me intersect with my link to this parent.
        for( l = j; l < i; l++ )
        {
          //For each parent to the left of my parent
          for( m = 0; m < k; m++ )
          {
            if( link_type( row, index_array[l], rel_row, m ) )
              current_count++;
          }
        }
      }
      
      if( current_count <= intersection_count )
      {
        intersection_count = current_count;
        best_index = j;
      }
    }
    
    //Now insert this node at the best location.
    for( j = i; j > best_index; j-- )
      index_array[j] = index_array[j-1];
    index_array[best_index] = i;
  }
  
  //Now rearrange the nodes in the actual row to match 
  //what is stored in index_list
  ModelEntity** node_array = new ModelEntity*[row_len];
  for( i = 0; i < row_len; i++ )
  {
    node_array[i] = table[row][index_array[i]];
  }
  for( i = 0; i < row_len; i++ )
  {
    table[row][i] = node_array[i];
  }
  delete [] node_array;
  delete [] index_array;
}