nvbuild.c

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

#ifndef NO_MULTI_FUNCTION
  if (cur_nvram.header_type.multi_function)
    strcpy(multi_function_agent, "Y");
  else
    strcpy(multi_function_agent, "N");
#endif
  if (cur_nvram.bist.bist_capable)
    strcpy(bist_capable, "Y");
  else
    strcpy(bist_capable, "N");

  sprintf(intr_line, "%02.2X", cur_nvram.intr_line);
  sprintf(min_grant, "%02.2X", cur_nvram.min_grant);
  sprintf(max_latency, "%02.2X", cur_nvram.max_latency);
  if (current_device_type == S5933)
    sprintf(exp_rom_size, "%8.8lx", exp_rom_values[exp_rom_subscr]);
  else
    sprintf(exp_rom_size, "%8.8lx", exp_rom_values_5920[exp_rom_subscr]);
  sprintf(class_code, "%2.2X", class_codes[class_code_subscr]);
  sprintf(subclass_code, "%2.2X", subclass_codes[class_code_subscr][subclass_code_subscr]);
  sprintf(intr_pin, "%d", intr_pin_subscr);

#define COL1  27
#define COL2  60
#define ROW_INC 2

  do {
    row = 1;

    /* Mark beginning of form. */
    winpbeg(DGREY|_LGREY,WHITE|_CYAN);

    /* Display prompts and define fields. */
    wprints(row, COL1 - 16, menu_window_color, "Vendor ID (Hex)");
    winpdef(row, COL1, vendor_id, "HHHH", 'U', 2, check_vendor_id, H_VENDOR_ID);

    wprints(row, COL2 - 16, menu_window_color, "Device ID (Hex)");
    winpdef(row, COL2, device_id, "HHHH", 'U', 2, check_device_id, H_DEVICE_ID);

    if (current_device_type != S5933)
    {
      row += ROW_INC;
      wprints( row,COL1 - 26,menu_window_color,"Subsystem Vendor ID (Hex)");
      winpdef( row,COL1,subsystem_vendor_id,"HHHH",'U',2,check_subsys_vendor_id,H_SUBSYS_VENDOR_ID);

      wprints( row,COL2 - 19,menu_window_color,"Subsystem ID (Hex)");
      winpdef( row,COL2,subsystem_device_id,"HHHH",'U',2,check_subsys_device_id,H_SUBSYS_DEVICE_ID);
    }

    row += ROW_INC;
    wprints(row,COL1 - 18, menu_window_color,"Revision ID (Hex)");
    winpdef(row,COL1,revision_id,"HH",'U',2,check_revision_id,H_REVISION_ID);

    row += ROW_INC;
    wprints(row, COL1 - 16, menu_window_color,"Base Class Code");
    wprints(row, COL1 + 3, menu_qsel_color, class_code_messages[class_code_subscr]);
    winpdef(row,COL1,class_code,"HH",0,2,check_class_code,H_BASE_CLASS_CODE);
    winpfba(pre_class_code,post_class_code);

    row += ROW_INC;
    wprints(row, COL1 - 15,menu_window_color,"Sub-Class Code");
    wprints(row, COL1 + 3, menu_qsel_color, subclass_code_messages[class_code_subscr][subclass_code_subscr]);
    winpdef(row, COL1,subclass_code,"HH",0,2,check_subclass_code,H_SUBCLASS_CODE);
    winpfba(pre_subclass_code,post_subclass_code);
    subclass_field = winpfcurr();

    row += ROW_INC;
    wprints(row, COL1 - 22, menu_window_color,"Programming I/F (Hex)");
    winpdef(row,COL1,prog_if,"HH",'U',2,NULL,H_PROG_IF);

    wprints(row,COL2 - 14, menu_window_color,"BIST Capable?");
    winpdef(row,COL2,bist_capable,"Y",'U',2,check_y_n,H_BIST_CAPABLE);

    row += ROW_INC;
    wprints(row,COL1 - 20, menu_window_color,"Latency Timer (Hex)");
    winpdef(row,COL1,latency_timer,"HH",'U',2,check_latency_timer,H_LATENCY_TIMER);

    // 5920 cannot be a multi-function device
    if (current_device_type == S5933) {
#ifndef NO_MULTI_FUNCTION
        wprints(row,COL2 - 16, menu_window_color,"Multi-function?");
        winpdef(row,COL2,multi_function_agent,"Y",'U',2,check_y_n,H_MULTI_FUNCTION);
#endif
    }

    row += ROW_INC;
    wprints(row,COL1 - 21,menu_window_color,"Interrupt Line (Hex)");
    winpdef(row,COL1,intr_line,"HH",'U',2,NULL,H_INTERRUPT_LINE);

    wprints(row,COL2 - 14, menu_window_color,"Interrupt Pin");
    wprints(row, COL2 + 2, menu_qsel_color, intr_pin_codes[intr_pin_subscr]);
    winpdef(row,COL2,intr_pin, "9",'U',2,check_intr_pin,H_INTERRUPT_PIN);
    winpfba(pre_intr_pin,post_intr_pin);

    row += ROW_INC;
    wprints(row, COL1 - 20,menu_window_color,"Minimum Grant (Hex)");
    winpdef(row,COL1,min_grant,"HH",'U',2,NULL,H_MINIMUM_GRANT);

    wprints(row,COL2 - 22,menu_window_color,"Maximum Latency (Hex)");
    winpdef(row,COL2,max_latency,"HH",'U',2,NULL,H_MAXIMUM_LATENCY);

    row += ROW_INC;
    wprints(row, COL1 - 19,menu_window_color,"Expansion ROM Size");
    if (current_device_type == S5933)
      wprints(row, COL1 + 9, menu_qsel_color, exp_rom_codes[exp_rom_subscr]);
    else
      wprints(row, COL1 + 9, menu_qsel_color, exp_rom_codes_5920[exp_rom_subscr]);
    winpdef(row,COL1,exp_rom_size,"HHHHHHHH",0,2,check_exp_rom,H_EXP_ROM);
    winpfba(pre_exp_rom,post_exp_rom);

    /* Define alternate keyboard get function. */
    winpkey(get_key,&key);

    /* Mark end of form and process it.  If [Esc] was pressed, */
    /* then don't bother with the confirmation message.        */
    if (winpread())
		break;

    /* Test to see if [F10] was pressed.  If   */
    /* so, don't display confirmation message. */
    if (key==0x4400)
      ch = 'Y';
    else {
      /* Display confirmation message. */
      if (!wopen(20,23,22,56,0,WHITE|_CYAN,WHITE|_CYAN))
	  	error_exit(1);
      add_shadow();
      wputs("\n Is this information correct? \033A\076Y\b");
      clearkeys();
      ch = wgetchf("YN", 'Y');
      wclose();
    }
  } while(ch!='Y');

  if (ch == 'Y') {
    sscanf(vendor_id,   "%x", &tmp_int);
    cur_nvram.vendor_id = tmp_int;

    sscanf(subsystem_vendor_id,   "%x", &tmp_int);
    cur_nvram.subsystem_vendor_id = tmp_int;

    sscanf(device_id,   "%x", &tmp_int);
    cur_nvram.device_id = tmp_int;

    sscanf(subsystem_device_id,   "%x", &tmp_int);
    cur_nvram.subsystem_device_id = tmp_int;

    sscanf(revision_id, "%x", &tmp_int);
    cur_nvram.revision_id = tmp_int;

    cur_nvram.class_code.base_class = class_codes[class_code_subscr];
    cur_nvram.class_code.subclass = subclass_codes[class_code_subscr][subclass_code_subscr];
    sscanf(prog_if, "%x", &tmp_int);
    cur_nvram.class_code.prog_if = tmp_int;

    sscanf(latency_timer, "%x", &tmp_int);
    cur_nvram.latency_timer = tmp_int;

    cur_nvram.header_type.multi_function =
#ifndef NO_MULTI_FUNCTION
    	(multi_function_agent[0] == 'Y');
#else
      	FALSE;
#endif

    cur_nvram.bist.bist_capable = (bist_capable[0] == 'Y');
    sscanf(intr_line, "%x", &tmp_int);
    cur_nvram.intr_line = tmp_int;

    cur_nvram.intr_pin = intr_pin_subscr;

    sscanf(min_grant, "%x", &tmp_int);
    cur_nvram.min_grant = tmp_int;

    sscanf(max_latency, "%x", &tmp_int);
    cur_nvram.max_latency = tmp_int;

    if (current_device_type == S5933)
      cur_nvram.exp_rom_size = exp_rom_values[exp_rom_subscr];
    else
      cur_nvram.exp_rom_size = exp_rom_values_5920[exp_rom_subscr];
  }
  whelpopc();
  wclose();
  hidecur();
  wunhide(title_window);
  wunhide(edit_menu_window);
}

STATIC int
check_device_id(char *device_id_ch)
{
	int device_id;

	sscanf(device_id_ch, "%x", &device_id);
	if ((device_id & 0xFFFF) == 0xffff) {
		wperror("0xffff is an invalid DEVICE ID", YES);
		return(1);
	}
	if (device_id != default_nvram.device_id)
		wperror("Changes to Device ID register are NOT RECOMMENDED!!!\n"
			"See Development Kit Documentation.", YES);
	return(0);
}

STATIC int
check_subsys_device_id(char *device_id_ch)
{
	int device_id;

	sscanf(device_id_ch, "%x", &device_id);

	if ((device_id & 0xFFFF) == 0xffff) {
		wperror("0xffff is an invalid DEVICE ID", YES);
		return(1);
	}
	if (device_id != default_nvram.device_id)
		wperror("RECOMMENDED: use a unique value for each of your add-in "
			"card designs.", NO);
	return(0);
}

STATIC int
check_vendor_id(char *vendor_id_ch)
{
	int vendor_id;

	sscanf(vendor_id_ch, "%x", &vendor_id);

	if ((vendor_id & 0xFFFF) == 0xffff) {
		wperror("0xffff is an invalid VENDOR ID", YES);
		return(1);
	}
	if (vendor_id != AMCC_VENDOR_ID)
		wperror("Changes to Vendor ID register are NOT RECOMMENDED!!!\n"
				"See Development Kit Documentation.", NO);
	return(0);
}

STATIC int
check_subsys_vendor_id(char *vendor_id_ch)
{
	int vendor_id;

	sscanf(vendor_id_ch, "%x", &vendor_id);

	if ((vendor_id & 0xFFFF) == 0xffff) {
		wperror("0xffff is an invalid VENDOR ID", YES);
		return(1);
	}
	if (vendor_id != AMCC_VENDOR_ID)
		wperror("RECOMMENDED: use your unique Vendor ID (from PCI SIG)\n"
			"for the subsystem register.", NO);
	return(0);
}

STATIC int
check_revision_id(char *revision_id_ch)
{
	int revision_id;

	sscanf(revision_id_ch, "%x", &revision_id);
	if (revision_id != default_nvram.revision_id)
		wperror("Changes to revision ID register are NOT RECOMMENDED!!!\n"
			"See Development Kit Documentation.", NO);
	return(0);
}

STATIC int
check_class_code(char *class_code_ch)
{
	int class_code, retval, index, row, col;

	sscanf(class_code_ch, "%x", &class_code);

	determine_row_col(&row, &col, FALSE);
	for (index = 0; index < NUMBER_CLASS_CODES; index++) {
		if (class_code == class_codes[index]) {
			retval = 0;
			if (index != class_code_subscr) {
				class_code_subscr = index;
				wgotoxy(row, col + 3);
				wclreol();
				wprints(row, col + 3, menu_qsel_color,
					class_code_messages[class_code_subscr]);
				subclass_code_subscr = 0;
				strcpy(subclass_code, "00");
				strcpy(subclass_field->buf, subclass_code);
				wgotoxy(row + ROW_INC, col + 3);
				wclreol();
				wprints(row + ROW_INC, col + 3, menu_qsel_color, subclass_code_messages[class_code_subscr][subclass_code_subscr]);
			}
		}
	}
	return(retval);
}

STATIC int
check_subclass_code(char *subclass_code_ch)
{
	int subclass_code, retval, index, row, col;

	retval = 1;
	sscanf(subclass_code_ch, "%x", &subclass_code);

	determine_row_col(&row, &col, FALSE);
	for (index = 0; index < NUMBER_SUBCLASS_CODES; index++)
		if (subclass_code == subclass_codes[class_code_subscr][index]) {
			retval = 0;
			subclass_code_subscr = index;
			wgotoxy(row, col + 3);
			wclreol();
			wprints(row, col + 3, menu_qsel_color,
				subclass_code_messages[class_code_subscr][subclass_code_subscr]);
			return(0);
		}
	return(1);
}

void
pre_subclass_code(void)
{
	field_edit_menu = TRUE;
	field_edit_menu_process = pick_subclass_code;
	disp_menu_pick();
}

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

// Generic pop-ups
STATIC char *current_generic_pop_up_title;

STATIC void
generic_pop_up_title(void)
{
	wtitle(current_generic_pop_up_title, TCENTER, submenu_border_color);
}

STATIC void
generic_pop_up(char **selection_strings, char *submenu_title)
{
	int subscr, row, col, erow, ecol, longest, count;
	int current_selection_subscr;
	struct _field_t *winpf;
	char str[9];

	count = 0;
	current_generic_pop_up_title = submenu_title;
	determine_row_col(&row, &col, TRUE);

	// Determine current field contents
	if (!(winpf = winpfcurr()))
		current_selection_subscr = atoi(winpf->buf);

	whelpush();
	longest = strlen(submenu_title);

	// Determine number of entries & longest entry
	for (subscr = 0; selection_strings[subscr]; subscr++) {
		count++;
		if (strlen(selection_strings[subscr]) > longest)
			longest = strlen(selection_strings[subscr]);
	}

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

	ecol = col + 1 + longest;
	while (ecol > 77) {
		col--;
		ecol--;
	}

	subscr = wpickstr(row, col, erow, ecol, 0, submenu_border_color,
				submenu_window_color, submenu_selection_color,
					selection_strings, current_selection_subscr,
						generic_pop_up_title);
	kbput(0x4700);
	if (subscr == -1)
		subscr = current_selection_subscr;
	sprintf(str, "%1d", subscr);
	kbputs(str);
	whelpop();
}

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

// Add on control - generic popup information
// Strings to display in pop-up
STATIC char *add_on_control_strs[] = {
	"0 - Add-on Initiated Bus Mastering",
	"1 - PCI Initiated Bus Mastering",
	NULL
};

STATIC void
pick_add_on_control(void)
{
	generic_pop_up(add_on_control_strs, "[ Choose Bus Master Register Access ]");
}

STATIC void
pre_add_on_control(void)
{
	field_edit_menu = TRUE;
	field_edit_menu_process = pick_add_on_control;
	disp_menu_pick();
}

// WRFIFO_ENABLE control - generic popup information
// Strings to display in pop-up
STATIC char *wrfifo_enable_strs[] = {
	"0 - Synchronous Mode",
	"1 - Asynchronous Mode",
	NULL
};

STATIC void
pick_wrfifo_enable(void)
{
	generic_pop_up(wrfifo_enable_strs, "[ Choose WRFIFO#, WR# Operation ]");
}

STATIC void
pre_wrfifo_enable(void)
{
	field_edit_menu = TRUE;
	field_edit_menu_process = pick_wrfifo_enable;
	disp_menu_pick();
}

// RDFIFO_ENABLE control - generic popup information
// Strings to display in pop-up
STATIC char *rdfifo_enable_strs[] = {
	"0 - Synchronous Mode",
	"1 - Asynchronous Mode",
	NULL
};

STATIC void
pick_rdfifo_enable(void)
{
	generic_pop_up(rdfifo_enable_strs, "[ Choose RDFIFO#, RD# Operation ]");
}

STATIC void
pre_rdfifo_enable(void)
{
	field_edit_menu = TRUE;
	field_edit_menu_process = pick_rdfifo_enable;
	disp_menu_pick();
}

// LATENCY_TIMER_TIMEOUT control - generic popup information
// Strings to display in pop-up
STATIC char *latency_timer_timeout_strs[] = {
	"0 - Disable PCI Latency Timer Timeout",
	"1 - Enable PCI Latency Timer Timeout",
	NULL
};

STATIC void
pick_latency_timer_timeout(void)
{
	generic_pop_up(latency_timer_timeout_strs,
		"[ Choose Target Latency Timer Control ]");
}

STATIC void
pre_latency_timer_timeout(void)
{
	field_edit_menu = TRUE;
	field_edit_menu_process = pick_latency_timer_timeout;
	disp_menu_pick();
}

// WRMODE control - generic popup information
// Strings to display in pop-up
STATIC char *wrmode_strs[] = {
	"0 - Disconnect On FIFO Full",
	"1 - Assert TRDY# When Full",
	NULL
};

STATIC void
pick_wrmode(void)
{
	generic_pop_up(wrmode_strs, "[ Choose WRMODE#, WR# Operation ]");
}

STATIC void
pre_wrmode(void)
{
	field_edit_menu = TRUE;
	field_edit_menu_process = pick_wrmode;
	disp_menu_pick();
}

// RDRETRY control - generic popup information
// Strings to display in pop-up
STATIC char *rdretry_strs[] = {
	"0 - Hold Data Until Read",
	"1 - Allow Flush On Next Read",
	NULL
};

STATIC void
pick_rdretry(void)
{
	generic_pop_up(rdretry_strs, "[ Choose RDRETRY#, RD# Operation ]");
}

STATIC void
pre_rdretry(void)
{
	field_edit_menu = TRUE;
	field_edit_menu_process = pick_rdretry;
	disp_menu_pick();
}

#define S5933_RDFIFO	"RDFIFO#, RD# Operation"
#define S5933_WRFIFO	"WRFIFO#, WR# Operation"
#define	S5920_RETRY		"RDRETRY#, RD# Operation"
#define	S5920_WRMODE	"WRMODE #, WR# Operation"

/*
** Edit all Location 45 bits
*/
STATIC void
edit_loc_45_config_bits(void)
{
	char latency_timer_timeout[2];
	char add_on_control[31];
	char wrfifo_enable[2];
	char rdfifo_enable[2]