static void
apply_boot_settings(void* kernelSettings, void* safemodeSettings)
{
#if B_HAIKU_PHYSICAL_BITS > 32
if ((kernelSettings != NULL
&& get_driver_boolean_parameter(kernelSettings, "4gb_memory_limit",
false, false))
|| (safemodeSettings != NULL
&& get_driver_boolean_parameter(safemodeSettings,
B_SAFEMODE_4_GB_MEMORY_LIMIT, false, false))) {
ignore_physical_memory_ranges_beyond_4gb();
}
#endif
}
static status_t
std_ops(int32 op, ...)
{
void *handle;
bool load = false;
switch (op) {
case B_MODULE_INIT:
handle = load_driver_settings("kernel");
if (handle) {
load = get_driver_boolean_parameter(handle,
"bochs_debug_output", load, true);
unload_driver_settings(handle);
}
if (load) {
if (get_module(B_ISA_MODULE_NAME, (module_info **)&sISAModule) < B_OK)
return B_ERROR;
}
return load ? B_OK : B_ERROR;
case B_MODULE_UNINIT:
put_module(B_ISA_MODULE_NAME);
return B_OK;
}
return B_BAD_VALUE;
}
void
load_settings()
{
void *handle = load_driver_settings(DRIVER_NAME);
if (handle == 0)
return;
gTraceOn = get_driver_boolean_parameter(handle, "trace", gTraceOn, true);
gTraceState = get_driver_boolean_parameter(handle,
"trace_state", gTraceState, true);
gTraceRX = get_driver_boolean_parameter(handle, "trace_rx", gTraceRX, true);
gTraceTX = get_driver_boolean_parameter(handle, "trace_tx", gTraceTX, true);
gTraceStats = get_driver_boolean_parameter(handle,
"trace_stats", gTraceStats, true);
gTruncateLogFile = get_driver_boolean_parameter(handle,
"reset_logfile", gTruncateLogFile, true);
gAddTimeStamp = get_driver_boolean_parameter(handle,
"add_timestamp", gAddTimeStamp, true);
const char * logFilePath = get_driver_parameter(handle,
"logfile", NULL, "/var/log/" DRIVER_NAME ".log");
if (logFilePath != NULL) {
gLogFilePath = strdup(logFilePath);
}
unload_driver_settings(handle);
create_log();
}
void load_settings()
{
void* handle = load_driver_settings(DRIVER_NAME);
if (handle == 0)
return;
gTraceMask = strtoul(get_driver_parameter(handle, "trace", "1", "0"), 0, 0);
gTruncateLogFile = get_driver_boolean_parameter(handle, "truncate_logfile",
gTruncateLogFile, true);
gAddTimeStamp = get_driver_boolean_parameter(handle, "add_timestamp",
gAddTimeStamp, true);
const char* logFilePath = get_driver_parameter(handle, "logfile",
NULL, "/var/log/" DRIVER_NAME ".log");
if (logFilePath != NULL)
gLogFilePath = strdup(logFilePath);
unload_driver_settings(handle);
create_log();
}
static void
read_settings(bool &hardwareCursor)
{
hardwareCursor = false;
void* settings = load_driver_settings("intel_extreme");
if (settings != NULL) {
hardwareCursor = get_driver_boolean_parameter(settings,
"hardware_cursor", true, true);
unload_driver_settings(settings);
}
}
void
elf_init()
{
// TODO: This cannot work, since the driver settings are loaded *after* the
// kernel has been loaded successfully.
#if 0
void *settings = load_driver_settings("kernel");
if (settings == NULL)
return;
sLoadElfSymbols = !get_driver_boolean_parameter(settings, "load_symbols",
false, false);
unload_driver_settings(settings);
#endif
}
status_t load_settings(void)
{
void *handle;
const char *val;
handle = load_driver_settings("googlefs");
if (!handle)
return ENOENT;
dprintf("googlefs: loaded settings\n");
val = get_driver_parameter(handle, "server", \
DEFAULT_GOOGLE_SERVER, DEFAULT_GOOGLE_SERVER);
strncpy(google_server, val, 20);
google_server[20-1] = '\0';
val = get_driver_parameter(handle, "port", "80", "80");
google_server_port = strtoul(val, NULL, 10);
val = get_driver_parameter(handle, "max_nodes", "5000", "5000");
max_vnodes = strtoul(val, NULL, 10);
max_vnodes = MIN(max_vnodes, 1000000);
max_vnodes = MAX(max_vnodes, 10);
val = get_driver_parameter(handle, "max_results", "50", "50");
max_results = strtoul(val, NULL, 10);
max_results = MIN(max_results, 1000);
max_results = MAX(max_results, 5);
sync_unlink_queries = get_driver_boolean_parameter(handle, "sync_unlink", false, true);
dprintf("googlefs: settings: server = %s\n", google_server);
dprintf("googlefs: settings: max_nodes = %lu\n", max_vnodes);
dprintf("googlefs: settings: max_results = %lu\n", max_results);
dprintf("googlefs: settings: sync_unlink = %c\n", sync_unlink_queries?'t':'f');
unload_driver_settings(handle);
return B_OK;
}
void
load_settings()
{
void *settingsHandle;
settingsHandle = load_driver_settings(DRIVER_NAME);
#if !DEBUG
gLogEnabled = get_driver_boolean_parameter(settingsHandle,
"debug_output", gLogEnabled, true);
#endif
gLogToFile = get_driver_boolean_parameter(settingsHandle,
"debug_output_in_file", gLogToFile, true);
gLogAppend = !get_driver_boolean_parameter(settingsHandle,
"debug_output_file_rewrite", !gLogAppend, true);
gLogFunctionCalls = get_driver_boolean_parameter(settingsHandle,
"debug_trace_func_calls", gLogFunctionCalls, false);
gLogFunctionReturns = get_driver_boolean_parameter(settingsHandle,
"debug_trace_func_returns", gLogFunctionReturns, false);
gLogFunctionResults = get_driver_boolean_parameter(settingsHandle,
"debug_trace_func_results", gLogFunctionResults, false);
unload_driver_settings(settingsHandle);
}
PartitionListRow::PartitionListRow(BPartition* partition)
:
Inherited(),
fPartitionID(partition->ID()),
fParentID(partition->Parent() ? partition->Parent()->ID() : -1),
fOffset(partition->Offset()),
fSize(partition->Size())
{
BPath path;
partition->GetPath(&path);
// Device icon
BBitmap* icon = NULL;
if (partition->IsDevice()) {
icon_size size = B_MINI_ICON;
icon = new BBitmap(BRect(0, 0, size - 1, size - 1), B_RGBA32);
if (partition->GetIcon(icon, size) != B_OK) {
delete icon;
icon = NULL;
}
}
SetField(new BBitmapStringField(icon, path.Path()), kDeviceColumn);
// File system & volume name
BString partitionType(partition->Type());
if (partition->ContainsFileSystem()) {
SetField(new BStringField(partition->ContentType()), kFilesystemColumn);
SetField(new BStringField(partition->ContentName()), kVolumeNameColumn);
} else if (partition->IsDevice()) {
SetField(new BStringField(kUnavailableString), kFilesystemColumn);
if (partition->Name() != NULL && partition->Name()[0])
SetField(new BStringField(partition->Name()), kVolumeNameColumn);
else
SetField(new BStringField(kUnavailableString), kVolumeNameColumn);
} else if (partition->CountChildren() > 0) {
SetField(new BStringField(kUnavailableString), kFilesystemColumn);
SetField(new BStringField(kUnavailableString), kVolumeNameColumn);
} else {
if (!partitionType.IsEmpty()) {
partitionType.Prepend("(");
partitionType.Append(")");
SetField(new BStringField(partitionType), kFilesystemColumn);
} else
SetField(new BStringField(kUnavailableString), kFilesystemColumn);
SetField(new BStringField(kUnavailableString), kVolumeNameColumn);
}
// Mounted at
if (partition->IsMounted() && partition->GetMountPoint(&path) == B_OK)
SetField(new BStringField(path.Path()), kMountedAtColumn);
else
SetField(new BStringField(kUnavailableString), kMountedAtColumn);
// Size
if (fSize > 0) {
char size[1024];
SetField(new BStringField(string_for_size(partition->Size(), size,
sizeof(size))), kSizeColumn);
} else {
SetField(new BStringField(kUnavailableString), kSizeColumn);
}
// Additional parameters
if (partition->Parameters() != NULL) {
BString parameters;
// check parameters
void* handle = parse_driver_settings_string(partition->Parameters());
if (handle != NULL) {
bool active = get_driver_boolean_parameter(handle, "active", false, true);
if (active)
parameters += B_TRANSLATE("Active");
delete_driver_settings(handle);
}
SetField(new BStringField(parameters), kParametersColumn);
} else {
SetField(new BStringField(kUnavailableString), kParametersColumn);
}
// Partition type
if (partitionType.IsEmpty())
partitionType = partition->ContentType();
SetField(new BStringField(partitionType), kPartitionTypeColumn);
}
static status_t
acpi_std_ops(int32 op,...)
{
switch (op) {
case B_MODULE_INIT:
{
ACPI_OBJECT arg;
ACPI_OBJECT_LIST parameter;
void *settings;
bool acpiDisabled = false;
AcpiGbl_CopyDsdtLocally = true;
settings = load_driver_settings("kernel");
if (settings != NULL) {
acpiDisabled = !get_driver_boolean_parameter(settings, "acpi",
true, true);
unload_driver_settings(settings);
}
if (!acpiDisabled) {
// check if safemode settings disable ACPI
settings = load_driver_settings(B_SAFEMODE_DRIVER_SETTINGS);
if (settings != NULL) {
acpiDisabled = get_driver_boolean_parameter(settings,
B_SAFEMODE_DISABLE_ACPI, false, false);
unload_driver_settings(settings);
}
}
if (acpiDisabled) {
ERROR("ACPI disabled\n");
return ENOSYS;
}
if (gDPC->new_dpc_queue(&gDPCHandle, "acpi_task",
B_URGENT_DISPLAY_PRIORITY + 1) != B_OK) {
ERROR("failed to create os execution queue\n");
return B_ERROR;
}
#ifdef ACPI_DEBUG_OUTPUT
AcpiDbgLevel = ACPI_DEBUG_ALL | ACPI_LV_VERBOSE;
AcpiDbgLayer = ACPI_ALL_COMPONENTS;
#endif
if (checkAndLogFailure(AcpiInitializeSubsystem(),
"AcpiInitializeSubsystem failed"))
goto err;
if (checkAndLogFailure(AcpiInitializeTables(NULL, 0, TRUE),
"AcpiInitializeTables failed"))
goto err;
if (checkAndLogFailure(AcpiLoadTables(),
"AcpiLoadTables failed"))
goto err;
/* Install the default address space handlers. */
if (checkAndLogFailure(AcpiInstallAddressSpaceHandler(
ACPI_ROOT_OBJECT, ACPI_ADR_SPACE_SYSTEM_MEMORY,
ACPI_DEFAULT_HANDLER, NULL, NULL),
"Could not initialise SystemMemory handler:"))
goto err;
if (checkAndLogFailure(AcpiInstallAddressSpaceHandler(
ACPI_ROOT_OBJECT, ACPI_ADR_SPACE_SYSTEM_IO,
ACPI_DEFAULT_HANDLER, NULL, NULL),
"Could not initialise SystemIO handler:"))
goto err;
if (checkAndLogFailure(AcpiInstallAddressSpaceHandler(
ACPI_ROOT_OBJECT, ACPI_ADR_SPACE_PCI_CONFIG,
ACPI_DEFAULT_HANDLER, NULL, NULL),
"Could not initialise PciConfig handler:"))
goto err;
arg.Integer.Type = ACPI_TYPE_INTEGER;
arg.Integer.Value = apic_available() ? APIC_MODE : PIC_MODE;
parameter.Count = 1;
parameter.Pointer = &arg;
AcpiEvaluateObject(NULL, "\\_PIC", ¶meter, NULL);
if (checkAndLogFailure(AcpiEnableSubsystem(
ACPI_FULL_INITIALIZATION),
"AcpiEnableSubsystem failed"))
goto err;
if (checkAndLogFailure(AcpiInitializeObjects(
ACPI_FULL_INITIALIZATION),
"AcpiInitializeObjects failed"))
goto err;
//TODO: Walk namespace init ALL _PRW's
#ifdef ACPI_DEBUG_OUTPUT
checkAndLogFailure(
AcpiInstallGlobalEventHandler(globalGPEHandler, NULL),
"Failed to install global GPE-handler.");
checkAndLogFailure(AcpiInstallNotifyHandler(ACPI_ROOT_OBJECT,
ACPI_ALL_NOTIFY, globalNotifyHandler, NULL),
"Failed to install global Notify-handler.");
#endif
checkAndLogFailure(AcpiEnableAllRuntimeGpes(),
"Failed to enable all runtime Gpes");
checkAndLogFailure(AcpiUpdateAllGpes(),
"Failed to update all Gpes");
TRACE("ACPI initialized\n");
return B_OK;
err:
return B_ERROR;
}
case B_MODULE_UNINIT:
{
if (checkAndLogFailure(AcpiTerminate(),
"Could not bring system out of ACPI mode. Oh well."));
gDPC->delete_dpc_queue(gDPCHandle);
gDPCHandle = NULL;
break;
}
default:
return B_ERROR;
}
return B_OK;
}
status_t
init_driver(void) {
void *settings_handle;
// get driver/accelerant settings, apsed
settings_handle = load_driver_settings (DRIVER_PREFIX ".settings");
if (settings_handle != NULL) {
const char *item;
char *end;
uint32 value;
// for driver
item = get_driver_parameter (settings_handle, "accelerant", "", "");
if ((strlen (item) > 0) && (strlen (item) < sizeof (current_settings.accelerant) - 1)) {
strcpy (current_settings.accelerant, item);
}
current_settings.dumprom = get_driver_boolean_parameter (settings_handle, "dumprom", false, false);
// for accelerant
item = get_driver_parameter (settings_handle, "logmask", "0x00000000", "0x00000000");
value = strtoul (item, &end, 0);
if (*end == '\0') current_settings.logmask = value;
item = get_driver_parameter (settings_handle, "memory", "0", "0");
value = strtoul (item, &end, 0);
if (*end == '\0') current_settings.memory = value;
current_settings.hardcursor = get_driver_boolean_parameter (settings_handle, "hardcursor", false, false);
current_settings.usebios = get_driver_boolean_parameter (settings_handle, "usebios", false, false);
current_settings.switchhead = get_driver_boolean_parameter (settings_handle, "switchhead", false, false);
current_settings.force_pci = get_driver_boolean_parameter (settings_handle, "force_pci", false, false);
current_settings.unhide_fw = get_driver_boolean_parameter (settings_handle, "unhide_fw", false, false);
current_settings.pgm_panel = get_driver_boolean_parameter (settings_handle, "pgm_panel", false, false);
unload_driver_settings (settings_handle);
}
/* get a handle for the pci bus */
if (get_module(B_PCI_MODULE_NAME, (module_info **)&pci_bus) != B_OK)
return B_ERROR;
/* get a handle for the isa bus */
if (get_module(B_ISA_MODULE_NAME, (module_info **)&isa_bus) != B_OK)
{
put_module(B_PCI_MODULE_NAME);
return B_ERROR;
}
/* get a handle for the agp bus if it exists */
get_module(B_AGP_GART_MODULE_NAME, (module_info **)&agp_bus);
/* driver private data */
pd = (DeviceData *)calloc(1, sizeof(DeviceData));
if (!pd) {
if (agp_bus)
put_module(B_AGP_GART_MODULE_NAME);
put_module(B_ISA_MODULE_NAME);
put_module(B_PCI_MODULE_NAME);
return B_ERROR;
}
/* initialize the benaphore */
INIT_BEN(pd->kernel);
/* find all of our supported devices */
probe_devices();
return B_OK;
}
status_t
Settings::ReadSwapSettings()
{
void* settings = load_driver_settings(kVirtualMemorySettings);
if (settings == NULL)
return kErrorSettingsNotFound;
CObjectDeleter<void, status_t> settingDeleter(settings,
&unload_driver_settings);
const char* enabled = get_driver_parameter(settings, "vm", NULL, NULL);
const char* automatic = get_driver_parameter(settings, "swap_auto",
NULL, NULL);
const char* size = get_driver_parameter(settings, "swap_size", NULL, NULL);
const char* volume = get_driver_parameter(settings, "swap_volume_name",
NULL, NULL);
const char* device = get_driver_parameter(settings,
"swap_volume_device", NULL, NULL);
const char* filesystem = get_driver_parameter(settings,
"swap_volume_filesystem", NULL, NULL);
const char* capacity = get_driver_parameter(settings,
"swap_volume_capacity", NULL, NULL);
if (enabled == NULL || automatic == NULL || size == NULL || device == NULL
|| volume == NULL || capacity == NULL || filesystem == NULL)
return kErrorSettingsInvalid;
off_t volCapacity = atoll(capacity);
SetSwapEnabled(get_driver_boolean_parameter(settings,
"vm", true, false));
SetSwapAutomatic(get_driver_boolean_parameter(settings,
"swap_auto", true, false));
SetSwapSize(atoll(size));
int32 bestScore = -1;
dev_t bestVol = -1;
BVolume vol;
fs_info volStat;
BVolumeRoster roster;
while (roster.GetNextVolume(&vol) == B_OK) {
if (!vol.IsPersistent() || vol.IsReadOnly() || vol.IsRemovable()
|| vol.IsShared())
continue;
if (fs_stat_dev(vol.Device(), &volStat) == 0) {
int32 score = 0;
if (strcmp(volume, volStat.volume_name) == 0)
score += 4;
if (strcmp(device, volStat.device_name) == 0)
score += 3;
if (volCapacity == volStat.total_blocks * volStat.block_size)
score += 2;
if (strcmp(filesystem, volStat.fsh_name) == 0)
score += 1;
if (score >= 4 && score > bestScore) {
bestVol = vol.Device();
bestScore = score;
}
}
}
SetSwapVolume(bestVol);
fInitialSettings = fCurrentSettings;
if (bestVol < 0)
return kErrorVolumeNotFound;
return B_OK;
}
static void
GetDriverSettings(void)
{
void *settings_handle = NULL;
SHOW_FLOW0( 1, "" );
// init settings to defaults;
current_settings = def_settings;
// get driver/accelerant settings, apsed
settings_handle = load_driver_settings ("radeon.settings");
if (settings_handle != NULL) {
const char *item;
char *end;
uint32 value;
item = get_driver_parameter (settings_handle, "loginfo", "2", "2");
value = strtoul (item, &end, 0);
if (*end == '\0' && value <= 4) {
current_settings.loginfo = value;
SHOW_INFO( 1, "Log Info Level now %ld/4", value );
}
item = get_driver_parameter (settings_handle, "logflow", "2", "2");
value = strtoul (item, &end, 0);
if (*end == '\0' && value <= 4) {
current_settings.logflow = value;
SHOW_INFO( 1, "Log Flow Level now %ld/4", value );
}
item = get_driver_parameter (settings_handle, "logerror", "2", "2");
value = strtoul (item, &end, 0);
if (*end == '\0' && value <= 4) {
current_settings.logerror = value;
SHOW_INFO( 1, "Log Error Level now %ld/4", value );
}
current_settings.switchhead = get_driver_boolean_parameter (settings_handle, "switchhead", false, false);
current_settings.force_lcd = get_driver_boolean_parameter (settings_handle, "force_lcd", false, false);
current_settings.dynamic_clocks = get_driver_boolean_parameter (settings_handle, "dynamic_clocks", true, true);
current_settings.force_pci = get_driver_boolean_parameter (settings_handle, "force_pci", true, true);
current_settings.unhide_fastwrites = get_driver_boolean_parameter (settings_handle, "unhide_fw", false, false);
current_settings.force_acc_dma = get_driver_boolean_parameter (settings_handle, "force_acc_dma", false, false);
current_settings.force_acc_mmio = get_driver_boolean_parameter (settings_handle, "force_acc_mmio", false, false);
current_settings.acc_writeback = get_driver_boolean_parameter (settings_handle, "acc_writeback", false, false);
if ( current_settings.switchhead != def_settings.switchhead )
SHOW_INFO0( 1, "Switch Head = True" );
if ( current_settings.force_lcd != def_settings.force_lcd )
SHOW_INFO0( 1, "Force LCD ON" );
if ( current_settings.dynamic_clocks != def_settings.dynamic_clocks )
SHOW_INFO0( 1, "Mobility Power Saving Disabled (Dynamic Clocks)" );
if ( current_settings.force_pci != def_settings.force_pci )
SHOW_INFO0( 1, "Force PCI = True" );
if ( current_settings.unhide_fastwrites != def_settings.unhide_fastwrites )
SHOW_INFO0( 1, "use Fastwrites ON" );
if ( current_settings.force_acc_dma != def_settings.force_acc_dma )
SHOW_INFO0( 1, "DMA ACC Enabled" );
if ( current_settings.force_acc_mmio != def_settings.force_acc_mmio )
SHOW_INFO0( 1, "DMA ACC Disabled" );
if ( current_settings.acc_writeback != def_settings.acc_writeback )
SHOW_INFO0( 1, "DMA WriteBack Disabled" );
unload_driver_settings (settings_handle);
}
}
status_t
init_driver(void)
{
void *settings;
// get driver/accelerant settings
settings = load_driver_settings(DRIVER_PREFIX ".settings");
if (settings != NULL) {
const char *item;
char *end;
uint32 value;
// for driver
item = get_driver_parameter(settings, "accelerant", "", "");
if (item[0] && strlen(item) < sizeof(sSettings.accelerant) - 1)
strcpy (sSettings.accelerant, item);
item = get_driver_parameter(settings, "primary", "", "");
if (item[0] && strlen(item) < sizeof(sSettings.primary) - 1)
strcpy(sSettings.primary, item);
sSettings.dumprom = get_driver_boolean_parameter(settings,
"dumprom", false, false);
// for accelerant
item = get_driver_parameter(settings, "logmask",
"0x00000000", "0x00000000");
value = strtoul(item, &end, 0);
if (*end == '\0')
sSettings.logmask = value;
item = get_driver_parameter(settings, "memory", "0", "0");
value = strtoul(item, &end, 0);
if (*end == '\0')
sSettings.memory = value;
sSettings.hardcursor = get_driver_boolean_parameter(settings,
"hardcursor", false, false);
sSettings.usebios = get_driver_boolean_parameter(settings,
"usebios", false, false);
sSettings.switchhead = get_driver_boolean_parameter(settings,
"switchhead", false, false);
sSettings.pgm_panel = get_driver_boolean_parameter(settings,
"pgm_panel", false, false);
sSettings.force_sync = get_driver_boolean_parameter(settings,
"force_sync", false, false);
sSettings.force_ws = get_driver_boolean_parameter(settings,
"force_ws", false, false);
item = get_driver_parameter(settings, "gpu_clk", "0", "0");
value = strtoul(item, &end, 0);
if (*end == '\0')
sSettings.gpu_clk = value;
item = get_driver_parameter(settings, "ram_clk", "0", "0");
value = strtoul(item, &end, 0);
if (*end == '\0')
sSettings.ram_clk = value;
unload_driver_settings(settings);
}
/* get a handle for the pci bus */
if (get_module(B_PCI_MODULE_NAME, (module_info **)&pci_bus) != B_OK)
return B_ERROR;
/* get a handle for the isa bus */
if (get_module(B_ISA_MODULE_NAME, (module_info **)&isa_bus) != B_OK) {
put_module(B_PCI_MODULE_NAME);
return B_ERROR;
}
/* driver private data */
pd = (DeviceData *)calloc(1, sizeof(DeviceData));
if (!pd) {
put_module(B_PCI_MODULE_NAME);
return B_ERROR;
}
/* initialize the benaphore */
INIT_BEN(pd->kernel);
/* find all of our supported devices */
probe_devices();
return B_OK;
}
