nvbuild.c

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

    0x00,
    0x00,
    0x00,
    0x00,
    0x00,
    0x00,
  },

  // "Mass Storage Controller"
  {
    0x00,
    0x01,
    0x02,
    0x03,
    0x04,
    0x80,
    0x00,
    0x00,
    0x00,
  },

  // "Network Controller"
  {
    0x00,
    0x01,
    0x02,
    0x03,
    0x80,
    0x00,
    0x00,
    0x00,
    0x00,
  },

  // "Display Controller"
  {
    0x00,
    0x01,
    0x80,
    0x00,
    0x00,
    0x00,
    0x00,
    0x00,
    0x00,
  },

  // "Multimedia Device"
  {
    0x00,
    0x01,
    0x80,
    0x00,
    0x00,
    0x00,
    0x00,
    0x00,
    0x00,
  },

  // "Memory Controller"
  {
    0x00,
    0x01,
    0x80,
    0x00,
    0x00,
    0x00,
    0x00,
    0x00,
    0x00,
  },

  // "Bridge Device"
  {
    0x00,
    0x01,
    0x02,
    0x03,
    0x04,
    0x05,
    0x06,
    0x07,
    0x80,
  },

  // "Simple Communication Controller"
  {
    0x00,
    0x01,
    0x80,
    0x00,
    0x00,
    0x00,
    0x00,
    0x00,
    0x00,
  },

  // "Base System Peripheral"
  {
    0x00,
    0x01,
    0x02,
    0x03,
    0x80,
    0x00,
    0x00,
    0x00,
    0x00,
  },

  // "Input Device"
  {
    0x00,
    0x01,
    0x02,
    0x80,
    0x00,
    0x00,
    0x00,
    0x00,
    0x00,
  },

  // "Docking Station"
  {
    0x00,
    0x80,
    0x00,
    0x00,
    0x00,
    0x00,
    0x00,
    0x00,
    0x00,
  },

  // "Processor"
  {
    0x00,
    0x01,
    0x02,
    0x10,
    0x40,
    0x00,
    0x00,
    0x00,
    0x00,
  },

  // "Serial Bus Controller"
  {
    0x00,
    0x01,
    0x02,
    0x00,
    0x00,
    0x00,
    0x00,
    0x00,
    0x00,
  },

  // "Device does not fit defined class codes"
  {
    0x00,
    0x00,
    0x00,
    0x00,
    0x00,
    0x00,
    0x00,
    0x00,
    0x00,
  }
};

char *intr_pin_codes[] = {"None", "INTA#", NULL};

#define NUMBER_EXP_ROM_CODES 7

char *exp_rom_codes[] = {
	"None - Disabled",
	"2K bytes  (512 DWORDS)",
	"4K bytes  (1K DWORDS)",
	"8K bytes  (2K DWORDS)",
	"16K bytes (4K DWORDS)",
	"32K bytes (8K DWORDS)",
	"64K bytes (16K DWORDS)",
	NULL
};

dword exp_rom_values[] = {
	0x00000000L,
	0xFFFFF801L,
	0xFFFFF001L,
	0xFFFFE001L,
	0xFFFFC001L,
	0xFFFF8001L,
	0xFFFF0001L
};

#define NUMBER_EXP_ROM_CODES_5920 2

char *exp_rom_codes_5920[] = {
	"None - Disabled",
	"2K bytes  (512 DWORDS)",
	NULL
};

dword exp_rom_values_5920[] = {
	0x00000000L, 0xFFFFF801L
};

#define NUMBER_IO_BASE_ADDR 29

char *io_base_addr[] = {
	"4 bytes   ",
	"8 bytes   ",
	"16 bytes  ",
	"32 bytes  ",
	"64 bytes  ",
	"128 bytes ",
	"256 bytes ",
	"512 bytes ",
	"1 Kbytes  ",
	"2 Kbytes  ",
	"4 Kbytes  ",
	"8 Kbytes  ",
	"16 Kbytes ",
	"32 Kbytes ",
	"64 Kbytes ",
	"128 Kbytes",
	"256 Kbytes",
	"512 Kbytes",
	"1 Mbytes  ",
	"2 Mbytes  ",
	"4 Mbytes  ",
	"8 Mbytes  ",
	"16 Mbytes ",
	"32 Mbytes ",
	"64 Mbytes ",
	"128 Mbytes",
	"256 Mbytes",
	"512 Mbytes",
	"1 Gbytes  ",
	NULL
};

dword io_base_values[] = {
	0x3FFFFFFCL,
	0x3FFFFFF8L,
	0x3FFFFFF0L,
	0x3FFFFFE0L,
	0x3FFFFFC0L,
	0x3FFFFF80L,
	0x3FFFFF00L,
	0x3FFFFE00L,
	0x3FFFFC00L,
	0x3FFFF800L,
	0x3FFFF000L,
	0x3FFFE000L,
	0x3FFFC000L,
	0x3FFF8000L,
	0x3FFF0000L,
	0x3FFE0000L,
	0x3FFC0000L,
	0x3FF80000L,
	0x3FF00000L,
	0x3FE00000L,
	0x3FC00000L,
	0x3F800000L,
	0x3F000000L,
	0x3E000000L,
	0x3C000000L,
	0x38000000L,
	0x30000000L,
	0x20000000L,
	0x00000000L
};

int io_base_addr_subscr;

STATIC void
edit_base_addr(void)
{
	char ch, str[80], prefetchable[2], mem_size[9];
	enum base_type type, prev_type;
	struct _item_t *wmenu_ptr;
	int i, done;
	UINT key;

	ch = 'N';
	done = FALSE;
	wmenu_ptr = wmenuicurr();
	base_reg = wmenu_ptr->tagid - 1;

	cur_addr = cur_nvram.base_address[base_reg];

	if (base_reg && !cur_addr)
		type = DISABLE_SELECT;
	else if (cur_addr & 0x1)
		type = IO_SELECT;
	else
		type = MEMORY_SELECT;

	/* Need to over-write boot-load signature */
	if (!base_reg)
		cur_addr |= 0xffffff00L;
	prev_type = type;

	wactiv(edit_base_menu_window);
	whide();

	if (!wopen(7, 7, 21, 73, 0, menu_border_color, menu_window_color))
		error_exit(1);
	add_shadow();
	wtitle("[ Edit Base Address ]", TCENTER, menu_border_color);
	sprintf(str, "Base Address %d", base_reg);
	wcenters(1, menu_window_color, str);

	do {
		wgotoxy(3, 1);
		wclreos();   				/* Clear to end of screen */
		wputs("Base Address Type");
		wmenubegc();
		wmenuitem(3, 20, "Memory",  'M', MEMORY_SELECT,  0, NULL,
			0, H_BASE_ADDR_TYPE);
		wmenuitem(3, 28, "I/O",     'I', IO_SELECT,      0, NULL,
			0, H_BASE_ADDR_TYPE);
		if (base_reg)
			wmenuitem(3, 33, "Disabled",'D', DISABLE_SELECT, 0, NULL,
				0, H_BASE_ADDR_TYPE);
		wmenuend(type, M_HORZ, 0, 6, menu_border_color, menu_qsel_color,
			0, menu_selection_color);
		if ((type = wmenuget()) == -1 && _winfo.errno > W_ESCPRESS)
			error_exit(1);
		done = TRUE;

		if (type != prev_type) {
			cur_addr = 0x0L;
			prev_type = type;

			/* Need to over-write boot-load signature */
			if (!base_reg) {
				cur_addr = default_nvram.base_address[0];
				cur_addr |= 0xffffff00L;
			}
		}

		if (type != -1) {
			for (i = 0; i < NUMBER_PASS_THROUGHS; i++)
				if ((cur_addr >> 30) == passthru_values[i])
					passthru_width_index = i;

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

			switch (type) {
			case MEMORY_SELECT:
				memory_loc_index = cur_addr & 0x02;
				memory_loc_index >>= 1;

				membase_addr_subscr = 0;
				for (i = 0; i < NUMBER_MEM_BASE_ADDR; i++)
					if ((cur_addr & 0x3ffffff0L) == membase_val[i])
						membase_addr_subscr = i;

				wprints(5, 3, menu_window_color, "Memory Location");
				strcpy(memory_loc, memory_loc_index == 0 ? "0" : "1");
				wprints(5, 22, menu_qsel_color,
					memory_locs[memory_loc_index]);
				winpdef(5, 20, memory_loc, "<01>", 0, 2,
					check_memory_loc, H_MEMORY_LOC);
				winpfba(pre_memory_loc, post_memory_loc);

				wprints(7, 5, menu_window_color, "Prefetchable?");
				if (base_reg) {
					strcpy(prefetchable, cur_addr & 0x8L ? "Y" : "N");
					winpdef(7, 20, prefetchable, "Y", 'U', 2,
						check_y_n, H_PREFETCHABLE);
				} else {
					strcpy(prefetchable, "N");
					wprints(7, 20, LGREEN | _LGREY, "N (Unchangable)");
				}

				wprints(9, 8, menu_window_color, "Memory Size");
				if (base_reg) {
					sprintf(mem_size, "%8.8lX",
						membase_val[membase_addr_subscr]);
					wprints(9, 30, menu_qsel_color,
						membase_addr[membase_addr_subscr]);
					winpdef(9, 20, mem_size, "HHHHHHHH", 0, 2,
						check_membase_addr, H_MEMORY_SIZE);
					winpfba(pre_base_mem_size, post_base_mem_size);
				} else {
					wprints(9, 20, LGREEN | _LGREY,
						membase_addr[membase_addr_subscr]);
					wprints(9, 30, LGREEN | _LGREY,"(Unchangable)");
				}

				if (base_reg) {
					wprints(11, 1, menu_window_color, "Pass Through Width");
					passthru_width[0] = passthru_width_index + '0';
					passthru_width[1] = 0;
					wprints(11, 22, menu_qsel_color,
						passthru[passthru_width_index]);
					winpdef(11, 20, passthru_width, "<0123>", 0, 2,
						check_passthru, H_PASS_THROUGH);
					winpfba(pre_passthru_width, post_passthru_width);
				}
				break;

			case IO_SELECT:
				io_base_addr_subscr = 0;
					for (i = 0; i < NUMBER_IO_BASE_ADDR; i++)
						if ((cur_addr & 0x3ffffffcL) == io_base_values[i])
							io_base_addr_subscr = i;
				wprints(5, 8, menu_window_color, "Memory Size");
				if (base_reg) {
					sprintf(mem_size, "%8.8lX",
						io_base_values[io_base_addr_subscr]);
					wprints(5, 30, menu_qsel_color,
						io_base_addr[io_base_addr_subscr]);
					winpdef(5, 20, mem_size, "HHHHHHHH", 0, 2,
						check_io_base_addr, H_MEMORY_SIZE);
					winpfba(pre_base_io_mem_size, post_base_io_mem_size);
				} else {
					wprints(5, 20, LGREEN | _LGREY,
						io_base_addr[io_base_addr_subscr]);
					wprints(5, 30, LGREEN | _LGREY, "(Unchangable)");
				}

				if (base_reg) {
					wprints(7, 1, menu_window_color, "Pass Through Width");
					passthru_width[0] = passthru_width_index + '0';
					passthru_width[1] = 0;
					wprints(7, 22, menu_qsel_color,
						passthru[passthru_width_index]);
					winpdef(7, 20, passthru_width, "<0123>", 0, 2,
						check_passthru, H_PASS_THROUGH);
					winpfba(pre_passthru_width, post_passthru_width);
				}
				break;

			case DISABLE_SELECT:
				break;
			}

			/* 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 ((base_reg || (type == MEMORY_SELECT)) && type != DISABLE_SELECT)
			{
				if (winpread())
					break;
			}
			switch (type) {
			case MEMORY_SELECT:
				cur_addr = membase_val[membase_addr_subscr];
				if (memory_loc[0] == '1')
					cur_addr |= 0x02;
				if (prefetchable[0] == 'Y')
					cur_addr |= 0x00000008L;
				cur_addr |= (dword)passthru_values[passthru_width_index] << 30;
				break;

			case IO_SELECT:
				cur_addr = io_base_values[io_base_addr_subscr];
				cur_addr |= 0x01; /* I/O address */
				cur_addr |= (dword)passthru_values[passthru_width_index] << 30;
				break;

			case DISABLE_SELECT:
				cur_addr = 0x0L;
				break;
			}

			/* Test to see if [F10] was pressed.  If   */
			/* so, don't display confirmation message. */
			if (key == 0x4400) {
				ch = 'Y';
				done = TRUE;
			} 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();
				if ((ch = wgetchf("YN",'Y')) == 'Y')
					done = TRUE;
				wclose();
			}
		}
	} while (!done);
	wclose();

	/* Insert boot-load signature into nvram structure */
	if (base_reg == 0)
		cur_addr = (cur_addr & 0x000000FFL) | 0x10e8ff00L;

	if (ch == 'Y')
		cur_nvram.base_address[base_reg] = cur_addr;

	wunhide(edit_base_menu_window);
	update_base_addr();
}

/*
** Re-displays the base-addr menu.
*/
STATIC void
update_base_addr(void)
{
	int i, index, row, membase_addr_subscr, io_base_addr_subscr;
	dword cur_addr;

	row = 2;
	membase_addr_subscr = io_base_addr_subscr = 0;
	wprints(0, 20, menu_qsel_color,
		"                  Passthrough   Memory");
	wprints(1, 20, menu_qsel_color,
		"Type     Size        Width     Location  Prefetchable");

	for (index = 0; index < 5; index++) {
		cur_addr = cur_nvram.base_address[index];

		/* Need to over-write boot-load signature */
		if (index == 0)
			cur_addr |= 0xffffff00L;

		wgotoxy(row, 20);
		wclreol();
		if (cur_addr == 0x0L)
			printf("Disabled");
		else {
			if (cur_addr & 0x01) {
				for (i = 0; i < NUMBER_IO_BASE_ADDR; i++)
					if ((cur_addr & 0x3ffffffcL) == io_base_values[i])
						io_base_addr_subscr = i;
				cxl_wprintf("I/O    %s  ", io_base_addr[io_base_addr_subscr]);
			} else {
				for (i = 0; i < NUMBER_MEM_BASE_ADDR; i++)
					if ((cur_addr & 0x3ffffff0L) == membase_val[i])
						membase_addr_subscr = i;
				cxl_wprintf("Memory %s  ", membase_addr[membase_addr_subscr]);
			}
			if (index)
				cxl_wprintf("%s ",