archive
/
windows-server-2003
mirror of https://github.com/selfrender/Windows-Server-2003
2
0
Fork 0
Code Issues Projects Releases Wiki Activity
Leaked source code of windows server 2003
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
4 Commits
1 Branch
0 Tags
1.5 GiB
 
 
 
 
 
 
Tree: 5c6fe3db62
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from '5c6fe3db62'
${ noResults }
windows-server-2003/base/pnp/tools/pcisim/softpci/exe/devdlg.c

1347 lines
35 KiB
Raw Blame History

#include "pch.h"
#include "dialogp.h"
HWND g_NewDevDlg;
PSOFTPCI_DEVICE g_NewDevice;
PHPS_HWINIT_DESCRIPTOR g_HPSInitDesc;
PPCI_DN g_ParentPdn;
ULONG g_PossibleDeviceNums;
#define HPS_HWINIT_OFFSET 0x4a
#define HPS_MAX_SLOTS 0x1f //Max number of slots for each type
#define HPS_MAX_SLOT_LABEL 0xff //Max number to start slot labeling
struct _BAR_CONTROL{
INT tb;
INT mrb;
INT irb;
INT pref;
INT bit64;
INT tx;
ULONG Bar;
}BarControl[PCI_TYPE0_ADDRESSES] = {
{IDC_BAR0_TB, IDC_BAR0MEM_RB, IDC_BAR0IO_RB, IDC_BAR0_PREF_XB, IDC_BAR0_64BIT_XB, IDC_SLIDER0_TX, 0},
{IDC_BAR1_TB, IDC_BAR1MEM_RB, IDC_BAR1IO_RB, IDC_BAR1_PREF_XB, IDC_BAR1_64BIT_XB, IDC_SLIDER1_TX, 0},
{IDC_BAR2_TB, IDC_BAR2MEM_RB, IDC_BAR2IO_RB, IDC_BAR2_PREF_XB, IDC_BAR2_64BIT_XB, IDC_SLIDER2_TX, 0},
{IDC_BAR3_TB, IDC_BAR3MEM_RB, IDC_BAR3IO_RB, IDC_BAR3_PREF_XB, IDC_BAR3_64BIT_XB, IDC_SLIDER3_TX, 0},
{IDC_BAR4_TB, IDC_BAR4MEM_RB, IDC_BAR4IO_RB, IDC_BAR4_PREF_XB, IDC_BAR4_64BIT_XB, IDC_SLIDER4_TX, 0},
{IDC_BAR5_TB, IDC_BAR5MEM_RB, IDC_BAR5IO_RB, IDC_BAR5_PREF_XB, 0, IDC_SLIDER5_TX, 0 }
};
INT_PTR
CALLBACK
SoftPCI_NewDevDlgProc(
IN HWND Dlg,
IN UINT Msg,
IN WPARAM wParam,
IN LPARAM lParam
)
/*++
Routine Description:
Dialog handling routine for new device creation
Arguments:
Return Value:
--*/
{
BOOL rc = FALSE;
LONG width, height, i;
RECT mainRect, dlgRect;
HWND devtype;
WCHAR buffer[256];
LONG_PTR dlgstyle;
PPCI_DN pdn = (PPCI_DN)lParam;
PPCI_DN bridgePdn;
PHPS_HWINIT_DESCRIPTOR hotplugData;
switch ( Msg ) {
case WM_INITDIALOG:
SOFTPCI_ASSERT(pdn != NULL);
if (pdn == NULL) {
PostMessage(Dlg, WM_CLOSE, 0, 0);
break;
}
//
// Allocate a new device. We will fill this out as the user selects
// options.
//
g_NewDevice = (PSOFTPCI_DEVICE) calloc(1, sizeof(SOFTPCI_DEVICE));
if (!g_NewDevice) {
MessageBox(Dlg, L"Failed to allocate memory for new device!",
NULL, MB_OK | MB_ICONEXCLAMATION);
SoftPCI_ResetNewDevDlg();
return FALSE;
}
g_ParentPdn = pdn;
g_PossibleDeviceNums = SoftPCI_GetPossibleDevNumMask(g_ParentPdn);
//
// Clear our BarControl BARS
//
for (i=0; i < PCI_TYPE0_ADDRESSES; i++) {
BarControl[i].Bar = 0;
}
//
// Grab the bus we are going to reside on
//
bridgePdn = pdn;
while (bridgePdn->SoftDev == NULL) {
bridgePdn = bridgePdn->Parent;
}
g_NewDevice->Bus = bridgePdn->SoftDev->Config.Current.u.type1.SecondaryBus;
//
// Initialize our drop list
//
devtype = GetDlgItem(Dlg, IDC_DEVTYPE_CB);
SendMessage(devtype, CB_ADDSTRING, 0L, (LPARAM) L"DEVICE");
SendMessage(devtype, CB_ADDSTRING, 0L, (LPARAM) L"PCI BRIDGE");
SendMessage(devtype, CB_ADDSTRING, 0L, (LPARAM) L"HOTPLUG BRIDGE");
SendMessage(devtype, CB_ADDSTRING, 0L, (LPARAM) L"CARDBUS DEVICE");
SendMessage(devtype, CB_ADDSTRING, 0L, (LPARAM) L"CARDBUS BRIDGE");
SetFocus(devtype);
//
// Set the Window size
//
GetWindowRect(g_SoftPCIMainWnd, &mainRect );
GetWindowRect(Dlg, &dlgRect );
width = (mainRect.right - mainRect.left) + 30;
height = (mainRect.bottom - mainRect.top);
dlgRect.right -= dlgRect.left;
dlgRect.bottom -= dlgRect.top;
//MoveWindow(Dlg, mainRect.right, mainRect.top, dlgRect.right, dlgRect.bottom, TRUE );
MoveWindow(Dlg, mainRect.left, mainRect.top, dlgRect.right, dlgRect.bottom, TRUE );
g_NewDevDlg = Dlg;
break;
HANDLE_MSG(Dlg, WM_COMMAND, SoftPCI_DlgOnCommand);
case WM_HSCROLL:
HANDLE_TRACKBAR(wParam, lParam);
//SoftPCI_HandleTrackBar(Dlg, wParam, lParam);
break;
case WM_VSCROLL:
HANDLE_SPINNER(wParam, lParam);
//HANDLE_TRACKBAR(wParam, lParam);
//SoftPCI_HandleTrackBar(Dlg, wParam, lParam);
break;
case WM_CLOSE:
g_NewDevDlg = 0;
if (g_NewDevice) {
free(g_NewDevice);
}
EndDialog(Dlg, 0);
break;
default:
break;
}
return rc; //DefDlgProc(Dlg, Msg, wParam, lParam);
}
ULONG
SoftPCI_GetPossibleDevNumMask(
IN PPCI_DN ParentDn
)
{
HPS_HWINIT_DESCRIPTOR hpData;
BOOL status;
if (!ParentDn->SoftDev) {
return 0;
}
if (ParentDn->Flags & SOFTPCI_HOTPLUG_CONTROLLER) {
//
// For hotplug bridges, we remove any hotplug slots, because devices
// have to be children of the slot objects to be in hotplug slots.
//
status = SoftPCI_GetHotplugData(ParentDn,
&hpData
);
if (!status) {
return 0;
} else {
return (((ULONG)(-1)) -
((ULONG)(1 << (hpData.FirstDeviceID + hpData.NumSlots)) - 1) +
((ULONG)(1 << (hpData.FirstDeviceID)) - 1));
}
} else if (ParentDn->Flags & SOFTPCI_HOTPLUG_SLOT) {
//
// The only legal device number is the one controlled by this slot.
//
return (1 << ParentDn->Slot.Device);
} else {
return (ULONG)-1;
}
}
VOID
SoftPCI_DisplayDlgOptions(
IN SOFTPCI_DEV_TYPE DevType
)
{
HWND control, bargroup;
ULONG i;
RECT barRect, dlgRect, rect;
LONG width, height;
POINT pt;
WCHAR buffer[100];
SoftPCI_ResetNewDevDlg();
SoftPCI_ShowCommonNewDevDlg();
bargroup = GetDlgItem(g_NewDevDlg, IDC_BARS_GB);
GetClientRect(bargroup, &barRect);
width = barRect.right - barRect.left;
height = barRect.bottom - barRect.top;
//
// Disable our Bars until something is selected.
//
for (i=0; i < PCI_TYPE0_ADDRESSES; i++) {
control = GetDlgItem(g_NewDevDlg, BarControl[i].tb);
SoftPCI_DisableWindow(control);
control = GetDlgItem(g_NewDevDlg, BarControl[i].tx);
SoftPCI_DisableWindow(control);
control = GetDlgItem(g_NewDevDlg, BarControl[i].pref);
SoftPCI_DisableWindow(control);
control = GetDlgItem(g_NewDevDlg, BarControl[i].bit64);
SoftPCI_DisableWindow(control);
}
SoftPCI_ResetLowerBars(-1);
//
// We want this checked by default for now....
//
CheckDlgButton(g_NewDevDlg, IDC_DEFAULTDEV_XB, BST_CHECKED);
//
// Start with a clean configspace
//
RtlZeroMemory(&g_NewDevice->Config.Current, (sizeof(PCI_COMMON_CONFIG) * 3));
switch (DevType) {
case TYPE_DEVICE:
for (i = IDC_BAR2_TB; i < IDC_BRIDGEWIN_GB; i++) {
control = GetDlgItem(g_NewDevDlg, i);
if (control) {
SoftPCI_ShowWindow(control);
}
}
SoftPCI_InitializeDevice(g_NewDevice, TYPE_DEVICE);
height = 215;
break;
case TYPE_PCI_BRIDGE:
for (i = IDC_DECODE_GB; i < LAST_CONTROL_ID; i++) {
control = GetDlgItem(g_NewDevDlg, i);
if (control) {
SoftPCI_ShowWindow(control);
}
}
SoftPCI_InitializeDevice(g_NewDevice, TYPE_PCI_BRIDGE);
//
// update the height of our bar group box
//
height = 78;
break;
case TYPE_HOTPLUG_BRIDGE:
for (i=IDC_ATTBTN_XB; i < LAST_CONTROL_ID; i++) {
control = GetDlgItem(g_NewDevDlg, i);
if (control) {
SoftPCI_ShowWindow(control);
}
}
//
// Allocate our HPS Descriptor
//
g_HPSInitDesc = (PHPS_HWINIT_DESCRIPTOR)((PUCHAR)&g_NewDevice->Config.Current + HPS_HWINIT_OFFSET);
g_HPSInitDesc->ProgIF = 1;
SoftPCI_InitializeHotPlugControls();
SoftPCI_InitializeDevice(g_NewDevice, TYPE_HOTPLUG_BRIDGE);
//
// update the height of our bar group box
//
height = 78;
break;
case TYPE_CARDBUS_DEVICE:
case TYPE_CARDBUS_BRIDGE:
//
// These are currently not implemented yet....
//
SoftPCI_ResetNewDevDlg();
control = GetDlgItem(g_NewDevDlg, IDC_NEWDEVINFO_TX);
SoftPCI_ShowWindow(control);
SetWindowText (control, L"DEVICE TYPE NOT IMPLEMENTED YET");
break;
}
//
// Update our various window positions
//
SetWindowPos(bargroup, HWND_TOP, 0, 0, width, height, SWP_NOMOVE | SWP_NOZORDER);
}
VOID
SoftPCI_DlgOnCommand(
IN HWND Wnd,
IN INT ControlID,
IN HWND ControlWnd,
IN UINT NotificationCode
)
{
SOFTPCI_DEV_TYPE selection = 0;
switch (ControlID){
case IDC_DEVTYPE_CB:
switch (NotificationCode){
case CBN_SELENDOK:
selection = SendDlgItemMessage(Wnd,
IDC_DEVTYPE_CB,
CB_GETCURSEL,
(WPARAM) 0,
(LPARAM) 0
);
SoftPCI_DisplayDlgOptions(selection);
break;
default:
break;
}
//
// Handle our CheckBoxes
//
case IDC_SAVETOREG_XB:
case IDC_DEFAULTDEV_XB:
case IDC_MEMENABLE_XB:
case IDC_IOENABLE_XB:
case IDC_BUSMSTR_XB:
case IDC_BAR0_PREF_XB:
case IDC_BAR0_64BIT_XB:
case IDC_BAR1_PREF_XB:
case IDC_BAR1_64BIT_XB:
case IDC_BAR2_PREF_XB:
case IDC_BAR2_64BIT_XB:
case IDC_BAR3_PREF_XB:
case IDC_BAR3_64BIT_XB:
case IDC_BAR4_PREF_XB:
case IDC_BAR4_64BIT_XB:
case IDC_BAR5_PREF_XB:
case IDC_POSDECODE_XB:
case IDC_SUBDECODE_XB:
case IDC_ATTBTN_XB:
case IDC_MRL_XB:
SoftPCI_HandleCheckBox(ControlWnd, ControlID, NotificationCode);
break;
//
// Handle our TrackBar/Sliders
//
case IDC_BAR0_TB:
case IDC_BAR1_TB:
case IDC_BAR2_TB:
case IDC_BAR3_TB:
case IDC_BAR4_TB:
case IDC_BAR5_TB:
case IDC_BRIDGEMEM_TB:
case IDC_BRIDGEIO_TB:
break;
//
// Handle the Radio Buttons
//
case IDC_BAR0IO_RB:
case IDC_BAR0MEM_RB:
case IDC_BAR1IO_RB:
case IDC_BAR1MEM_RB:
case IDC_BAR2IO_RB:
case IDC_BAR2MEM_RB:
case IDC_BAR3IO_RB:
case IDC_BAR3MEM_RB:
case IDC_BAR4IO_RB:
case IDC_BAR4MEM_RB:
case IDC_BAR5IO_RB:
case IDC_BAR5MEM_RB:
SoftPCI_HandleRadioButton(ControlWnd, ControlID, NotificationCode);
break;
case IDC_SLOTLABELUP_RB:
g_HPSInitDesc->UpDown = 1;
break;
case IDC_SLOTLABELDN_RB:
g_HPSInitDesc->UpDown = 0;
break;
//
// Handle our Edit boxes (attached to our spinners)
//
case IDC_33CONV_EB:
case IDC_66CONV_EB:
case IDC_66PCIX_EB:
case IDC_100PCIX_EB:
case IDC_133PCIX_EB:
case IDC_ALLSLOTS_EB:
case IDC_1STDEVSEL_EB:
case IDC_1STSLOTLABEL_EB:
if (g_HPSInitDesc && (NotificationCode == EN_CHANGE)) {
//
// ISSUE: This should probably be done some other way as this
// makes us dependant on the numbering in resource.h
//
SoftPCI_HandleSpinnerControl(GetDlgItem(g_NewDevDlg, ControlID+1), SB_ENDSCROLL, 0);
}
break;
case IDC_INSTALL_BUTTON:
//
// Add code to vaildate selection and install new device.
//
if (NotificationCode == BN_CLICKED) {
SoftPCI_HandleDlgInstallDevice(Wnd);
PostMessage(Wnd, WM_CLOSE, 0, 0);
}
break;
case IDC_CANCEL_BUTTON:
if (NotificationCode == BN_CLICKED) {
//
// User wants to Cancel creation of new device
//
PostMessage(Wnd, WM_CLOSE, 0, 0);
}
break;
default:
break;
}
}
VOID
SoftPCI_HandleCheckBox(
IN HWND Wnd,
IN INT ControlID,
IN UINT NotificationCode
)
{
HWND control;
BOOL isChecked;
ULONG barIndex = 0;
isChecked = (BOOL)IsDlgButtonChecked(g_NewDevDlg, ControlID);
if (!SoftPCI_GetAssociatedBarControl(ControlID, &barIndex)){
//
// Not sure what I should do here...
//
}
if (NotificationCode == BN_CLICKED) {
switch (ControlID) {
case IDC_SAVETOREG_XB:
//
// ISSUE: Add code here to save device selection to registry.
//
MessageBox(NULL, L"This is still under developement...", L"NOT IMPLEMENTED YET", MB_OK | MB_ICONEXCLAMATION);
SoftPCI_UnCheckDlgBox(Wnd);
SoftPCI_DisableWindow(Wnd);
break;
case IDC_DEFAULTDEV_XB:
MessageBox(NULL, L"This is still under developement...", L"NOT FULLY IMPLEMENTED YET", MB_OK | MB_ICONEXCLAMATION);
SoftPCI_CheckDlgBox(Wnd);
break;
//
// Now deal with our Command Register
//
case IDC_MEMENABLE_XB:
if (isChecked) {
g_NewDevice->Config.Current.Command |= PCI_ENABLE_MEMORY_SPACE;
}else{
g_NewDevice->Config.Current.Command &= ~PCI_ENABLE_MEMORY_SPACE;
}
break;
case IDC_IOENABLE_XB:
if (isChecked) {
g_NewDevice->Config.Current.Command |= PCI_ENABLE_IO_SPACE;
}else{
g_NewDevice->Config.Current.Command &= ~PCI_ENABLE_IO_SPACE;
}
break;
case IDC_BUSMSTR_XB:
if (isChecked) {
g_NewDevice->Config.Current.Command |= PCI_ENABLE_BUS_MASTER;
}else{
g_NewDevice->Config.Current.Command &= ~PCI_ENABLE_BUS_MASTER;
}
break;
case IDC_BAR0_PREF_XB:
case IDC_BAR1_PREF_XB:
case IDC_BAR2_PREF_XB:
case IDC_BAR3_PREF_XB:
case IDC_BAR4_PREF_XB:
case IDC_BAR5_PREF_XB:
if (isChecked) {
BarControl[barIndex].Bar |= PCI_ADDRESS_MEMORY_PREFETCHABLE;
g_NewDevice->Config.Mask.u.type0.BaseAddresses[barIndex] |= PCI_ADDRESS_MEMORY_PREFETCHABLE;
}else{
BarControl[barIndex].Bar &= ~PCI_ADDRESS_MEMORY_PREFETCHABLE;
g_NewDevice->Config.Mask.u.type0.BaseAddresses[barIndex] &= ~PCI_ADDRESS_MEMORY_PREFETCHABLE;
}
//SendMessage(g_NewDevDlg, WM_HSCROLL, (WPARAM)SB_THUMBPOSITION, (LPARAM)Wnd);
break;
case IDC_BAR0_64BIT_XB:
case IDC_BAR1_64BIT_XB:
case IDC_BAR2_64BIT_XB:
case IDC_BAR3_64BIT_XB:
case IDC_BAR4_64BIT_XB:
SoftPCI_ResetLowerBars(barIndex);
if (isChecked) {
//
// Disable the next BAR
//
control = GetDlgItem(g_NewDevDlg, BarControl[barIndex+1].mrb);
SoftPCI_UnCheckDlgBox(control);
SoftPCI_DisableWindow(control);
control = GetDlgItem(g_NewDevDlg, BarControl[barIndex+1].irb);
SoftPCI_UnCheckDlgBox(control);
SoftPCI_DisableWindow(control);
control = GetDlgItem(g_NewDevDlg, BarControl[barIndex+1].pref);
SoftPCI_UnCheckDlgBox(control);
SoftPCI_DisableWindow(control);
control = GetDlgItem(g_NewDevDlg, BarControl[barIndex+1].bit64);
SoftPCI_UnCheckDlgBox(control);
SoftPCI_DisableWindow(control);
control = GetDlgItem(g_NewDevDlg, BarControl[barIndex+1].tb);
SoftPCI_ResetTrackBar(control);
SoftPCI_DisableWindow(control);
control = GetDlgItem(g_NewDevDlg, BarControl[barIndex+1].tx);
SoftPCI_DisableWindow(control);
BarControl[barIndex].Bar |= PCI_TYPE_64BIT;
}else{
//
// Enable next BAR
//
control = GetDlgItem(g_NewDevDlg, BarControl[barIndex+1].mrb);
SoftPCI_UnCheckDlgBox(control);
SoftPCI_EnableWindow(control);
control = GetDlgItem(g_NewDevDlg, BarControl[barIndex+1].irb);
SoftPCI_UnCheckDlgBox(control);
SoftPCI_EnableWindow(control);
BarControl[barIndex].Bar &= ~PCI_TYPE_64BIT;
}
SoftPCI_InitializeBar(barIndex);
break;
case IDC_ATTBTN_XB:
case IDC_MRL_XB:
if (isChecked) {
g_HPSInitDesc->MRLSensorsImplemented = 1;
g_HPSInitDesc->AttentionButtonImplemented = 1;
}else{
g_HPSInitDesc->MRLSensorsImplemented = 0;
g_HPSInitDesc->AttentionButtonImplemented = 0;
}
break;
case IDC_POSDECODE_XB:
case IDC_SUBDECODE_XB:
SOFTPCI_ASSERT(IS_BRIDGE(g_NewDevice));
if (isChecked) {
g_NewDevice->Config.Current.ProgIf = 0x1;
g_NewDevice->Config.Mask.ProgIf = 0x1;
}else{
g_NewDevice->Config.Current.ProgIf = 0;
g_NewDevice->Config.Mask.ProgIf = 0;
}
break;
}
}
}
VOID
SoftPCI_HandleDlgInstallDevice(
IN HWND Wnd
)
{
BOOL defaultDev = FALSE;
SOFTPCI_DEV_TYPE selection = 0;
SOFTPCI_ASSERTMSG("Attempting to install a NULL device!\n\nHave BrandonA check this out!!",
(g_NewDevice != NULL));
if (!g_NewDevice){
return;
}
//
// If we're inserting in a hotplug slot, store the device away
// in hpsim and return without telling softpci.sys about it.
//
if (g_ParentPdn->Flags & SOFTPCI_HOTPLUG_SLOT) {
g_NewDevice->Slot.Device = g_ParentPdn->Slot.Device;
SoftPCI_AddHotplugDevice(g_ParentPdn->Parent,
g_NewDevice
);
SoftPCI_CreateTreeView();
return;
}
switch (g_NewDevice->DevType) {
case TYPE_CARDBUS_DEVICE:
case TYPE_CARDBUS_BRIDGE:
MessageBox(Wnd, L"This device type has not been implemented fully!",
L"NOT IMPLEMENTED YET", MB_OK | MB_ICONEXCLAMATION);
return;
}
#if DBG
if ((IS_BRIDGE(g_NewDevice)) &&
((g_NewDevice->Config.Mask.u.type1.PrimaryBus == 0) ||
(g_NewDevice->Config.Mask.u.type1.SecondaryBus == 0) ||
(g_NewDevice->Config.Mask.u.type1.SubordinateBus == 0))){
SOFTPCI_ASSERTMSG("A bus number config mask is zero!",
((g_NewDevice->Config.Mask.u.type1.PrimaryBus != 0) ||
(g_NewDevice->Config.Mask.u.type1.SecondaryBus != 0) ||
(g_NewDevice->Config.Mask.u.type1.SubordinateBus != 0)));
return;
}
#endif
defaultDev = IsDlgButtonChecked(Wnd , IDC_DEFAULTDEV_XB);
if (!SoftPCI_CreateDevice(g_NewDevice, g_PossibleDeviceNums, FALSE)){
MessageBox(Wnd, L"Failed to install specified SoftPCI device.....", L"ERROR", MB_OK);
}
}
VOID
SoftPCI_HandleRadioButton(
IN HWND Wnd,
IN INT ControlID,
IN UINT NotificationCode
)
{
HWND control;
ULONG i = 0;
if (!SoftPCI_GetAssociatedBarControl(ControlID, &i)){
//
// Not sure what I should do here...
//
SOFTPCI_ASSERTMSG("SoftPCI_GetAssociatedBarControl() failed!", FALSE);
}
if (NotificationCode == BN_CLICKED) {
switch (ControlID) {
case IDC_BAR0IO_RB:
case IDC_BAR1IO_RB:
case IDC_BAR2IO_RB:
case IDC_BAR3IO_RB:
case IDC_BAR4IO_RB:
case IDC_BAR5IO_RB:
control = GetDlgItem(g_NewDevDlg, BarControl[i].tb);
SoftPCI_EnableWindow(control);
control = GetDlgItem(g_NewDevDlg, BarControl[i].tx);
SoftPCI_EnableWindow(control);
control = GetDlgItem(g_NewDevDlg, BarControl[i].pref);
SoftPCI_UnCheckDlgBox(control);
SoftPCI_DisableWindow(control);
control = GetDlgItem(g_NewDevDlg, BarControl[i].bit64);
//
// Reset the bars below this one if it was
// set to 64 bit mem bar
//
if (IsDlgButtonChecked(g_NewDevDlg, BarControl[i].bit64)) {
SoftPCI_ResetLowerBars(i);
}
SoftPCI_UnCheckDlgBox(control);
SoftPCI_DisableWindow(control);
//
// Initialize BAR
//
BarControl[i].Bar |= PCI_ADDRESS_IO_SPACE;
SoftPCI_InitializeBar(i);
break;
case IDC_BAR0MEM_RB:
case IDC_BAR1MEM_RB:
case IDC_BAR2MEM_RB:
case IDC_BAR3MEM_RB:
case IDC_BAR4MEM_RB:
case IDC_BAR5MEM_RB:
//
// Initialize BAR
//
BarControl[i].Bar &= ~PCI_ADDRESS_IO_SPACE;
SoftPCI_InitializeBar(i);
control = GetDlgItem(g_NewDevDlg, BarControl[i].tb);
SoftPCI_EnableWindow(control);
control = GetDlgItem(g_NewDevDlg, BarControl[i].tx);
SoftPCI_EnableWindow(control);
control = GetDlgItem(g_NewDevDlg, BarControl[i].pref);
SoftPCI_EnableWindow(control);
if (g_NewDevice &&
IS_BRIDGE(g_NewDevice) &&
ControlID == IDC_BAR1MEM_RB) {
//
// We only have two BARs on a bridge and therefore cannot
// allow the second bar to set 64Bit.
//
break;
}
control = GetDlgItem(g_NewDevDlg, BarControl[i].bit64);
SoftPCI_EnableWindow(control);
break;
}
}
}
VOID
SoftPCI_HandleTrackBar(
IN HWND Wnd,
IN WORD NotificationCode,
IN WORD CurrentPos
)
{
HWND sliderWnd;
UINT controlID;
ULONG currentPos = 0;
WCHAR buffer[MAX_PATH];
ULONG barIndex = 0, *pbar = NULL, saveBar = 0;
ULONGLONG bar = 0, barMask = 0, barSize = 0;
SOFTPCI_ASSERTMSG("Attempting to init a NULL device!\n\nHave BrandonA check this out!!",
(g_NewDevice != NULL));
if (!g_NewDevice){
return;
}
switch (NotificationCode) {
case SB_ENDSCROLL:
case SB_THUMBPOSITION:
case SB_THUMBTRACK:
controlID = GetDlgCtrlID(Wnd);
if ((controlID == IDC_BRIDGEMEM_TB) || (controlID == IDC_BRIDGEIO_TB)) {
//
// Implement this...
//
return;
}
if (!SoftPCI_GetAssociatedBarControl(controlID, &barIndex)){
//
// Not sure what I should do here...
//
}
sliderWnd = GetDlgItem(g_NewDevDlg, BarControl[barIndex].tx);
//
// Save our current Bar value so we can restore any important bits after we
// mangle it.
//
saveBar = BarControl[barIndex].Bar;
//
// Set intial BAR values
//
if (BarControl[barIndex].Bar & PCI_ADDRESS_IO_SPACE) {
bar = PCI_ADDRESS_IO_ADDRESS_MASK;
}else{
bar = PCI_ADDRESS_MEMORY_ADDRESS_MASK;
}
//
// Get the current position of the slider
//
currentPos = (ULONG) SoftPCI_GetTrackBarPosition(Wnd);
//
// Fill in the rest of the BAR if we are dealing with 64 bit
//
if ((BarControl[barIndex].Bar & PCI_TYPE_64BIT)) {
pbar = &((ULONG)bar);
pbar++;
*pbar = 0xffffffff;
}
//
// Shift the bar by the sliders returned position
//
bar <<= currentPos;
barMask = bar;
//
// Update our Bar Control for this bar
//
if (saveBar & PCI_ADDRESS_IO_SPACE) {
bar &= 0xffff;
barMask &= 0xffff;
bar |= PCI_ADDRESS_IO_SPACE;
} else {
bar |= (saveBar & (PCI_ADDRESS_MEMORY_TYPE_MASK | PCI_ADDRESS_MEMORY_PREFETCHABLE));
}
if (IS_BRIDGE(g_NewDevice)){
g_NewDevice->Config.Current.u.type1.BaseAddresses[barIndex] = (ULONG)bar;
g_NewDevice->Config.Mask.u.type1.BaseAddresses[barIndex] = (ULONG) barMask;
SOFTPCI_ASSERTMSG("A bus number config mask is zero!",
((g_NewDevice->Config.Mask.u.type1.PrimaryBus != 0) ||
(g_NewDevice->Config.Mask.u.type1.SecondaryBus != 0) ||
(g_NewDevice->Config.Mask.u.type1.SubordinateBus != 0)));
}else{
g_NewDevice->Config.Current.u.type0.BaseAddresses[barIndex] = (ULONG)bar;
g_NewDevice->Config.Mask.u.type0.BaseAddresses[barIndex] = (ULONG) barMask ;
}
GetDlgItem(g_NewDevDlg, BarControl[barIndex].tx);
//
// Update the next bar if we are dealing with 64 bit
//
if ((BarControl[barIndex].Bar & PCI_TYPE_64BIT)) {
g_NewDevice->Config.Mask.u.type0.BaseAddresses[barIndex+1] = (ULONG)(bar >> 32);
}
//
// Get the size so we can display its current setting
//
barSize = SoftPCI_GetLengthFromBar(bar);
SOFTPCI_ASSERT(barSize != 0);
//
// Update our sliders text field
//
SoftPCI_UpdateBarText(buffer, barSize);
SetWindowText (sliderWnd, buffer);
break;
default:
break;
}
}
VOID
SoftPCI_HandleSpinnerControl(
IN HWND Wnd,
IN WORD NotificationCode,
IN WORD CurrentPos
)
{
SOFTPCI_ASSERTMSG("Attempting to init a NULL device!\n\nHave BrandonA check this out!!",
(g_NewDevice != NULL));
if (!g_NewDevice){
PostMessage(g_NewDevDlg, WM_CLOSE, 0, 0);
}
switch (NotificationCode) {
case SB_ENDSCROLL:
case SB_THUMBPOSITION:
switch (GetDlgCtrlID(Wnd)) {
case IDC_33CONV_SP:
g_HPSInitDesc->NumSlots33Conv = (WORD) SoftPCI_GetSpinnerValue(Wnd);
break;
case IDC_66CONV_SP:
g_HPSInitDesc->NumSlots66Conv = (WORD) SoftPCI_GetSpinnerValue(Wnd);
break;
case IDC_66PCIX_SP:
g_HPSInitDesc->NumSlots66PciX = (WORD) SoftPCI_GetSpinnerValue(Wnd);
break;
case IDC_100PCIX_SP:
g_HPSInitDesc->NumSlots100PciX = (WORD) SoftPCI_GetSpinnerValue(Wnd);
break;
case IDC_133PCIX_SP:
g_HPSInitDesc->NumSlots133PciX = (WORD) SoftPCI_GetSpinnerValue(Wnd);
break;
case IDC_ALLSLOTS_SP:
g_HPSInitDesc->NumSlots = (WORD) SoftPCI_GetSpinnerValue(Wnd);
break;
case IDC_1STDEVSEL_SP:
g_HPSInitDesc->FirstDeviceID = (UCHAR) SoftPCI_GetSpinnerValue(Wnd);
break;
case IDC_1STSLOTLABEL_SP:
g_HPSInitDesc->FirstSlotLabelNumber = (UCHAR)SoftPCI_GetSpinnerValue(Wnd);
break;
default:
break;
}
}
}
VOID
SoftPCI_InitializeBar(
IN INT Bar
)
{
HWND control;
WCHAR buffer[50];
ULONGLONG bar64 = 0;
//
// Get the track bar associated with this bar
//
control = GetDlgItem(g_NewDevDlg, BarControl[Bar].tb);
if (BarControl[Bar].Bar & PCI_ADDRESS_IO_SPACE) {
//
// IO Bar
//
SendMessage(control, TBM_SETRANGE, (WPARAM)TRUE, (LPARAM)MAKELONG(0, 6));
SendMessage(control, TBM_SETPOS, (WPARAM)TRUE, 0);
SendMessage(g_NewDevDlg, WM_HSCROLL, (WPARAM)SB_THUMBPOSITION, (LPARAM)control);
}else{
//
// Mem Bar
//
control = GetDlgItem(g_NewDevDlg, BarControl[Bar].tb);
if (IsDlgButtonChecked(g_NewDevDlg, BarControl[Bar].bit64)) {
//
// Init this as 64 bit bar. Bit Range 0 - 60
//
SendMessage(control, TBM_SETRANGE, (WPARAM)TRUE, (LPARAM)MAKELONG(0, 59));
SendMessage(control, TBM_SETPOS, (WPARAM)TRUE, 0);
SendMessage(g_NewDevDlg, WM_HSCROLL, (WPARAM)SB_THUMBPOSITION, (LPARAM)control);
}else{
//
// Standard 32bit bar. Bit Range 0 - 28
//
SendMessage(control, TBM_SETRANGE, (WPARAM)TRUE, (LPARAM)MAKELONG(0, 27));
SendMessage(control, TBM_SETPOS, (WPARAM)TRUE, 0);
SendMessage(g_NewDevDlg, WM_HSCROLL, (WPARAM)SB_THUMBPOSITION, (LPARAM)control);
}
}
}
VOID
SoftPCI_InitializeHotPlugControls(
VOID
)
{
INT controlID = IDC_ATTBTN_XB;
HWND controlWnd;
while (controlID < LAST_CONTROL_ID) {
controlWnd = GetDlgItem(g_NewDevDlg, controlID);
switch (controlID) {
case IDC_ATTBTN_XB:
case IDC_MRL_XB:
SoftPCI_CheckDlgBox(controlWnd);
g_HPSInitDesc->MRLSensorsImplemented = 1;
g_HPSInitDesc->AttentionButtonImplemented = 1;
break;
//
// init our Spinners
//
case IDC_33CONV_SP:
case IDC_66CONV_SP:
case IDC_66PCIX_SP:
case IDC_100PCIX_SP:
case IDC_133PCIX_SP:
case IDC_ALLSLOTS_SP:
case IDC_1STDEVSEL_SP:
SoftPCI_InitSpinnerControl(controlWnd, 0, HPS_MAX_SLOTS, 0);
//if (controlID == IDC_1STDEVSEL_SP) {
// SendMessage(GetDlgItem(g_NewDevDlg, controlID), UDM_SETBASE, (WPARAM) 16, 0);
//}
break;
case IDC_1STSLOTLABEL_SP:
SoftPCI_InitSpinnerControl(controlWnd, 0, HPS_MAX_SLOT_LABEL, 1);
break;
case IDC_SLOTLABELUP_RB:
SoftPCI_CheckDlgBox(controlWnd);
g_HPSInitDesc->UpDown = 1;
break;
case IDC_33CONV_EB:
case IDC_66CONV_EB:
case IDC_66PCIX_EB:
case IDC_100PCIX_EB:
case IDC_133PCIX_EB:
case IDC_ALLSLOTS_EB:
case IDC_1STDEVSEL_EB:
case IDC_1STSLOTLABEL_EB:
break;
default:
break;
}
controlID++;
}
}
BOOL
SoftPCI_GetAssociatedBarControl(
IN INT ControlID,
OUT INT *Bar
)
{
INT i = 0;
*Bar = 0;
for (i=0; i < PCI_TYPE0_ADDRESSES; i++ ) {
if ((ControlID == BarControl[i].tb) ||
(ControlID == BarControl[i].mrb) ||
(ControlID == BarControl[i].irb) ||
(ControlID == BarControl[i].pref) ||
(ControlID == BarControl[i].bit64) ||
(ControlID == BarControl[i].tx)) {
*Bar = i;
return TRUE;
}
}
return FALSE;
}
VOID
SoftPCI_ResetLowerBars(
IN INT Bar
)
{
INT i;
HWND control;
WCHAR buffer[10];
for (i = Bar+1; i < PCI_TYPE0_ADDRESSES; i++ ) {
control = GetDlgItem(g_NewDevDlg, BarControl[i].mrb);
SoftPCI_UnCheckDlgBox(control);
SoftPCI_EnableWindow(control);
control = GetDlgItem(g_NewDevDlg, BarControl[i].irb);
SoftPCI_UnCheckDlgBox(control);
SoftPCI_EnableWindow(control);
control = GetDlgItem(g_NewDevDlg, BarControl[i].pref);
SoftPCI_UnCheckDlgBox(control);
SoftPCI_DisableWindow(control);
control = GetDlgItem(g_NewDevDlg, BarControl[i].bit64);
SoftPCI_UnCheckDlgBox(control);
SoftPCI_DisableWindow(control);
control = GetDlgItem(g_NewDevDlg, BarControl[i].tb);
SoftPCI_ResetTrackBar(control);
SoftPCI_DisableWindow(control);
control = GetDlgItem(g_NewDevDlg, BarControl[i].tx);
wsprintf(buffer, L"BAR%d", i);
SetWindowText (control, buffer);
SoftPCI_DisableWindow(control);
}
}
VOID
SoftPCI_ResetNewDevDlg(VOID)
{
HWND control;
ULONG i = 0;
for (i = IDC_SAVETOREG_XB; i < LAST_CONTROL_ID; i++) {
control = GetDlgItem(g_NewDevDlg, i);
if (control) {
SoftPCI_HideWindow(control);
}
}
}
VOID
SoftPCI_ShowCommonNewDevDlg(VOID)
{
HWND control;
ULONG i = 0;
for (i = IDC_SAVETOREG_XB; i < IDC_BAR2_TB; i++) {
control = GetDlgItem(g_NewDevDlg, i);
if (control) {
SoftPCI_ShowWindow(control);
}
}
control = GetDlgItem(g_NewDevDlg, IDC_INSTALL_BUTTON);
SoftPCI_ShowWindow(control);
control = GetDlgItem(g_NewDevDlg, IDC_CANCEL_BUTTON);
SoftPCI_ShowWindow(control);
}
VOID
SoftPCI_UpdateBarText(
IN PWCHAR Buffer,
IN ULONGLONG BarSize
)
{
#define SIZE_1KB 0x400
#define SIZE_1MB 0x100000
#define SIZE_1GB 0x40000000
#define SIZE_1TB 0x10000000000
#define SIZE_1PB 0x4000000000000
#define SIZE_1XB 0x1000000000000000
if (BarSize < SIZE_1KB) {
wsprintf(Buffer, L"%d Bytes", BarSize);
}else if ((BarSize >= SIZE_1KB) && (BarSize < SIZE_1MB)) {
wsprintf(Buffer, L"%d KB", (BarSize / SIZE_1KB));
}else if ((BarSize >= SIZE_1MB) && (BarSize < SIZE_1GB)) {
wsprintf(Buffer, L"%d MB", (BarSize / SIZE_1MB));
}else if ((BarSize >= SIZE_1GB) && (BarSize < SIZE_1TB)) {
wsprintf(Buffer, L"%d GB", (BarSize / SIZE_1GB));
}else if ((BarSize >= SIZE_1TB) && (BarSize < SIZE_1PB)) {
wsprintf(Buffer, L"%d TB", (BarSize / SIZE_1TB));
}else if ((BarSize >= SIZE_1PB) && (BarSize < SIZE_1XB)) {
wsprintf(Buffer, L"%d PB", (BarSize / SIZE_1PB));
}else if (BarSize >= SIZE_1XB) {
wsprintf(Buffer, L"%d XB", (BarSize / SIZE_1XB));
}
}