?? RIGHT := 110 ??
MODULE clm$spi_commands;

{Purpose:
{
{      The purpose of this module is to process the SCL SPI commands.
{
?? PUSH (LISTEXT := ON) ??
*copyc clt$value
*copyc clp$get_value
*copyc clp$get_set_count
*copyc clp$convert_integer_to_string
*copyc clp$scan_parameter_list
*copyc osc$multiprocessor_constants
*copyc osp$disestablish_cond_handler
*copyc osp$establish_condition_handler
*copyc osp$generate_message
*copyc osp$release_spi_environment
*copyc osp$reserve_spi_environment
*copyc osp$set_status_abnormal
*copyc osp$set_status_from_condition
*copyc osp$start_spi_collection
*copyc osp$stop_spi_collection
*copyc oss$job_paged_literal
*copyc ost$processor_id_set
*copyc pmp$continue_to_cause
?? POP ??

?? TITLE := 'PROCEDURE [XDCL, #GATE] clp$reserve_spi_environment', EJECT ??


  PROCEDURE [XDCL] clp$reserve_spi_environment
    (    parameter_list: clt$parameter_list;
     VAR status: ost$status);


{     PDT resse_pdt (
{         spi_identifier,si: integer 0 .. 63 = 0
{         collection_file, cf: file = $required
{         number_of_spi_samples,noss: integer 100 .. 100000000 = 50000
{         spi_sampling_interval,ssi: integer 1 .. 10000 = 300
{         wait,w: boolean = true
{         processor, processors, p: list of key p0,p1,p2,p3,p4,p5,all = all
{         data_string,ds: string 0 .. 32 = 'spi data collection utility'
{         status)

?? PUSH (LISTEXT := ON) ??

    VAR
      resse_pdt: [STATIC, READ, cls$pdt] clt$parameter_descriptor_table :=
            [^resse_pdt_names, ^resse_pdt_params];

    VAR
      resse_pdt_names: [STATIC, READ, cls$pdt_names_and_defaults] array [1 .. 16] of
            clt$parameter_name_descriptor := [['SPI_IDENTIFIER', 1], ['SI', 1], ['COLLECTION_FILE', 2],
            ['CF', 2], ['NUMBER_OF_SPI_SAMPLES', 3], ['NOSS', 3], ['SPI_SAMPLING_INTERVAL', 4], ['SSI', 4],
            ['WAIT', 5], ['W', 5], ['PROCESSOR', 6], ['PROCESSORS', 6], ['P', 6], ['DATA_STRING', 7],
            ['DS', 7], ['STATUS', 8]];

    VAR
      resse_pdt_params: [STATIC, READ, cls$pdt_parameters] array [1 .. 8] of clt$parameter_descriptor := [

{ SPI_IDENTIFIER SI }
      [[clc$optional_with_default, ^resse_pdt_dv1], 1, 1, 1, 1, clc$value_range_not_allowed,
            [NIL, clc$integer_value, 0, 63]],

{ COLLECTION_FILE CF }
      [[clc$required], 1, 1, 1, 1, clc$value_range_not_allowed, [NIL, clc$file_value]],

{ NUMBER_OF_SPI_SAMPLES NOSS }
      [[clc$optional_with_default, ^resse_pdt_dv3], 1, 1, 1, 1, clc$value_range_not_allowed,
            [NIL, clc$integer_value, 100, 100000000]],

{ SPI_SAMPLING_INTERVAL SSI }
      [[clc$optional_with_default, ^resse_pdt_dv4], 1, 1, 1, 1, clc$value_range_not_allowed,
            [NIL, clc$integer_value, 1, 10000]],

{ WAIT W }
      [[clc$optional_with_default, ^resse_pdt_dv5], 1, 1, 1, 1, clc$value_range_not_allowed,
            [NIL, clc$boolean_value]],

{ PROCESSOR PROCESSORS P }
      [[clc$optional_with_default, ^resse_pdt_dv6], 1, clc$max_value_sets, 1, 1,
            clc$value_range_not_allowed, [^resse_pdt_kv6, clc$keyword_value]],

{ DATA_STRING DS }
      [[clc$optional_with_default, ^resse_pdt_dv7], 1, 1, 1, 1, clc$value_range_not_allowed,
            [NIL, clc$string_value, 0, 32]],

{ STATUS }
      [[clc$optional], 1, 1, 1, 1, clc$value_range_not_allowed,
            [NIL, clc$variable_reference, clc$array_not_allowed, clc$status_value]]];

    VAR
      resse_pdt_kv6: [STATIC, READ, cls$pdt_names_and_defaults] array [1 .. 7] of ost$name := ['P0', 'P1',
            'P2', 'P3', 'P4', 'P5', 'ALL'];

    VAR
      resse_pdt_dv1: [STATIC, READ, cls$pdt_names_and_defaults] string (1) := '0';

    VAR
      resse_pdt_dv3: [STATIC, READ, cls$pdt_names_and_defaults] string (5) := '50000';

    VAR
      resse_pdt_dv4: [STATIC, READ, cls$pdt_names_and_defaults] string (3) := '300';

    VAR
      resse_pdt_dv5: [STATIC, READ, cls$pdt_names_and_defaults] string (4) := 'true';

    VAR
      resse_pdt_dv6: [STATIC, READ, cls$pdt_names_and_defaults] string (3) := 'all';

    VAR
      resse_pdt_dv7: [STATIC, READ, cls$pdt_names_and_defaults] string (29) :=
            '''spi data collection utility''';

?? POP ??

    VAR
      collection_file: amt$local_file_name,
      data_string: string (32),
      i: 0 .. clc$max_value_sets,
      number_of_spi_samples: ost$number_of_spi_samples,
      processor_count: 0 .. clc$max_value_sets,
      processor_id_set: ost$processor_id_set,
      processor_value: clt$value,
      spi_identifier: ost$spi_identifier,
      spi_sampling_interval: ost$spi_sampling_interval,
      value: clt$value,
      wait: ost$wait;

    clp$scan_parameter_list (parameter_list, resse_pdt, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

    clp$get_value ('SPI_IDENTIFIER', 1, 1, clc$low, value, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;
    spi_identifier := value.int.value;

    clp$get_value ('NUMBER_OF_SPI_SAMPLES', 1, 1, clc$low, value, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;
    number_of_spi_samples := value.int.value;

    clp$get_value ('SPI_SAMPLING_INTERVAL', 1, 1, clc$low, value, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;
    spi_sampling_interval := value.int.value;

    clp$get_value ('WAIT', 1, 1, clc$low, value, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;
    IF value.bool.value = TRUE THEN
      wait := osc$wait;
    ELSE
      wait := osc$nowait;
    IFEND;

    clp$get_value ('DATA_STRING', 1, 1, clc$low, value, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;
    data_string := value.str.value (1, value.str.size);

    clp$get_value ('COLLECTION_FILE', 1, 1, clc$low, value, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;
    collection_file := value.file.local_file_name;

{  Check the value of the PROCESSORS parameter.

    processor_id_set := $ost$processor_id_set [];
    clp$get_set_count ('PROCESSORS', processor_count, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

{  Check the value processor count.

    FOR i := 1 TO processor_count DO
      clp$get_value ('PROCESSORS', i, 1, clc$low, processor_value, status);
      IF NOT status.normal THEN
        RETURN;
      IFEND;
      IF processor_value.name.value (1, 2) = 'P0' THEN
        processor_id_set := processor_id_set + $ost$processor_id_set [0];
      ELSEIF processor_value.name.value (1, 2) = 'P1' THEN
        processor_id_set := processor_id_set + $ost$processor_id_set [1];
      ELSEIF processor_value.name.value (1, 2) = 'P2' THEN
        processor_id_set := processor_id_set + $ost$processor_id_set [2];
      ELSEIF processor_value.name.value (1, 2) = 'P3' THEN
        processor_id_set := processor_id_set + $ost$processor_id_set [3];
      ELSEIF processor_value.name.value (1, 2) = 'P4' THEN
        processor_id_set := processor_id_set + $ost$processor_id_set [4];
      ELSEIF processor_value.name.value (1, 2) = 'P5' THEN
        processor_id_set := processor_id_set + $ost$processor_id_set [5];
      ELSEIF processor_value.name.value (1, 3) = 'ALL' THEN
        processor_id_set := -$ost$processor_id_set [];
      IFEND;
    FOREND;
    osp$reserve_spi_environment (spi_identifier, collection_file, number_of_spi_samples,
          spi_sampling_interval, wait, processor_id_set, data_string, status);

  PROCEND clp$reserve_spi_environment;

?? EJECT, TITLE := 'PROCEDURE clp$start_spi_collection' ??

{ PDT status_pdt (status)

?? PUSH (LISTEXT := ON) ??

  VAR
    status_pdt: [STATIC, READ, cls$pdt] clt$parameter_descriptor_table :=
          [^status_pdt_names, ^status_pdt_params];

  VAR
    status_pdt_names: [STATIC, READ, cls$pdt_names_and_defaults] array [1 .. 1] of
          clt$parameter_name_descriptor := [['STATUS', 1]];

  VAR
    status_pdt_params: [STATIC, READ, cls$pdt_parameters] array [1 .. 1] of clt$parameter_descriptor := [

{ STATUS }
    [[clc$optional], 1, 1, 1, 1, clc$value_range_not_allowed,
          [NIL, clc$variable_reference, clc$array_not_allowed, clc$status_value]]];

?? POP ??

  PROCEDURE [XDCL] clp$start_spi_collection
    (    parameter_list: clt$parameter_list;
     VAR status: ost$status);

    clp$scan_parameter_list (parameter_list, status_pdt, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

    osp$start_spi_collection (status);

  PROCEND clp$start_spi_collection;

?? EJECT, TITLE := 'PROCEDURE clp$stop_spi_collection' ??

  PROCEDURE [XDCL] clp$stop_spi_collection
    (    parameter_list: clt$parameter_list;
     VAR status: ost$status);

    clp$scan_parameter_list (parameter_list, status_pdt, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

    osp$stop_spi_collection (status);

  PROCEND clp$stop_spi_collection;

?? EJECT, TITLE := 'PROCEDURE clp$release_spi_environment ' ??

  PROCEDURE [XDCL] clp$release_spi_environment
    (    parameter_list: clt$parameter_list;
     VAR status: ost$status);

    clp$scan_parameter_list (parameter_list, status_pdt, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

    osp$release_spi_environment (status);
  PROCEND clp$release_spi_environment;

MODEND clm$spi_commands;
