nvbuild.c

详细介绍了一篇关于pci开发的接口芯片

					passthru[passthru_values[(byte)(cur_addr>>30)]]);
			if ((cur_addr & 0x01) == 0) { /* Memory */
				wgotoxy(row, 51);
				cxl_wprintf(((cur_addr & 0x2) == 0x02) ?
						"Below 1MB" : "Anywhere ");
				wgotoxy(row, 64);
				cxl_wprintf((cur_addr & 0x08) ? "  Yes" : "  No");
			}
		}
		row += 2;
	}
	hidecur();
}

/*
** Check the validity of the memory location field.
*/
STATIC int
check_memory_loc(char *memory_loc_ch)
{
	if ((*memory_loc_ch != '0') && (*memory_loc_ch != '1')) {
		wperror("Memory Location must be 0 or 1", YES);
		return(1);
	}
	memory_loc_index = *memory_loc_ch - '0';
	wgotoxy(5, 22);
	wclreol();
	wprints(5, 22, menu_qsel_color, memory_locs[memory_loc_index]);
	return(0);
}

STATIC void
pre_memory_loc(void)
{
   field_edit_menu = TRUE;
   field_edit_menu_process = pick_memory_loc;
   disp_menu_pick();
}

STATIC void
post_memory_loc(void)
{
	field_edit_menu = FALSE;
	field_edit_menu_process = NULL;
	del_menu_pick();
}

STATIC void
disp_memory_loc(void)
{
	wtitle("[ Choose Memory Location ]", TCENTER, submenu_border_color);
}

/*
** Pop-up menu that selects a memory location
*/
STATIC void
pick_memory_loc(void)
{
  int subscr, row, col, erow, ecol;
  char str[2];

  determine_row_col(&row, &col, TRUE);
  whelpush();

  row += 2;
  col += 2;

  erow = row + 1 + NUMBER_MEMORY_LOCS;
  while (erow > 23) {
    row--;
    erow--;
  }

  ecol = col + 2 + 30;
  while (ecol > 77) {
    col--;
    ecol--;
  }

  subscr = wpickstr(row, col, erow, ecol, 0, submenu_border_color, submenu_window_color, submenu_selection_color, memory_locs, memory_loc_index, disp_memory_loc);

  kbput(0x4700);  /* [Home] */
  if(subscr == -1) {
    subscr = memory_loc_index;
  }
  str[0] = subscr + '0';
  str[1] = 0;

  kbputs(str);
  whelpop();
}

/*
** Check the validity of the memory base address register.
*/
STATIC int
check_membase_addr(char *membase_addr_ch)
{
   int retval, index;
   dword base_addr;

   retval = 1;
   sscanf(membase_addr_ch, "%lx", &base_addr);

   for (index = 0; index < NUMBER_MEM_BASE_ADDR; index++) {
      if (base_addr == membase_val[index]) {
         membase_addr_subscr = index;
         wgotoxy(9, 34);
         wclreol();
         wprints(9, 30, menu_qsel_color, membase_addr[membase_addr_subscr]);
         retval = 0;
      }
   }

   if (retval == 1)
      wperror("Invalid Memory Base Address", YES);
   return(retval);
}

STATIC void
pre_base_mem_size(void)
{
	field_edit_menu = TRUE;
	field_edit_menu_process = pick_base_mem_size;
	disp_menu_pick();
}

STATIC void
post_base_mem_size(void)
{
	field_edit_menu = FALSE;
	field_edit_menu_process = NULL;
	del_menu_pick();
}

STATIC void
disp_base_addr(void)
{
	wtitle("[ Choose Base Address Size ]", TCENTER, submenu_border_color);
}

/*
** Allow the user to pick the base memory size.
*/
STATIC void
pick_base_mem_size(void)
{
  int subscr;
  int row, col;
  int erow, ecol;
  char str[9];

  determine_row_col(&row, &col, TRUE);
	whelpush();

  row -= NUMBER_MEM_BASE_ADDR / 3 + 1;
  col += 2;

  erow = row + 1 + NUMBER_MEM_BASE_ADDR / 3;
  while (erow > 23) {
    row--;
    erow--;
  }

  ecol = col + 2 + 14*3;
  while (ecol > 77) {
    col--;
    ecol--;
  }

  subscr = wpickstr(row, col, erow, ecol, 0, submenu_border_color, submenu_window_color, submenu_selection_color, membase_addr, membase_addr_subscr, disp_base_addr);

	kbput(0x4700);  /* [Home] */
	if (subscr == -1)
		subscr = membase_addr_subscr;
  sprintf(str, "%8.8lX", membase_val[subscr]);
  kbputs(str);
	whelpop();
}


/*---------------------------------------------------------------------------*/
// This function checks the validity of the pass through register
STATIC int
check_passthru(char *passthru_ch)
{
	int row, col;

	switch (*passthru_ch) {
		case '0':
		case '1':
		case '2':
		case '3':
			break;
		default:
			wperror("Invalid Pass Through Width", YES);
			return(1);
	}

	determine_row_col(&row, &col, FALSE);
	wgotoxy(row, 22);
	wclreol();
	passthru_width_index = *passthru_ch - '0';
	wprints(row,22, menu_qsel_color, passthru[passthru_width_index]);
	return(0);
}

	static void
pre_passthru_width(void)
{
	field_edit_menu = TRUE;
	field_edit_menu_process = pick_passthru_width;
	disp_menu_pick();
}

STATIC void
post_passthru_width(void)
{
	field_edit_menu = FALSE;
	field_edit_menu_process = NULL;
	del_menu_pick();
}

STATIC void
disp_passthru(void)
{
	wtitle("[ Choose Pass Through Width ]", TCENTER, submenu_border_color);
}

/*
** Allow the user to pick the pass through width.
*/
STATIC void
pick_passthru_width(void)
{
  int subscr, row, col, erow, ecol;
  char str[2];

  determine_row_col(&row, &col, TRUE);
  whelpush();

  row -= 1 + 1;
  col += 2;

  erow = row + 2;
  while (erow > 23) {
    row--;
    erow--;
  }

  ecol = col + 2 + 10*4;
  while (ecol > 77) {
    col--;
    ecol--;
  }

  subscr = wpickstr(row, col, erow, ecol, 0, submenu_border_color, submenu_window_color, submenu_selection_color, passthru, passthru_width_index, disp_passthru);

  kbput(0x4700);  /* [Home] */
  if (subscr == -1)
    subscr = passthru_width_index;
  str[0] = subscr + '0';
  str[1] = 0;
  kbputs(str);
  whelpop();
  determine_row_col(&row, &col, FALSE);
  wgotoxy(row, 22);
  wclreol();
  wprints(row,22, menu_qsel_color, passthru[subscr]);
}

/*
** Check the validity of an I/O Base Address entry.
*/
STATIC int
check_io_base_addr(char *io_base_addr_ch)
{
   int retval, index;
   dword base_addr;

   retval = 1;
   sscanf(io_base_addr_ch, "%lx", &base_addr);

   for (index = 0; index < NUMBER_IO_BASE_ADDR; index++) {
      if (base_addr == io_base_values[index]) {
         io_base_addr_subscr = index;
         wgotoxy(5, 30);
         wclreol();
         wprints(5,30, menu_qsel_color, io_base_addr[io_base_addr_subscr]);
         retval = 0;
      }
   }

   if (retval == 1)
      wperror("Invalid I/O Base Address", YES);
   return(retval);
}

STATIC void
pre_base_io_mem_size(void)
{
	field_edit_menu = TRUE;
	field_edit_menu_process = pick_base_io_mem_size;
	disp_menu_pick();
}

STATIC void
post_base_io_mem_size(void)
{
	field_edit_menu = FALSE;
	field_edit_menu_process = NULL;
	del_menu_pick();
}

/*
** Allow the user to select a valid base I/O memory size.
*/
STATIC void
pick_base_io_mem_size(void)
{
	int subscr, row, col, erow, ecol;
   char str[9];

   determine_row_col(&row, &col, TRUE);
	whelpush();

   row -= NUMBER_IO_BASE_ADDR / 3 + 2;
   col += 2;

   erow = row + NUMBER_IO_BASE_ADDR / 3 + 2;
   while (erow > 23) {
      row--;
      erow--;
   }

   ecol = col + 2 + 14*3;
   while (ecol > 77) {
      col--;
      ecol--;
   }

   subscr = wpickstr(row, col, erow, ecol, 0, submenu_border_color, submenu_window_color, submenu_selection_color, io_base_addr, io_base_addr_subscr, disp_base_addr);

	kbput(0x4700);  /* [Home] */
	if (subscr == -1)
      subscr = io_base_addr_subscr;
   sprintf(str, "%8.8lX", io_base_values[subscr]);
   kbputs(str);
	whelpop();
}

/*
** Check the validitiy of the interrupt pin.
*/
STATIC int
check_intr_pin(char *intr_pin_ch)
{
	int row, col;

	sscanf(intr_pin_ch, "%x", &intr_pin_subscr);

	determine_row_col(&row, &col, FALSE);
	if (intr_pin_subscr <= 2) {
		wgotoxy(row, col + 2);
		wclreol();
		wprints(row, col + 2, menu_qsel_color,
			intr_pin_codes[intr_pin_subscr]);
		return(0);
	}
	wperror("Invalid Interrupt Pin", YES);
	return(1);
}

STATIC void
pre_exp_rom(void)
{
	field_edit_menu = TRUE;
	field_edit_menu_process = pick_exp_rom;
	disp_menu_pick();
}

STATIC void
post_exp_rom(void)
{
	field_edit_menu = FALSE;
	field_edit_menu_process = NULL;
	del_menu_pick();
}

/*
** Allow the user to pick the expansion rom size.
*/
STATIC void
pick_exp_rom(void)
{
  int subscr, row, col, erow, ecol, num_exp_rom_codes;
  char str[20];

  if (current_device_type == S5933)
    num_exp_rom_codes = NUMBER_EXP_ROM_CODES;
  else
    num_exp_rom_codes = NUMBER_EXP_ROM_CODES_5920;

  del_menu_pick();
  determine_row_col(&row, &col, TRUE);
  whelpush();

  row -= num_exp_rom_codes + 1;
  col += 2;

  erow = row + 1 + num_exp_rom_codes;
  while (erow > 23) {
    row--;
    erow--;
  }

  ecol = col + 2 + 28;
  while (ecol > 77) {
    col--;
    ecol--;
  }

  if (current_device_type == S5933)
    subscr = wpickstr(row, col, erow, ecol, 0, submenu_border_color, submenu_window_color, submenu_selection_color, exp_rom_codes, exp_rom_subscr, disp_exp_rom);
  else
    subscr = wpickstr(row, col, erow, ecol, 0, submenu_border_color, submenu_window_color, submenu_selection_color, exp_rom_codes_5920, exp_rom_subscr, disp_exp_rom);

  kbput(0x4700);  /* [Home] */
  if (subscr == -1)
    subscr = exp_rom_subscr;
  if (current_device_type == S5933)
    sprintf(str, "%8.8lX", exp_rom_values[subscr]);
  else
    sprintf(str, "%8.8lX", exp_rom_values_5920[subscr]);
  kbputs(str);
  kbput(0x1c0d);  /* [Enter] */
  whelpop();
}

STATIC int
check_exp_rom(char *exp_rom_ch)
{
  int retval, index, row, col;
  dword exp_rom;

  retval = 1;
  sscanf(exp_rom_ch, "%lx", &exp_rom);

  determine_row_col(&row, &col, FALSE);
  if (current_device_type == S5933)
  {
    for (index = 0; index < NUMBER_EXP_ROM_CODES; index++) {
      if (exp_rom == exp_rom_values[index]) {
        exp_rom_subscr = index;
        wgotoxy(row, col + 9);
        wclreol();
        wprints(row, col + 9, menu_qsel_color, exp_rom_codes[exp_rom_subscr]);
        retval = 0;
      }
    }
  } else {
    for (index = 0; index < NUMBER_EXP_ROM_CODES_5920; index++) {
      if (exp_rom == exp_rom_values_5920[index]) {
        exp_rom_subscr = index;
        wgotoxy(row, col + 9);
        wclreol();
        wprints(row, col + 9, menu_qsel_color, exp_rom_codes_5920[exp_rom_subscr]);
        retval = 0;
      }
    }
  }

  if (retval == 1)
    wperror("Invalid Expansion ROM Size", YES);
  return(retval);
}

/*---------------------------------------------------------------------------*/
// This function edits all NVRAM fields except BASE ADDR & Location 45 fields

#define NO_MULTI_FUNCTION

STATIC void
edit_other(void)
{
  int ch, tmp_int, index, row;
  UINT key;

  ch = 'N';
  wactiv(title_window);
  whide();

  wactiv(edit_menu_window);
  whide();

  /* Find class_code_subscr */
  class_code_subscr = 0;
  for (index = 0; index < NUMBER_CLASS_CODES; index++) {
    if (cur_nvram.class_code.base_class == class_codes[index]) {
      class_code_subscr = index;
      break;
    }
  }

  /* Find subclass_code_subscr */
  subclass_code_subscr = 0;
  for (index = 0; index < NUMBER_SUBCLASS_CODES; index++) {
    if (cur_nvram.class_code.subclass == subclass_codes[class_code_subscr][index]) {
      subclass_code_subscr = index;
      break;
    }
  }

  if (current_device_type == S5933)
  {
    /* Find exp_rom_subscr */
    exp_rom_subscr = 0;
    for (index = 0; index < NUMBER_EXP_ROM_CODES; index++) {
      if (exp_rom_values[index] == cur_nvram.exp_rom_size) {
        exp_rom_subscr = index;
        break;
      }
    }
  } else {
    /* Find exp_rom_subscr */
    exp_rom_subscr = 0;
    for (index = 0; index < NUMBER_EXP_ROM_CODES_5920; index++) {
      if (exp_rom_values_5920[index] == cur_nvram.exp_rom_size) {
        exp_rom_subscr = index;
        break;
      }
    }
  }

  intr_pin_subscr = cur_nvram.intr_pin;
  if (intr_pin_subscr > sizeof(intr_pin_codes))
    intr_pin_subscr = 0;

  if (!wopen(1,2,21,77,0,menu_border_color,menu_window_color))
  	error_exit(1);
  add_shadow();
  wtitle("[ Edit Other Configuration Registers ]",TCENTER,menu_border_color);
  wmessage(" [F10]=Finished ",BT_BORD, 5,menu_border_color);
  wmessage(" [Esc]=Abort "   ,BT_BORD,45,menu_border_color);
  whelpushc(H_EDITKEYS);
  sprintf(vendor_id, "%04.4X", cur_nvram.vendor_id);
  sprintf(subsystem_vendor_id, "%04.4X", cur_nvram.subsystem_vendor_id);
  sprintf(device_id, "%04.4X", cur_nvram.device_id);
  sprintf(subsystem_device_id, "%04.4X", cur_nvram.subsystem_device_id);
  sprintf(revision_id, "%02.2X", cur_nvram.revision_id);
  sprintf(prog_if, "%02.2X", cur_nvram.class_code.prog_if);
  sprintf(latency_timer, "%02.2X", cur_nvram.latency_timer);