uclinux_v2_1_0.tcl

uclinux在fpga上的移植时

proc get_periph_irq_list {periph} {

	set irq_list {}

	# Get any output interrupt ports of this core type
	set intr_ports [xget_port_by_subtype $periph "SIGIS" "INTERRUPT" "DIR" "O"]
	if {[llength $intr_ports] > 0} {

		set num_intr_ports [llength $intr_ports];

		# Get handle to actual MHS instance of this core 
		set mhs_handle [xget_hw_parent_handle $periph]

		# Loop over each interrupt-generating port
		foreach port $intr_ports {
			# What signal (wire) is attached?
			set signal [xget_value $port "VALUE"]
			if {[llength $signal] == 0} {
				continue
			}
			# Get the name of the interrupt port 
			set intr_port_name [string toupper [xget_value $port "NAME"]]

			# Our interrupt output is the source - what about the sink?
			set sink_ports [xget_hw_connected_ports_handle $mhs_handle $signal "sink"]

			if {[string match "" $sink_ports]} {
				puts [format "WARNING: Interrupt signal %s on port %s has no sink" $signal $intr_port_name]
				continue;
			} 

			# Get parent periphs of sink port for IRQ signal
			set sink_periphs [xget_hw_parent_handle $sink_ports]
			set sink_periphs_names [xget_value $sink_periphs "VALUE"]
			puts sink_periphs:$sink_periphs_names
			puts sink_ports:$sink_ports

			# Which of these are interrupt controllers?
			set intc_sink_periphs ""
			set intc_sink_ports ""
			set sink_idx 0
			foreach sink_periph $sink_periphs_names {
				if {[string match -nocase *_intc $sink_periph]} {
					lappend intc_sink_periphs $sink_periph
					lappend intc_sink_ports [lindex $sink_ports $sink_idx]
				}
				incr sink_idx
			}

			# Does the signal drive an interrupt controller?
			if {[llength $intc_sink_periphs] ==0} {
				continue
			}

			# Does it drive more than one controller?
			# Or one controller, more than once maybe?
			if {[llength $intc_sink_periphs] != 1} {
				puts [format "ERROR: Interupt signal %s on port %s connects to multiple interrupt controllers:" $signal $intr_port_name]
				puts $intc_sink_periphs
				continue
			}

			# We've isolated a single sink port on an interrupt controller
			# Enumerate all incoming signals on this sink port 
			set signals [split [xget_value $intc_sink_ports "VALUE"] "&"]

			# What numerical position is our signal in this list?
			set i 1
			foreach s $signals {
				set s [string trim $s]
				if {[string compare -nocase $s $signal] == 0} {
					break
				} 
				incr i
			}

			# Workout the IRQ num
			set posn [expr [llength $signals] - $i]

			lappend irq_list [list $intr_port_name $posn]
		}
	}
	return $irq_list 
}
proc xprint_drv_param {config_file drv_handle} {
    
	set periphs [xget_sw_iplist_for_driver $drv_handle]
	set device_id -1
	set prev_periph_name ""
	
	# global array to keep count of each peripheral type
	global periph_count

	# Global array tracking periph-type overrides
	global override_array

	foreach periph $periphs {
		set args [xget_hw_parameter_handle $periph "*"]
		set periph_name [string toupper [xget_value $periph "VALUE"]]

		# Handle periph type override (e.g. for EMCs used as generic
		# interface adapters
		
		# Get instance name for current peripheral
		set inst_handle [xget_hw_parameter_handle $periph "INSTANCE"]
		set instance_name [string toupper [xget_value $inst_handle]]
		puts Instance:$instance_name

		# Has this instance been overridden?
		if {![string match [array names override_array $instance_name] "" ]} {
			set periph_name $override_array($instance_name)
		}

		puts "periph: $periph_name"
	
		# strip any opb_ plb_ or dcr_ prefixes from periph name
		regsub -nocase ^OPB_ $periph_name "" periph_name
		regsub -nocase ^PLB_ $periph_name "" periph_name
		regsub -nocase ^DCR_ $periph_name "" periph_name

		# initialize / update count for this peripheral type
		if {![string compare -nocase "" [array names periph_count $periph_name]]} {
			set periph_count($periph_name) 1
		} else {
			incr periph_count($periph_name)
		}
	
		set device_id [expr $periph_count($periph_name)-1];

		# Output standard core params
		set periph_string [format "%s_%s" $periph_name $device_id]
		xprint_params $config_file $periph_string $args

		# Special handling for MDM core, but not sure why
		#if {[string compare -nocase $periph_name "opb_mdm"] != 0} {
		#	incr device_id
		#} 

		# Interrupt controller connections
		# Don't process interrupt controller itself
		if {![string match -nocase *_intc $periph_name]} {
			set irq_list [get_periph_irq_list $periph]

			puts irq_list:$irq_list
			puts [llength $irq_list]

			# For periphs with a single interrupt output, it's just called "IRQ"
			# However periphs with multiple interrupt outputs, we name the ports explicitly
			if {[llength $irq_list] == 1} {
				set irq_name [format "CONFIG_XILINX_%s_IRQ" $periph_string]
				set irq_num [lindex [lindex $irq_list 0] 1]
				puts $config_file "define_int $irq_name $irq_num"
			} else {
				foreach irq_data $irq_list {
					puts irq_data:$irq_data
					set irq_name [format "CONFIG_XILINX_%s_%s_IRQ" $periph_string [lindex $irq_data 0]]
					set irq_num [lindex $irq_data 1]
					puts $config_file "define_int $irq_name $irq_num"
				}
			}
		}

		puts $config_file ""
	}

}

# Convert EDK param of type std_logic_vector into a C-style hex val
proc stdlogicvec_to_hex {param_value} {
	# remove any internal underscore characters, 
	# these are permitted in VHDL/EDK, but not C
	set param_value [string map {_ ""} $param_value]
	
	# Check to see if value starts with 0b or 0x
	if {[string match -nocase 0b* $param_value]} {
		set param_value [xconvert_binary_to_hex $param_value]
	} elseif {[string match -nocase 0x* $param_value]} {
		set param_value [format "0x%08X" $param_value]
	} else {
		# assume malformed binary value, put 0b at the front
		set param_value [xconvert_binary_to_hex 0b$param_value]
	}
	return $param_value;
}

# Generate a config.in string for a parameter value
proc gen_config_string {periph_string param} {
	set config_string ""

	# get the name of the parameter, and format
	set param_name [string toupper [xget_value $param "NAME"]]

	# trim leading "C_" from param name
	set param_name [string map -nocase {C_ ""} $param_name]

	# morph into config.in naming format
	set param_name [format "CONFIG_XILINX_%s_%s" $periph_string $param_name]

	# Now deal with the value
	set param_value [xget_value $param "VALUE"]

	# format according to datatype
	set dt [string toupper [xget_hw_subproperty_value $param "DT"]]

	puts "param_name:$param_name"
	puts "param_value:$param_value"
	puts "param_dt:$dt"

	switch -regexp $dt {
		INTEGER {
			set param_value [string map {_ ""} $param_value]
			set config_string "define_int $param_name $param_value"
		}
		STD_LOGIC_VECTOR* {
			set config_string "define_hex $param_name [stdlogicvec_to_hex $param_value]"
		}
		STD_LOGIC {
			set config_string "define_int $param_name $param_value"
		}
		STRING {
			set config_string "define_string $param_name $param_value"
		}
		default {
			set config_string "define_string $param_name $param_value"
		}
	}

	return $config_string;
}

proc xprint_params {config_file periph_string largs} {
    
	puts $config_file "\# Definitions for $periph_string"

	foreach arg $largs {
		set config_param_string [gen_config_string $periph_string $arg]
		if {![string match "" $config_param_string]} {
			puts $config_file $config_param_string
		}
	}
}

proc xprint_header {config_file} {

    puts $config_file "\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\##\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#"
    puts $config_file "\# "
    puts $config_file "\# CAUTION: This file is automatically generated by libgen."
    puts $config_file "\# Version: [xget_swverandbld] "
    puts $config_file "\# Description: uClinux Configuration File"
    puts $config_file "\# "
    puts $config_file "\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\##\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#"
    puts $config_file "\n"
}