i2p/haiku-beta6
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

kernel: Drop non-standard GNU inline assignment syntax

Browse Source 
* We needed this previously due to our gcc2 compiled kernel.
* Now that our kernel is always latest gcc, we can move to the
  c++20 syntax for inline assignment.
* Improves compatibility with clang, less GNU-specific stuff

Change-Id: Ib7272a0a52554a31e9a0e788fd3f031db9049795
Reviewed-on: https://review.haiku-os.org/c/haiku/+/5898
Reviewed-by: Alex von Gluck IV <[email protected]>
Reviewed-by: Adrien Destugues <[email protected]>
This commit is contained in:
X512
2022-12-13 20:49:53 +00:00
committed by Alex von Gluck IV
parent 67d20a5856
commit 215b685f7f
60 changed files with 291 additions and 294 deletions
Download Patch File Download Diff File Expand all files Collapse all files
headers/private/drivers/scsi_periph.h
+1 -1
View File
@@ -44,7 +44,7 @@ typedef struct err_res {
} err_res; } err_res;
#define MK_ERROR( aaction, code ) ({ \ #define MK_ERROR( aaction, code ) ({ \
err_res _res = {error_code: (code), action: (aaction) }; \ err_res _res = {.error_code = (code), .action = (aaction) }; \
_res; \ _res; \
}) })
src/add-ons/kernel/bus_managers/acpi/EmbeddedController.cpp
+1 -1
View File
@@ -269,7 +269,7 @@ embedded_controller_register_device(device_node* node)
{ {
device_attr attrs[] = { device_attr attrs[] = {
{ B_DEVICE_PRETTY_NAME, B_STRING_TYPE, { B_DEVICE_PRETTY_NAME, B_STRING_TYPE,
{ string: "ACPI embedded controller" }}, { .string = "ACPI embedded controller" }},
{ NULL } { NULL }
}; };
src/add-ons/kernel/bus_managers/acpi/Module.cpp
+14 -15
View File
@@ -57,9 +57,8 @@ static status_t
acpi_module_register_device(device_node* parent) acpi_module_register_device(device_node* parent)
{ {
device_attr attrs[] = { device_attr attrs[] = {
{ B_DEVICE_PRETTY_NAME, B_STRING_TYPE, { string: "ACPI" }}, { B_DEVICE_PRETTY_NAME, B_STRING_TYPE, { .string = "ACPI" }},
{ B_DEVICE_FLAGS, B_UINT32_TYPE, { .ui32 = B_KEEP_DRIVER_LOADED }},
{ B_DEVICE_FLAGS, B_UINT32_TYPE, { ui32: B_KEEP_DRIVER_LOADED }},
{} {}
}; };
@@ -88,15 +87,15 @@ acpi_enumerate_child_devices(device_node* node, const char* root)
case ACPI_TYPE_DEVICE: { case ACPI_TYPE_DEVICE: {
device_attr attrs[16] = { device_attr attrs[16] = {
// info about device // info about device
{ B_DEVICE_BUS, B_STRING_TYPE, { string: "acpi" }}, { B_DEVICE_BUS, B_STRING_TYPE, { .string = "acpi" }},
// location on ACPI bus // location on ACPI bus
{ ACPI_DEVICE_PATH_ITEM, B_STRING_TYPE, { string: result }}, { ACPI_DEVICE_PATH_ITEM, B_STRING_TYPE, { .string = result }},
// info about the device // info about the device
{ ACPI_DEVICE_TYPE_ITEM, B_UINT32_TYPE, { ui32: type }}, { ACPI_DEVICE_TYPE_ITEM, B_UINT32_TYPE, { .ui32 = type }},
{ B_DEVICE_FLAGS, B_UINT32_TYPE, { ui32: B_FIND_MULTIPLE_CHILDREN }}, { B_DEVICE_FLAGS, B_UINT32_TYPE, { .ui32 = B_FIND_MULTIPLE_CHILDREN }},
{ NULL } { NULL }
}; };
@@ -175,14 +174,14 @@ acpi_module_register_child_devices(void* cookie)
dprintf("registering power button\n"); dprintf("registering power button\n");
device_attr attrs[] = { device_attr attrs[] = {
// info about device // info about device
{ B_DEVICE_BUS, B_STRING_TYPE, { string: "acpi" }}, { B_DEVICE_BUS, B_STRING_TYPE, { .string = "acpi" }},
// info about the device // info about the device
{ ACPI_DEVICE_HID_ITEM, B_STRING_TYPE, { string: "ACPI_FPB" }}, { ACPI_DEVICE_HID_ITEM, B_STRING_TYPE, { .string = "ACPI_FPB" }},
{ ACPI_DEVICE_TYPE_ITEM, B_UINT32_TYPE, { ui32: ACPI_TYPE_DEVICE }}, { ACPI_DEVICE_TYPE_ITEM, B_UINT32_TYPE, { .ui32 = ACPI_TYPE_DEVICE }},
// consumer specification // consumer specification
{ B_DEVICE_FLAGS, B_UINT32_TYPE, { ui32: B_FIND_MULTIPLE_CHILDREN }}, { B_DEVICE_FLAGS, B_UINT32_TYPE, { .ui32 = B_FIND_MULTIPLE_CHILDREN }},
{ NULL } { NULL }
}; };
device_node* deviceNode; device_node* deviceNode;
@@ -193,14 +192,14 @@ acpi_module_register_child_devices(void* cookie)
dprintf("registering sleep button\n"); dprintf("registering sleep button\n");
device_attr attrs[] = { device_attr attrs[] = {
// info about device // info about device
{ B_DEVICE_BUS, B_STRING_TYPE, { string: "acpi" }}, { B_DEVICE_BUS, B_STRING_TYPE, { .string = "acpi" }},
// info about the device // info about the device
{ ACPI_DEVICE_HID_ITEM, B_STRING_TYPE, { string: "ACPI_FSB" }}, { ACPI_DEVICE_HID_ITEM, B_STRING_TYPE, { .string = "ACPI_FSB" }},
{ ACPI_DEVICE_TYPE_ITEM, B_UINT32_TYPE, { ui32: ACPI_TYPE_DEVICE }}, { ACPI_DEVICE_TYPE_ITEM, B_UINT32_TYPE, { .ui32 = ACPI_TYPE_DEVICE }},
// consumer specification // consumer specification
{ B_DEVICE_FLAGS, B_UINT32_TYPE, { ui32: B_FIND_MULTIPLE_CHILDREN }}, { B_DEVICE_FLAGS, B_UINT32_TYPE, { .ui32 = B_FIND_MULTIPLE_CHILDREN }},
{ NULL } { NULL }
}; };
device_node* deviceNode; device_node* deviceNode;
src/add-ons/kernel/bus_managers/ata/ATAModule.cpp
+4 -4
View File
@@ -182,12 +182,12 @@ ata_channel_added(device_node *parent)
device_attr attributes[] = { device_attr attributes[] = {
{ {
B_DEVICE_FIXED_CHILD, B_STRING_TYPE, B_DEVICE_FIXED_CHILD, B_STRING_TYPE,
{ string: SCSI_FOR_SIM_MODULE_NAME } { .string = SCSI_FOR_SIM_MODULE_NAME }
}, },
{ {
SCSI_DESCRIPTION_CONTROLLER_NAME, B_STRING_TYPE, SCSI_DESCRIPTION_CONTROLLER_NAME, B_STRING_TYPE,
{ string: controllerName } { .string = controllerName }
}, },
// maximum number of blocks per transmission: // maximum number of blocks per transmission:
@@ -195,8 +195,8 @@ ata_channel_added(device_node *parent)
// but I'm not sure about controller restrictions // but I'm not sure about controller restrictions
// - ATA allows up to 256 blocks for LBA28 and 65535 for LBA48 // - ATA allows up to 256 blocks for LBA28 and 65535 for LBA48
// to fix specific drive bugs use ATAChannel::GetRestrictions() // to fix specific drive bugs use ATAChannel::GetRestrictions()
{ B_DMA_MAX_TRANSFER_BLOCKS, B_UINT32_TYPE, { ui32: 0xffff } }, { B_DMA_MAX_TRANSFER_BLOCKS, B_UINT32_TYPE, { .ui32 = 0xffff } },
{ ATA_CHANNEL_ID_ITEM, B_UINT32_TYPE, { ui32: (uint32)channelID } }, { ATA_CHANNEL_ID_ITEM, B_UINT32_TYPE, { .ui32 = (uint32)channelID } },
{ NULL } { NULL }
}; };
src/add-ons/kernel/bus_managers/fdt/fdt_module.cpp
+8 -8
View File
@@ -99,15 +99,15 @@ fdt_register_node(fdt_bus* bus, int node, device_node* parentDev,
return B_ERROR; return B_ERROR;
} }
attrs.Add({ B_DEVICE_BUS, B_STRING_TYPE, {string: "fdt"}}); attrs.Add({ B_DEVICE_BUS, B_STRING_TYPE, {.string = "fdt"}});
attrs.Add({ B_DEVICE_PRETTY_NAME, B_STRING_TYPE, attrs.Add({ B_DEVICE_PRETTY_NAME, B_STRING_TYPE,
{ string: (strcmp(name, "") != 0) ? name : "Root" }}); { .string = (strcmp(name, "") != 0) ? name : "Root" }});
attrs.Add({ "fdt/node", B_UINT32_TYPE, {ui32: (uint32)node}}); attrs.Add({ "fdt/node", B_UINT32_TYPE, {.ui32 = (uint32)node}});
attrs.Add({ "fdt/name", B_STRING_TYPE, {string: name}}); attrs.Add({ "fdt/name", B_STRING_TYPE, {.string = name}});
prop = fdt_getprop(gFDT, node, "device_type", &propLen); prop = fdt_getprop(gFDT, node, "device_type", &propLen);
if (prop != NULL) if (prop != NULL)
attrs.Add({ "fdt/device_type", B_STRING_TYPE, { string: (const char*)prop }}); attrs.Add({ "fdt/device_type", B_STRING_TYPE, { .string = (const char*)prop }});
prop = fdt_getprop(gFDT, node, "compatible", &propLen); prop = fdt_getprop(gFDT, node, "compatible", &propLen);
@@ -116,7 +116,7 @@ fdt_register_node(fdt_bus* bus, int node, device_node* parentDev,
const char* propEnd = propStr + propLen; const char* propEnd = propStr + propLen;
while (propEnd - propStr > 0) { while (propEnd - propStr > 0) {
int curLen = strlen(propStr); int curLen = strlen(propStr);
attrs.Add({ "fdt/compatible", B_STRING_TYPE, { string: propStr }}); attrs.Add({ "fdt/compatible", B_STRING_TYPE, { .string = propStr }});
propStr += curLen + 1; propStr += curLen + 1;
} }
} }
@@ -201,8 +201,8 @@ fdt_bus_register_device(device_node* parent)
} scopeExit; } scopeExit;
device_attr attrs[] = { device_attr attrs[] = {
{B_DEVICE_PRETTY_NAME, B_STRING_TYPE, {string: "FDT"}}, {B_DEVICE_PRETTY_NAME, B_STRING_TYPE, {.string = "FDT"}},
{B_DEVICE_FLAGS, B_UINT32_TYPE, {ui32: B_KEEP_DRIVER_LOADED}}, {B_DEVICE_FLAGS, B_UINT32_TYPE, {.ui32 = B_KEEP_DRIVER_LOADED}},
{} {}
}; };
src/add-ons/kernel/bus_managers/i2c/I2CBus.cpp
+7 -7
View File
@@ -57,21 +57,21 @@ I2CBus::RegisterDevice(i2c_addr slaveAddress, char* hid, char** cid,
CALLED(); CALLED();
device_attr attrs[] = { device_attr attrs[] = {
{ B_DEVICE_PRETTY_NAME, B_STRING_TYPE, { string: "I2C device" }}, { B_DEVICE_PRETTY_NAME, B_STRING_TYPE, { .string = "I2C device" }},
// connection // connection
{ I2C_DEVICE_SLAVE_ADDR_ITEM, B_UINT16_TYPE, { ui16: slaveAddress }}, { I2C_DEVICE_SLAVE_ADDR_ITEM, B_UINT16_TYPE, { .ui16 = slaveAddress }},
// description of peripheral drivers // description of peripheral drivers
{ B_DEVICE_BUS, B_STRING_TYPE, { string: "i2c" }}, { B_DEVICE_BUS, B_STRING_TYPE, { .string = "i2c" }},
{ B_DEVICE_FLAGS, B_UINT32_TYPE, { ui32: B_FIND_MULTIPLE_CHILDREN }}, { B_DEVICE_FLAGS, B_UINT32_TYPE, { .ui32 = B_FIND_MULTIPLE_CHILDREN }},
{ ACPI_DEVICE_HID_ITEM, B_STRING_TYPE, { string: hid }}, { ACPI_DEVICE_HID_ITEM, B_STRING_TYPE, { .string = hid }},
{ ACPI_DEVICE_CID_ITEM, B_STRING_TYPE, { string: cid[0] }}, { ACPI_DEVICE_CID_ITEM, B_STRING_TYPE, { .string = cid[0] }},
{ ACPI_DEVICE_HANDLE_ITEM, B_UINT64_TYPE, { ui64: (addr_t)acpiHandle }}, { ACPI_DEVICE_HANDLE_ITEM, B_UINT64_TYPE, { .ui64 = (addr_t)acpiHandle }},
{ NULL } { NULL }
}; };
src/add-ons/kernel/bus_managers/i2c/I2CModule.cpp
+3 -3
View File
@@ -26,9 +26,9 @@ i2c_added_device(device_node *parent)
device_attr attributes[] = { device_attr attributes[] = {
// info about device // info about device
{ B_DEVICE_PRETTY_NAME, B_STRING_TYPE, { string: "I2C bus" }}, { B_DEVICE_PRETTY_NAME, B_STRING_TYPE, { .string = "I2C bus" }},
{ B_DEVICE_BUS, B_STRING_TYPE, { string: "i2c" }}, { B_DEVICE_BUS, B_STRING_TYPE, { .string = "i2c" }},
{ I2C_BUS_PATH_ID_ITEM, B_UINT8_TYPE, { ui8: (uint8)pathID }}, { I2C_BUS_PATH_ID_ITEM, B_UINT8_TYPE, { .ui8 = (uint8)pathID }},
{ NULL } { NULL }
}; };
src/add-ons/kernel/bus_managers/isa/isa.cpp
+2 -2
View File
@@ -111,9 +111,9 @@ isa_register_device(device_node *parent)
{ {
static const device_attr attrs[] = { static const device_attr attrs[] = {
// tell where to look for child devices // tell where to look for child devices
{B_DEVICE_BUS, B_STRING_TYPE, {string: "isa" }}, {B_DEVICE_BUS, B_STRING_TYPE, {.string = "isa" }},
{B_DEVICE_FLAGS, B_UINT32_TYPE, {B_DEVICE_FLAGS, B_UINT32_TYPE,
{ui32: B_FIND_CHILD_ON_DEMAND | B_FIND_MULTIPLE_CHILDREN}}, {.ui32 = B_FIND_CHILD_ON_DEMAND | B_FIND_MULTIPLE_CHILDREN}},
{} {}
}; };
src/add-ons/kernel/bus_managers/mmc/mmc_bus.cpp
+10 -10
View File
@@ -289,16 +289,16 @@ MMCBus::_WorkerThread(void* cookie)
uint16_t rca = response >> 16; uint16_t rca = response >> 16;
device_attr attrs[] = { device_attr attrs[] = {
{ B_DEVICE_BUS, B_STRING_TYPE, {string: "mmc" }}, { B_DEVICE_BUS, B_STRING_TYPE, {.string = "mmc" }},
{ B_DEVICE_PRETTY_NAME, B_STRING_TYPE, {string: "mmc device" }}, { B_DEVICE_PRETTY_NAME, B_STRING_TYPE, {.string = "mmc device" }},
{ B_DEVICE_VENDOR_ID, B_UINT32_TYPE, {ui32: vendor}}, { B_DEVICE_VENDOR_ID, B_UINT32_TYPE, {.ui32 = vendor}},
{ B_DEVICE_ID, B_STRING_TYPE, {string: name}}, { B_DEVICE_ID, B_STRING_TYPE, {.string = name}},
{ B_DEVICE_UNIQUE_ID, B_UINT32_TYPE, {ui32: serial}}, { B_DEVICE_UNIQUE_ID, B_UINT32_TYPE, {.ui32 = serial}},
{ "mmc/revision", B_UINT16_TYPE, {ui16: revision}}, { "mmc/revision", B_UINT16_TYPE, {.ui16 = revision}},
{ "mmc/month", B_UINT8_TYPE, {ui8: month}}, { "mmc/month", B_UINT8_TYPE, {.ui8 = month}},
{ "mmc/year", B_UINT16_TYPE, {ui16: year}}, { "mmc/year", B_UINT16_TYPE, {.ui16 = year}},
{ kMmcRcaAttribute, B_UINT16_TYPE, {ui16: rca}}, { kMmcRcaAttribute, B_UINT16_TYPE, {.ui16 = rca}},
{ kMmcTypeAttribute, B_UINT8_TYPE, {ui8: cardType}}, { kMmcTypeAttribute, B_UINT8_TYPE, {.ui8 = cardType}},
{} {}
}; };
src/add-ons/kernel/bus_managers/mmc/mmc_module.cpp
+2 -2
View File
@@ -67,8 +67,8 @@ mmc_bus_added_device(device_node* parent)
CALLED(); CALLED();
device_attr attributes[] = { device_attr attributes[] = {
{ B_DEVICE_BUS, B_STRING_TYPE, { string: "mmc"}}, { B_DEVICE_BUS, B_STRING_TYPE, { .string = "mmc"}},
{ B_DEVICE_PRETTY_NAME, B_STRING_TYPE, { string: "MMC bus root"}}, { B_DEVICE_PRETTY_NAME, B_STRING_TYPE, { .string = "MMC bus root"}},
{ NULL } { NULL }
}; };
src/add-ons/kernel/bus_managers/pci/pci.cpp
+22 -22
View File
@@ -125,27 +125,27 @@ pci_reserve_device(uchar virtualBus, uchar device, uchar function,
device_attr matchThis[] = { device_attr matchThis[] = {
// info about device // info about device
{B_DEVICE_BUS, B_STRING_TYPE, {string: "pci"}}, {B_DEVICE_BUS, B_STRING_TYPE, {.string = "pci"}},
// location on PCI bus // location on PCI bus
{B_PCI_DEVICE_DOMAIN, B_UINT8_TYPE, {ui8: domain}}, {B_PCI_DEVICE_DOMAIN, B_UINT8_TYPE, {.ui8 = domain}},
{B_PCI_DEVICE_BUS, B_UINT8_TYPE, {ui8: bus}}, {B_PCI_DEVICE_BUS, B_UINT8_TYPE, {.ui8 = bus}},
{B_PCI_DEVICE_DEVICE, B_UINT8_TYPE, {ui8: device}}, {B_PCI_DEVICE_DEVICE, B_UINT8_TYPE, {.ui8 = device}},
{B_PCI_DEVICE_FUNCTION, B_UINT8_TYPE, {ui8: function}}, {B_PCI_DEVICE_FUNCTION, B_UINT8_TYPE, {.ui8 = function}},
{NULL} {NULL}
}; };
device_attr legacyAttrs[] = { device_attr legacyAttrs[] = {
// info about device // info about device
{B_DEVICE_BUS, B_STRING_TYPE, {string: "legacy_driver"}}, {B_DEVICE_BUS, B_STRING_TYPE, {.string = "legacy_driver"}},
{B_DEVICE_PRETTY_NAME, B_STRING_TYPE, {string: "Legacy Driver Reservation"}}, {B_DEVICE_PRETTY_NAME, B_STRING_TYPE, {.string = "Legacy Driver Reservation"}},
{NULL} {NULL}
}; };
device_attr drvAttrs[] = { device_attr drvAttrs[] = {
// info about device // info about device
{B_DEVICE_BUS, B_STRING_TYPE, {string: "legacy_driver"}}, {B_DEVICE_BUS, B_STRING_TYPE, {.string = "legacy_driver"}},
{B_DEVICE_PRETTY_NAME, B_STRING_TYPE, {string: driverName}}, {B_DEVICE_PRETTY_NAME, B_STRING_TYPE, {.string = driverName}},
{"legacy_driver", B_STRING_TYPE, {string: driverName}}, {"legacy_driver", B_STRING_TYPE, {.string = driverName}},
{"legacy_driver_cookie", B_UINT64_TYPE, {ui64: (uint64)nodeCookie}}, {"legacy_driver_cookie", B_UINT64_TYPE, {.ui64 = (uint64)nodeCookie}},
{NULL} {NULL}
}; };
device_node *node, *legacy; device_node *node, *legacy;
@@ -205,31 +205,31 @@ pci_unreserve_device(uchar virtualBus, uchar device, uchar function,
// domain, bus, device, function, driverName, nodeCookie)); // domain, bus, device, function, driverName, nodeCookie));
device_attr matchPCIRoot[] = { device_attr matchPCIRoot[] = {
{B_DEVICE_PRETTY_NAME, B_STRING_TYPE, {string: "PCI"}}, {B_DEVICE_PRETTY_NAME, B_STRING_TYPE, {.string = "PCI"}},
{NULL} {NULL}
}; };
device_attr matchThis[] = { device_attr matchThis[] = {
// info about device // info about device
{B_DEVICE_BUS, B_STRING_TYPE, {string: "pci"}}, {B_DEVICE_BUS, B_STRING_TYPE, {.string = "pci"}},
// location on PCI bus // location on PCI bus
{B_PCI_DEVICE_DOMAIN, B_UINT8_TYPE, {ui8: domain}}, {B_PCI_DEVICE_DOMAIN, B_UINT8_TYPE, {.ui8 = domain}},
{B_PCI_DEVICE_BUS, B_UINT8_TYPE, {ui8: bus}}, {B_PCI_DEVICE_BUS, B_UINT8_TYPE, {.ui8 = bus}},
{B_PCI_DEVICE_DEVICE, B_UINT8_TYPE, {ui8: device}}, {B_PCI_DEVICE_DEVICE, B_UINT8_TYPE, {.ui8 = device}},
{B_PCI_DEVICE_FUNCTION, B_UINT8_TYPE, {ui8: function}}, {B_PCI_DEVICE_FUNCTION, B_UINT8_TYPE, {.ui8 = function}},
{NULL} {NULL}
}; };
device_attr legacyAttrs[] = { device_attr legacyAttrs[] = {
// info about device // info about device
{B_DEVICE_BUS, B_STRING_TYPE, {string: "legacy_driver"}}, {B_DEVICE_BUS, B_STRING_TYPE, {.string = "legacy_driver"}},
{B_DEVICE_PRETTY_NAME, B_STRING_TYPE, {string: "Legacy Driver Reservation"}}, {B_DEVICE_PRETTY_NAME, B_STRING_TYPE, {.string = "Legacy Driver Reservation"}},
{NULL} {NULL}
}; };
device_attr drvAttrs[] = { device_attr drvAttrs[] = {
// info about device // info about device
{B_DEVICE_BUS, B_STRING_TYPE, {string: "legacy_driver"}}, {B_DEVICE_BUS, B_STRING_TYPE, {.string = "legacy_driver"}},
{"legacy_driver", B_STRING_TYPE, {string: driverName}}, {"legacy_driver", B_STRING_TYPE, {.string = driverName}},
{"legacy_driver_cookie", B_UINT64_TYPE, {ui64: (uint64)nodeCookie}}, {"legacy_driver_cookie", B_UINT64_TYPE, {.ui64 = (uint64)nodeCookie}},
{NULL} {NULL}
}; };
device_node *root, *pci, *node, *legacy, *drv; device_node *root, *pci, *node, *legacy, *drv;
src/add-ons/kernel/bus_managers/pci/pci_root.cpp
+13 -13
View File
@@ -81,8 +81,8 @@ pci_root_register_device(device_node* parent)
{} {}
}; };
device_attr attrs[] = { device_attr attrs[] = {
{B_DEVICE_PRETTY_NAME, B_STRING_TYPE, {string: "PCI"}}, {B_DEVICE_PRETTY_NAME, B_STRING_TYPE, {.string = "PCI"}},
{B_DEVICE_FLAGS, B_UINT32_TYPE, {ui32: B_KEEP_DRIVER_LOADED}}, {B_DEVICE_FLAGS, B_UINT32_TYPE, {.ui32 = B_KEEP_DRIVER_LOADED}},
{} {}
}; };
@@ -107,23 +107,23 @@ pci_root_register_child_devices(void* cookie)
device_attr attrs[] = { device_attr attrs[] = {
// info about device // info about device
{B_DEVICE_BUS, B_STRING_TYPE, {string: "pci"}}, {B_DEVICE_BUS, B_STRING_TYPE, {.string = "pci"}},
// location on PCI bus // location on PCI bus
{B_PCI_DEVICE_DOMAIN, B_UINT8_TYPE, {ui8: domain}}, {B_PCI_DEVICE_DOMAIN, B_UINT8_TYPE, {.ui8 = domain}},
{B_PCI_DEVICE_BUS, B_UINT8_TYPE, {ui8: bus}}, {B_PCI_DEVICE_BUS, B_UINT8_TYPE, {.ui8 = bus}},
{B_PCI_DEVICE_DEVICE, B_UINT8_TYPE, {ui8: info.device}}, {B_PCI_DEVICE_DEVICE, B_UINT8_TYPE, {.ui8 = info.device}},
{B_PCI_DEVICE_FUNCTION, B_UINT8_TYPE, {ui8: info.function}}, {B_PCI_DEVICE_FUNCTION, B_UINT8_TYPE, {.ui8 = info.function}},
// info about the device // info about the device
{B_DEVICE_VENDOR_ID, B_UINT16_TYPE, { ui16: info.vendor_id }}, {B_DEVICE_VENDOR_ID, B_UINT16_TYPE, {.ui16 = info.vendor_id}},
{B_DEVICE_ID, B_UINT16_TYPE, { ui16: info.device_id }}, {B_DEVICE_ID, B_UINT16_TYPE, {.ui16 = info.device_id}},
{B_DEVICE_TYPE, B_UINT16_TYPE, { ui16: info.class_base }}, {B_DEVICE_TYPE, B_UINT16_TYPE, {.ui16 = info.class_base}},
{B_DEVICE_SUB_TYPE, B_UINT16_TYPE, { ui16: info.class_sub }}, {B_DEVICE_SUB_TYPE, B_UINT16_TYPE, {.ui16 = info.class_sub}},
{B_DEVICE_INTERFACE, B_UINT16_TYPE, { ui16: info.class_api }}, {B_DEVICE_INTERFACE, B_UINT16_TYPE, {.ui16 = info.class_api}},
{B_DEVICE_FLAGS, B_UINT32_TYPE, {ui32: B_FIND_CHILD_ON_DEMAND}}, {B_DEVICE_FLAGS, B_UINT32_TYPE, {.ui32 = B_FIND_CHILD_ON_DEMAND}},
{} {}
}; };
src/add-ons/kernel/bus_managers/random/driver.cpp
+2 -2
View File
@@ -170,8 +170,8 @@ random_register_device(device_node *node)
// ready to register // ready to register
device_attr attrs[] = { device_attr attrs[] = {
{ B_DEVICE_PRETTY_NAME, B_STRING_TYPE, { string: "Random" }}, { B_DEVICE_PRETTY_NAME, B_STRING_TYPE, { .string = "Random" }},
{ B_DEVICE_FLAGS, B_UINT32_TYPE, { ui32: B_KEEP_DRIVER_LOADED }}, { B_DEVICE_FLAGS, B_UINT32_TYPE, { .ui32 = B_KEEP_DRIVER_LOADED }},
{ NULL } { NULL }
}; };
src/add-ons/kernel/bus_managers/scsi/devices.cpp
+13 -13
View File
@@ -114,29 +114,29 @@ scsi_register_device(scsi_bus_info *bus, uchar target_id,
char product_rev[sizeof( inquiry_data->product_rev ) + 1]; char product_rev[sizeof( inquiry_data->product_rev ) + 1];
device_attr attrs[] = { device_attr attrs[] = {
// connection // connection
{ SCSI_DEVICE_TARGET_ID_ITEM, B_UINT8_TYPE, { ui8: target_id }}, { SCSI_DEVICE_TARGET_ID_ITEM, B_UINT8_TYPE, { .ui8 = target_id }},
{ SCSI_DEVICE_TARGET_LUN_ITEM, B_UINT8_TYPE, { ui8: target_lun }}, { SCSI_DEVICE_TARGET_LUN_ITEM, B_UINT8_TYPE, { .ui8 = target_lun }},
// inquiry data (used for both identification and information) // inquiry data (used for both identification and information)
{ SCSI_DEVICE_INQUIRY_ITEM, B_RAW_TYPE, { SCSI_DEVICE_INQUIRY_ITEM, B_RAW_TYPE,
{ raw: { inquiry_data, sizeof( *inquiry_data ) }}}, { .raw = { inquiry_data, sizeof( *inquiry_data ) }}},
// some more info for driver loading // some more info for driver loading
{ SCSI_DEVICE_TYPE_ITEM, B_UINT8_TYPE, { ui8: inquiry_data->device_type }}, { SCSI_DEVICE_TYPE_ITEM, B_UINT8_TYPE, { .ui8 = inquiry_data->device_type }},
{ SCSI_DEVICE_VENDOR_ITEM, B_STRING_TYPE, { string: vendor_ident }}, { SCSI_DEVICE_VENDOR_ITEM, B_STRING_TYPE, { .string = vendor_ident }},
{ SCSI_DEVICE_PRODUCT_ITEM, B_STRING_TYPE, { string: product_ident }}, { SCSI_DEVICE_PRODUCT_ITEM, B_STRING_TYPE, { .string = product_ident }},
{ SCSI_DEVICE_REVISION_ITEM, B_STRING_TYPE, { string: product_rev }}, { SCSI_DEVICE_REVISION_ITEM, B_STRING_TYPE, { .string = product_rev }},
// description of peripheral drivers // description of peripheral drivers
{ B_DEVICE_BUS, B_STRING_TYPE, { string: "scsi" }}, { B_DEVICE_BUS, B_STRING_TYPE, { .string = "scsi" }},
// extra restriction of maximum number of blocks per transfer // extra restriction of maximum number of blocks per transfer
{ B_DMA_MAX_TRANSFER_BLOCKS, B_UINT32_TYPE, { ui32: max_blocks }}, { B_DMA_MAX_TRANSFER_BLOCKS, B_UINT32_TYPE, { .ui32 = max_blocks }},
// atapi emulation // atapi emulation
{ SCSI_DEVICE_IS_ATAPI_ITEM, B_UINT8_TYPE, { ui8: is_atapi }}, { SCSI_DEVICE_IS_ATAPI_ITEM, B_UINT8_TYPE, { .ui8 = is_atapi }},
// manual autosense // manual autosense
{ SCSI_DEVICE_MANUAL_AUTOSENSE_ITEM, B_UINT8_TYPE, { ui8: manual_autosense }}, { SCSI_DEVICE_MANUAL_AUTOSENSE_ITEM, B_UINT8_TYPE, { .ui8 = manual_autosense }},
{ NULL } { NULL }
}; };
@@ -382,8 +382,8 @@ scsi_force_get_device(scsi_bus_info *bus, uchar target_id,
uchar target_lun, scsi_device_info **res_device) uchar target_lun, scsi_device_info **res_device)
{ {
device_attr attrs[] = { device_attr attrs[] = {
{ SCSI_DEVICE_TARGET_ID_ITEM, B_UINT8_TYPE, { ui8: target_id }}, { SCSI_DEVICE_TARGET_ID_ITEM, B_UINT8_TYPE, { .ui8 = target_id }},
{ SCSI_DEVICE_TARGET_LUN_ITEM, B_UINT8_TYPE, { ui8: target_lun }}, { SCSI_DEVICE_TARGET_LUN_ITEM, B_UINT8_TYPE, { .ui8 = target_lun }},
{ NULL } { NULL }
}; };
device_node *node; device_node *node;
src/add-ons/kernel/bus_managers/scsi/sim_interface.cpp
+4 -4
View File
@@ -47,16 +47,16 @@ scsi_controller_added(device_node *parent)
{ {
device_attr attrs[] = { device_attr attrs[] = {
{ B_DEVICE_PRETTY_NAME, B_STRING_TYPE, { B_DEVICE_PRETTY_NAME, B_STRING_TYPE,
{ string: "SCSI Controller" }}, { .string = "SCSI Controller" }},
// remember who we are // remember who we are
// (could use the controller name, but probably some software would choke) // (could use the controller name, but probably some software would choke)
// TODO create_id() generates a 32 bit ranged integer but we need only 8 bits // TODO create_id() generates a 32 bit ranged integer but we need only 8 bits
{ SCSI_BUS_PATH_ID_ITEM, B_UINT8_TYPE, { ui8: (uint8)pathID }}, { SCSI_BUS_PATH_ID_ITEM, B_UINT8_TYPE, { .ui8 = (uint8)pathID }},
// tell PnP manager to clean up ID // tell PnP manager to clean up ID
// { PNP_MANAGER_ID_GENERATOR, B_STRING_TYPE, { string: SCSI_PATHID_GENERATOR }}, // { PNP_MANAGER_ID_GENERATOR, B_STRING_TYPE, { .string = SCSI_PATHID_GENERATOR }},
// { PNP_MANAGER_AUTO_ID, B_UINT32_TYPE, { ui32: path_id }}, // { PNP_MANAGER_AUTO_ID, B_UINT32_TYPE, { .ui32 = path_id }},
{} {}
}; };
src/add-ons/kernel/bus_managers/usb/Device.cpp
+4 -4
View File
@@ -843,14 +843,14 @@ Device::RegisterNode(device_node *parent)
parent = ((Device*)Parent())->Node(); parent = ((Device*)Parent())->Node();
device_attr attrs[128] = { device_attr attrs[128] = {
{ B_DEVICE_BUS, B_STRING_TYPE, { string: "usb" }}, { B_DEVICE_BUS, B_STRING_TYPE, { .string = "usb" }},
// location // location
{ USB_DEVICE_ID_ITEM, B_UINT32_TYPE, { ui32: id }}, { USB_DEVICE_ID_ITEM, B_UINT32_TYPE, { .ui32 = id }},
{ B_DEVICE_FLAGS, B_UINT32_TYPE, { ui32: B_FIND_MULTIPLE_CHILDREN }}, { B_DEVICE_FLAGS, B_UINT32_TYPE, { .ui32 = B_FIND_MULTIPLE_CHILDREN }},
{ B_DEVICE_PRETTY_NAME, B_STRING_TYPE, { string: "USB device" }}, { B_DEVICE_PRETTY_NAME, B_STRING_TYPE, { .string = "USB device" }},
{ NULL } { NULL }
}; };
src/add-ons/kernel/bus_managers/virtio/VirtioModule.cpp
+2 -2
View File
@@ -220,9 +220,9 @@ virtio_added_device(device_node *parent)
device_attr attributes[] = { device_attr attributes[] = {
// info about device // info about device
{ B_DEVICE_BUS, B_STRING_TYPE, { string: "virtio" }}, { B_DEVICE_BUS, B_STRING_TYPE, { .string = "virtio" }},
{ VIRTIO_DEVICE_TYPE_ITEM, B_UINT16_TYPE, { VIRTIO_DEVICE_TYPE_ITEM, B_UINT16_TYPE,
{ ui16: deviceType }}, { .ui16 = deviceType }},
{ NULL } { NULL }
}; };
src/add-ons/kernel/bus_managers/virtio/virtio_balloon.cpp
+1 -1
View File
@@ -111,7 +111,7 @@ virtio_balloon_register_child_devices(void *cookie)
device_attr attrs[] = { device_attr attrs[] = {
{ B_DEVICE_PRETTY_NAME, B_STRING_TYPE, { B_DEVICE_PRETTY_NAME, B_STRING_TYPE,
{ string: VIRTIO_BALLOON_CONTROLLER_PRETTY_NAME }}, { .string = VIRTIO_BALLOON_CONTROLLER_PRETTY_NAME }},
{ NULL } { NULL }
}; };
src/add-ons/kernel/busses/ata/ide_isa/ide_isa.c
+9 -9
View File
@@ -64,23 +64,23 @@ publish_channel(device_node *parent, uint16 command_block_base,
uint16 control_block_base, uint8 intnum, const char *name) uint16 control_block_base, uint8 intnum, const char *name)
{ {
device_attr attrs[] = { device_attr attrs[] = {
{ B_DEVICE_FIXED_CHILD, B_STRING_TYPE, { string: ATA_FOR_CONTROLLER_MODULE_NAME }}, { B_DEVICE_FIXED_CHILD, B_STRING_TYPE, { .string = ATA_FOR_CONTROLLER_MODULE_NAME }},
// properties of this controller for ata bus manager // properties of this controller for ata bus manager
{ ATA_CONTROLLER_MAX_DEVICES_ITEM, B_UINT8_TYPE, { ui8: 2 }}, { ATA_CONTROLLER_MAX_DEVICES_ITEM, B_UINT8_TYPE, { .ui8 = 2 }},
{ ATA_CONTROLLER_CAN_DMA_ITEM, B_UINT8_TYPE, { ui8: 0 }}, { ATA_CONTROLLER_CAN_DMA_ITEM, B_UINT8_TYPE, { .ui8 = 0 }},
{ ATA_CONTROLLER_CONTROLLER_NAME_ITEM, B_STRING_TYPE, { string: name }}, { ATA_CONTROLLER_CONTROLLER_NAME_ITEM, B_STRING_TYPE, { .string = name }},
// DMA properties; the 16 bit alignment is not necessary as // DMA properties; the 16 bit alignment is not necessary as
// the ata bus manager handles that very efficiently, but why // the ata bus manager handles that very efficiently, but why
// not use the block device manager for doing that? // not use the block device manager for doing that?
{ B_DMA_ALIGNMENT, B_UINT32_TYPE, { ui32: 1 }}, { B_DMA_ALIGNMENT, B_UINT32_TYPE, { .ui32 = 1 }},
{ B_DMA_HIGH_ADDRESS, B_UINT64_TYPE, { ui64: 0x100000000LL }}, { B_DMA_HIGH_ADDRESS, B_UINT64_TYPE, { .ui64 = 0x100000000LL }},
// private data to identify device // private data to identify device
{ ATA_ISA_COMMAND_BLOCK_BASE, B_UINT16_TYPE, { ui16: command_block_base }}, { ATA_ISA_COMMAND_BLOCK_BASE, B_UINT16_TYPE, { .ui16 = command_block_base }},
{ ATA_ISA_CONTROL_BLOCK_BASE, B_UINT16_TYPE, { ui16: control_block_base }}, { ATA_ISA_CONTROL_BLOCK_BASE, B_UINT16_TYPE, { .ui16 = control_block_base }},
{ ATA_ISA_INTNUM, B_UINT8_TYPE, { ui8: intnum }}, { ATA_ISA_INTNUM, B_UINT8_TYPE, { .ui8 = intnum }},
{ NULL } { NULL }
}; };
io_resource resources[3] = { io_resource resources[3] = {
src/add-ons/kernel/busses/ata/promise_tx2/promise_tx2.c
+10 -11
View File
@@ -179,28 +179,27 @@ publish_controller(device_node *parent, uint16 bus_master_base, uint8 intnum,
device_attr attrs[] = { device_attr attrs[] = {
// properties of this controller for ide bus manager // properties of this controller for ide bus manager
// there are always max. 2 devices // there are always max. 2 devices
{ ATA_CONTROLLER_MAX_DEVICES_ITEM, B_UINT8_TYPE, { ui8: 2 }}, { ATA_CONTROLLER_MAX_DEVICES_ITEM, B_UINT8_TYPE, { .ui8 = 2 }},
// of course we can DMA // of course we can DMA
{ ATA_CONTROLLER_CAN_DMA_ITEM, B_UINT8_TYPE, { ui8: 1 }}, { ATA_CONTROLLER_CAN_DMA_ITEM, B_UINT8_TYPE, { .ui8 = 1 }},
// choose any name here // choose any name here
{ ATA_CONTROLLER_CONTROLLER_NAME_ITEM, B_STRING_TYPE, { string: "Promise TX2" }}, { ATA_CONTROLLER_CONTROLLER_NAME_ITEM, B_STRING_TYPE, { .string = "Promise TX2" }},
// DMA properties // DMA properties
// some say it must be dword-aligned, others that it can be byte-aligned; // some say it must be dword-aligned, others that it can be byte-aligned;
// stay on the safe side // stay on the safe side
{ B_DMA_ALIGNMENT, B_UINT32_TYPE, { ui32: 3 }}, { B_DMA_ALIGNMENT, B_UINT32_TYPE, { .ui32 = 3 }},
// one S/G block must not cross 64K boundary // one S/G block must not cross 64K boundary
{ B_DMA_BOUNDARY, B_UINT32_TYPE, { ui32: 0xffff }}, { B_DMA_BOUNDARY, B_UINT32_TYPE, { .ui32 = 0xffff }},
// size of S/G block is 16 bits with zero being 64K // size of S/G block is 16 bits with zero being 64K
{ B_DMA_MAX_SEGMENT_BLOCKS, B_UINT32_TYPE, { ui32: 0x10000 }}, { B_DMA_MAX_SEGMENT_BLOCKS, B_UINT32_TYPE, { .ui32 = 0x10000 }},
{ B_DMA_MAX_SEGMENT_COUNT, B_UINT32_TYPE, { B_DMA_MAX_SEGMENT_COUNT, B_UINT32_TYPE, { .ui32 = ATA_ADAPTER_MAX_SG_COUNT }},
{ ui32: ATA_ADAPTER_MAX_SG_COUNT }}, { B_DMA_HIGH_ADDRESS, B_UINT64_TYPE, { .ui64 = 0x100000000LL }},
{ B_DMA_HIGH_ADDRESS, B_UINT64_TYPE, { ui64: 0x100000000LL }},
// private data to find controller // private data to find controller
{ ATA_ADAPTER_BUS_MASTER_BASE, B_UINT16_TYPE, { ui16: bus_master_base }}, { ATA_ADAPTER_BUS_MASTER_BASE, B_UINT16_TYPE, { .ui16 = bus_master_base }},
// store interrupt in controller node // store interrupt in controller node
{ ATA_ADAPTER_INTNUM, B_UINT8_TYPE, { ui8: intnum }}, { ATA_ADAPTER_INTNUM, B_UINT8_TYPE, { .ui8 = intnum }},
{ NULL } { NULL }
}; };
src/add-ons/kernel/busses/ata/silicon_image_3112/silicon_image_3112.c
+16 -16
View File
@@ -205,32 +205,32 @@ controller_probe(device_node *parent)
// (unless this is a Compact Flash Card with a built-in ATA // (unless this is a Compact Flash Card with a built-in ATA
// controller, which has exactly 1 device) // controller, which has exactly 1 device)
{ ATA_CONTROLLER_MAX_DEVICES_ITEM, B_UINT8_TYPE, { ATA_CONTROLLER_MAX_DEVICES_ITEM, B_UINT8_TYPE,
{ ui8: kASICData[asicIndex].channel_count }}, { .ui8 = kASICData[asicIndex].channel_count }},
// of course we can DMA // of course we can DMA
{ ATA_CONTROLLER_CAN_DMA_ITEM, B_UINT8_TYPE, { ui8: true }}, { ATA_CONTROLLER_CAN_DMA_ITEM, B_UINT8_TYPE, { .ui8 = true }},
// choose any name here // choose any name here
{ ATA_CONTROLLER_CONTROLLER_NAME_ITEM, B_STRING_TYPE, { ATA_CONTROLLER_CONTROLLER_NAME_ITEM, B_STRING_TYPE,
{ string: CONTROLLER_NAME }}, { .string = CONTROLLER_NAME }},
// DMA properties // DMA properties
// data must be word-aligned; // data must be word-aligned;
// warning: some controllers are more picky! // warning: some controllers are more picky!
{ B_DMA_ALIGNMENT, B_UINT32_TYPE, { ui32: 1}}, { B_DMA_ALIGNMENT, B_UINT32_TYPE, { .ui32 = 1}},
// one S/G block must not cross 64K boundary // one S/G block must not cross 64K boundary
{ B_DMA_BOUNDARY, B_UINT32_TYPE, { ui32: 0xffff }}, { B_DMA_BOUNDARY, B_UINT32_TYPE, { .ui32 = 0xffff }},
// max size of S/G block is 16 bits with zero being 64K // max size of S/G block is 16 bits with zero being 64K
{ B_DMA_MAX_SEGMENT_BLOCKS, B_UINT32_TYPE, { ui32: 0x10000 }}, { B_DMA_MAX_SEGMENT_BLOCKS, B_UINT32_TYPE, { .ui32 = 0x10000 }},
{ B_DMA_MAX_SEGMENT_COUNT, B_UINT32_TYPE, { B_DMA_MAX_SEGMENT_COUNT, B_UINT32_TYPE,
{ ui32: ATA_ADAPTER_MAX_SG_COUNT }}, { .ui32 = ATA_ADAPTER_MAX_SG_COUNT }},
{ B_DMA_HIGH_ADDRESS, B_UINT64_TYPE, { ui64: 0x100000000LL }}, { B_DMA_HIGH_ADDRESS, B_UINT64_TYPE, { .ui64 = 0x100000000LL }},
// private data to find controller // private data to find controller
{ "silicon_image_3112/asic_index", B_UINT32_TYPE, { "silicon_image_3112/asic_index", B_UINT32_TYPE,
{ ui32: asicIndex }}, { .ui32 = asicIndex }},
{ "silicon_image_3112/mmio_base", B_UINT32_TYPE, { "silicon_image_3112/mmio_base", B_UINT32_TYPE,
{ ui32: mmioBase }}, { .ui32 = mmioBase }},
{ "silicon_image_3112/int_num", B_UINT32_TYPE, { "silicon_image_3112/int_num", B_UINT32_TYPE,
{ ui32: interruptNumber }}, { .ui32 = interruptNumber }},
{ NULL } { NULL }
}; };
@@ -373,13 +373,13 @@ controller_register_channels(void *cookie)
for (index = 0; index < kASICData[controller->asic_index].channel_count; for (index = 0; index < kASICData[controller->asic_index].channel_count;
index++) { index++) {
device_attr attrs[] = { device_attr attrs[] = {
{ B_DEVICE_PRETTY_NAME, B_STRING_TYPE, { string: DRIVER_PRETTY_NAME }}, { B_DEVICE_PRETTY_NAME, B_STRING_TYPE, { .string = DRIVER_PRETTY_NAME }},
// { PNP_DRIVER_CONNECTION, B_STRING_TYPE, { string: kControllerChannelData[channelIndex].name }}, // { PNP_DRIVER_CONNECTION, B_STRING_TYPE, { .string = kControllerChannelData[channelIndex].name }},
{ B_DEVICE_FIXED_CHILD, B_STRING_TYPE, { string: ATA_FOR_CONTROLLER_MODULE_NAME }}, { B_DEVICE_FIXED_CHILD, B_STRING_TYPE, { .string = ATA_FOR_CONTROLLER_MODULE_NAME }},
// private data to identify channel // private data to identify channel
{ ATA_CONTROLLER_CAN_DMA_ITEM, B_UINT8_TYPE, { ui8: true }}, { ATA_CONTROLLER_CAN_DMA_ITEM, B_UINT8_TYPE, { .ui8 = true }},
{ "silicon_image_3112/chan_index", B_UINT32_TYPE, { ui32: index }}, { "silicon_image_3112/chan_index", B_UINT32_TYPE, { .ui32 = index }},
{ NULL } { NULL }
}; };
src/add-ons/kernel/busses/i2c/pch/pch_i2c_acpi.cpp
+3 -3
View File
@@ -87,9 +87,9 @@ register_child_devices(void* cookie)
device_attr attrs[] = { device_attr attrs[] = {
// properties of this controller for i2c bus manager // properties of this controller for i2c bus manager
{ B_DEVICE_PRETTY_NAME, B_STRING_TYPE, { B_DEVICE_PRETTY_NAME, B_STRING_TYPE,
{ string: prettyName }}, { .string = prettyName }},
{ B_DEVICE_FIXED_CHILD, B_STRING_TYPE, { B_DEVICE_FIXED_CHILD, B_STRING_TYPE,
{ string: I2C_FOR_CONTROLLER_MODULE_NAME }}, { .string = I2C_FOR_CONTROLLER_MODULE_NAME }},
// private data to identify the device // private data to identify the device
{ NULL } { NULL }
@@ -163,7 +163,7 @@ static status_t
register_device(device_node* parent) register_device(device_node* parent)
{ {
device_attr attrs[] = { device_attr attrs[] = {
{B_DEVICE_PRETTY_NAME, B_STRING_TYPE, {string: "PCH I2C ACPI"}}, {B_DEVICE_PRETTY_NAME, B_STRING_TYPE, {.string = "PCH I2C ACPI"}},
{} {}
}; };
src/add-ons/kernel/busses/i2c/pch/pch_i2c_pci.cpp
+5 -5
View File
@@ -48,8 +48,8 @@ pci_scan_bus(i2c_bus_cookie cookie)
device_node* deviceRoot = gDeviceManager->get_root_node(); device_node* deviceRoot = gDeviceManager->get_root_node();
uint32 addr = (pciInfo->device << 16) | pciInfo->function; uint32 addr = (pciInfo->device << 16) | pciInfo->function;
device_attr acpiAttrs[] = { device_attr acpiAttrs[] = {
{ B_DEVICE_BUS, B_STRING_TYPE, { string: "acpi" }}, { B_DEVICE_BUS, B_STRING_TYPE, { .string = "acpi" }},
{ ACPI_DEVICE_ADDR_ITEM, B_UINT32_TYPE, {ui32: addr}}, { ACPI_DEVICE_ADDR_ITEM, B_UINT32_TYPE, {.ui32 = addr}},
{ NULL } { NULL }
}; };
if (addr != 0 && gDeviceManager->find_child_node(deviceRoot, acpiAttrs, if (addr != 0 && gDeviceManager->find_child_node(deviceRoot, acpiAttrs,
@@ -89,9 +89,9 @@ register_child_devices(void* cookie)
device_attr attrs[] = { device_attr attrs[] = {
// properties of this controller for i2c bus manager // properties of this controller for i2c bus manager
{ B_DEVICE_PRETTY_NAME, B_STRING_TYPE, { B_DEVICE_PRETTY_NAME, B_STRING_TYPE,
{ string: prettyName }}, { .string = prettyName }},
{ B_DEVICE_FIXED_CHILD, B_STRING_TYPE, { B_DEVICE_FIXED_CHILD, B_STRING_TYPE,
{ string: I2C_FOR_CONTROLLER_MODULE_NAME }}, { .string = I2C_FOR_CONTROLLER_MODULE_NAME }},
// private data to identify the device // private data to identify the device
{ NULL } { NULL }
@@ -232,7 +232,7 @@ static status_t
register_device(device_node* parent) register_device(device_node* parent)
{ {
device_attr attrs[] = { device_attr attrs[] = {
{B_DEVICE_PRETTY_NAME, B_STRING_TYPE, {string: "PCH I2C PCI"}}, {B_DEVICE_PRETTY_NAME, B_STRING_TYPE, {.string = "PCH I2C PCI"}},
{} {}
}; };
src/add-ons/kernel/busses/mmc/sdhci_pci.cpp
+11 -11
View File
@@ -781,24 +781,24 @@ register_child_devices(void* cookie)
sprintf(prettyName, "SDHC bus %" B_PRIu8, slot); sprintf(prettyName, "SDHC bus %" B_PRIu8, slot);
device_attr attrs[] = { device_attr attrs[] = {
// properties of this controller for mmc bus manager // properties of this controller for mmc bus manager
{ B_DEVICE_PRETTY_NAME, B_STRING_TYPE, { string: prettyName } }, { B_DEVICE_PRETTY_NAME, B_STRING_TYPE, { .string = prettyName } },
{ B_DEVICE_FIXED_CHILD, B_STRING_TYPE, { B_DEVICE_FIXED_CHILD, B_STRING_TYPE,
{string: MMC_BUS_MODULE_NAME} }, {.string = MMC_BUS_MODULE_NAME} },
{ B_DEVICE_BUS, B_STRING_TYPE, {string: "mmc"} }, { B_DEVICE_BUS, B_STRING_TYPE, {.string = "mmc"} },
// DMA properties // DMA properties
// The high alignment is to force access only to complete sectors // The high alignment is to force access only to complete sectors
// These constraints could be removed by using ADMA which allows // These constraints could be removed by using ADMA which allows
// use of the full 64bit address space and can do scatter-gather. // use of the full 64bit address space and can do scatter-gather.
{ B_DMA_ALIGNMENT, B_UINT32_TYPE, { ui32: 511 }}, { B_DMA_ALIGNMENT, B_UINT32_TYPE, { .ui32 = 511 }},
{ B_DMA_HIGH_ADDRESS, B_UINT64_TYPE, { ui64: 0x100000000LL }}, { B_DMA_HIGH_ADDRESS, B_UINT64_TYPE, { .ui64 = 0x100000000LL }},
{ B_DMA_BOUNDARY, B_UINT32_TYPE, { ui32: (1 << 19) - 1 }}, { B_DMA_BOUNDARY, B_UINT32_TYPE, { .ui32 = (1 << 19) - 1 }},
{ B_DMA_MAX_SEGMENT_COUNT, B_UINT32_TYPE, { ui32: 1 }}, { B_DMA_MAX_SEGMENT_COUNT, B_UINT32_TYPE, { .ui32 = 1 }},
{ B_DMA_MAX_SEGMENT_BLOCKS, B_UINT32_TYPE, { ui32: (1 << 10) - 1 }}, { B_DMA_MAX_SEGMENT_BLOCKS, B_UINT32_TYPE, { .ui32 = (1 << 10) - 1 }},
// private data to identify device // private data to identify device
{ SLOT_NUMBER, B_UINT8_TYPE, { ui8: slot} }, { SLOT_NUMBER, B_UINT8_TYPE, { .ui8 = slot} },
{ BAR_INDEX, B_UINT8_TYPE, { ui8: bar} }, { BAR_INDEX, B_UINT8_TYPE, { .ui8 = bar} },
{ NULL } { NULL }
}; };
device_node* node; device_node* node;
@@ -894,7 +894,7 @@ static status_t
register_device(device_node* parent) register_device(device_node* parent)
{ {
device_attr attrs[] = { device_attr attrs[] = {
{B_DEVICE_PRETTY_NAME, B_STRING_TYPE, {string: "SD Host Controller"}}, {B_DEVICE_PRETTY_NAME, B_STRING_TYPE, {.string = "SD Host Controller"}},
{} {}
}; };
src/add-ons/kernel/busses/random/ccp/ccp.cpp
+2 -2
View File
@@ -55,8 +55,8 @@ static status_t
register_device(device_node* parent) register_device(device_node* parent)
{ {
device_attr attrs[] = { device_attr attrs[] = {
{B_DEVICE_PRETTY_NAME, B_STRING_TYPE, {string: "CCP device"}}, {B_DEVICE_PRETTY_NAME, B_STRING_TYPE, {.string = "CCP device"}},
{B_DEVICE_BUS, B_STRING_TYPE, {string: "CCP"}}, {B_DEVICE_BUS, B_STRING_TYPE, {.string = "CCP"}},
{} {}
}; };
src/add-ons/kernel/busses/random/ccp/ccp_acpi.cpp
+3 -3
View File
@@ -109,9 +109,9 @@ static status_t
register_device(device_node* parent) register_device(device_node* parent)
{ {
device_attr attrs[] = { device_attr attrs[] = {
{B_DEVICE_PRETTY_NAME, B_STRING_TYPE, {string: "CCP ACPI"}}, {B_DEVICE_PRETTY_NAME, B_STRING_TYPE, {.string = "CCP ACPI"}},
{B_DEVICE_BUS, B_STRING_TYPE, {string: "CCP"}}, {B_DEVICE_BUS, B_STRING_TYPE, {.string = "CCP"}},
{B_DEVICE_FIXED_CHILD, B_STRING_TYPE, {string: CCP_DEVICE_MODULE_NAME}}, {B_DEVICE_FIXED_CHILD, B_STRING_TYPE, {.string = CCP_DEVICE_MODULE_NAME}},
{} {}
}; };
src/add-ons/kernel/busses/random/ccp/ccp_pci.cpp
+3 -3
View File
@@ -89,9 +89,9 @@ static status_t
register_device(device_node* parent) register_device(device_node* parent)
{ {
device_attr attrs[] = { device_attr attrs[] = {
{B_DEVICE_PRETTY_NAME, B_STRING_TYPE, {string: "CCP PCI"}}, {B_DEVICE_PRETTY_NAME, B_STRING_TYPE, {.string = "CCP PCI"}},
{B_DEVICE_BUS, B_STRING_TYPE, {string: "CCP"}}, {B_DEVICE_BUS, B_STRING_TYPE, {.string = "CCP"}},
{B_DEVICE_FIXED_CHILD, B_STRING_TYPE, {string: CCP_DEVICE_MODULE_NAME}}, {B_DEVICE_FIXED_CHILD, B_STRING_TYPE, {.string = CCP_DEVICE_MODULE_NAME}},
{} {}
}; };
src/add-ons/kernel/busses/scsi/ahci/ahci.c
+14 -14
View File
@@ -174,17 +174,17 @@ register_sim(device_node *parent)
{ {
device_attr attrs[] = { device_attr attrs[] = {
{ B_DEVICE_FIXED_CHILD, B_STRING_TYPE, { B_DEVICE_FIXED_CHILD, B_STRING_TYPE,
{ string: SCSI_FOR_SIM_MODULE_NAME }}, { .string = SCSI_FOR_SIM_MODULE_NAME }},
{ B_DEVICE_PRETTY_NAME, B_STRING_TYPE, { B_DEVICE_PRETTY_NAME, B_STRING_TYPE,
{ string: AHCI_CONTROLLER_PRETTY_NAME }}, { .string = AHCI_CONTROLLER_PRETTY_NAME }},
{ SCSI_DESCRIPTION_CONTROLLER_NAME, B_STRING_TYPE, { SCSI_DESCRIPTION_CONTROLLER_NAME, B_STRING_TYPE,
{ string: AHCI_DEVICE_MODULE_NAME }}, { .string = AHCI_DEVICE_MODULE_NAME }},
{ B_DMA_MAX_TRANSFER_BLOCKS, B_UINT32_TYPE, { ui32: 255 }}, { B_DMA_MAX_TRANSFER_BLOCKS, B_UINT32_TYPE, { .ui32 = 255 }},
{ AHCI_ID_ITEM, B_UINT32_TYPE, { ui32: (uint32)id }}, { AHCI_ID_ITEM, B_UINT32_TYPE, { .ui32 = (uint32)id }},
// { PNP_MANAGER_ID_GENERATOR, B_STRING_TYPE, // { PNP_MANAGER_ID_GENERATOR, B_STRING_TYPE,
// { string: AHCI_ID_GENERATOR }}, // { .string = AHCI_ID_GENERATOR }},
// { PNP_MANAGER_AUTO_ID, B_UINT32_TYPE, { ui32: id }}, // { PNP_MANAGER_AUTO_ID, B_UINT32_TYPE, { .ui32 = id }},
{ NULL } { NULL }
}; };
@@ -265,20 +265,20 @@ ahci_register_device(device_node *parent)
{ {
device_attr attrs[] = { device_attr attrs[] = {
{ SCSI_DEVICE_MAX_TARGET_COUNT, B_UINT32_TYPE, { SCSI_DEVICE_MAX_TARGET_COUNT, B_UINT32_TYPE,
{ ui32: 33 }}, { .ui32 = 33 }},
{ B_DEVICE_PRETTY_NAME, B_STRING_TYPE, { B_DEVICE_PRETTY_NAME, B_STRING_TYPE,
{ string: AHCI_BRIDGE_PRETTY_NAME }}, { .string = AHCI_BRIDGE_PRETTY_NAME }},
// DMA properties // DMA properties
// data must be word-aligned; // data must be word-aligned;
{ B_DMA_ALIGNMENT, B_UINT32_TYPE, { ui32: 1 }}, { B_DMA_ALIGNMENT, B_UINT32_TYPE, { .ui32 = 1 }},
// one S/G block must not cross 64K boundary // one S/G block must not cross 64K boundary
{ B_DMA_BOUNDARY, B_UINT32_TYPE, { ui32: 0xffff }}, { B_DMA_BOUNDARY, B_UINT32_TYPE, { .ui32 = 0xffff }},
// max size of S/G block is 16 bits with zero being 64K // max size of S/G block is 16 bits with zero being 64K
{ B_DMA_MAX_SEGMENT_BLOCKS, B_UINT32_TYPE, { ui32: 0x10000 }}, { B_DMA_MAX_SEGMENT_BLOCKS, B_UINT32_TYPE, { .ui32 = 0x10000 }},
{ B_DMA_MAX_SEGMENT_COUNT, B_UINT32_TYPE, { B_DMA_MAX_SEGMENT_COUNT, B_UINT32_TYPE,
{ ui32: 32 /* whatever... */ }}, { .ui32 = 32 /* whatever... */ }},
{ B_DMA_HIGH_ADDRESS, B_UINT64_TYPE, { ui64: 0x100000000LL }}, { B_DMA_HIGH_ADDRESS, B_UINT64_TYPE, { .ui64 = 0x100000000LL }},
// TODO: We don't know at this point whether 64 bit addressing is // TODO: We don't know at this point whether 64 bit addressing is
// supported. That's indicated by a capability flag. Play it safe // supported. That's indicated by a capability flag. Play it safe
// for now. // for now.
src/add-ons/kernel/busses/scsi/virtio/virtio_scsi.cpp
+10 -10
View File
@@ -212,16 +212,16 @@ virtio_scsi_register_device(device_node *parent)
device_attr attrs[] = { device_attr attrs[] = {
{ SCSI_DEVICE_MAX_TARGET_COUNT, B_UINT32_TYPE, { SCSI_DEVICE_MAX_TARGET_COUNT, B_UINT32_TYPE,
{ ui32: max_targets }}, { .ui32 = max_targets }},
{ SCSI_DEVICE_MAX_LUN_COUNT, B_UINT32_TYPE, { SCSI_DEVICE_MAX_LUN_COUNT, B_UINT32_TYPE,
{ ui32: max_luns }}, { .ui32 = max_luns }},
{ B_DEVICE_PRETTY_NAME, B_STRING_TYPE, { B_DEVICE_PRETTY_NAME, B_STRING_TYPE,
{ string: VIRTIO_SCSI_BRIDGE_PRETTY_NAME }}, { .string = VIRTIO_SCSI_BRIDGE_PRETTY_NAME }},
// DMA properties // DMA properties
{ B_DMA_MAX_SEGMENT_BLOCKS, B_UINT32_TYPE, { ui32: max_blocks }}, { B_DMA_MAX_SEGMENT_BLOCKS, B_UINT32_TYPE, { .ui32 = max_blocks }},
{ B_DMA_MAX_SEGMENT_COUNT, B_UINT32_TYPE, { B_DMA_MAX_SEGMENT_COUNT, B_UINT32_TYPE,
{ ui32: config.seg_max }}, { .ui32 = config.seg_max }},
{ NULL } { NULL }
}; };
@@ -251,13 +251,13 @@ virtio_scsi_register_child_devices(void *cookie)
device_attr attrs[] = { device_attr attrs[] = {
{ B_DEVICE_FIXED_CHILD, B_STRING_TYPE, { B_DEVICE_FIXED_CHILD, B_STRING_TYPE,
{ string: SCSI_FOR_SIM_MODULE_NAME }}, { .string = SCSI_FOR_SIM_MODULE_NAME }},
{ B_DEVICE_PRETTY_NAME, B_STRING_TYPE, { B_DEVICE_PRETTY_NAME, B_STRING_TYPE,
{ string: VIRTIO_SCSI_CONTROLLER_PRETTY_NAME }}, { .string = VIRTIO_SCSI_CONTROLLER_PRETTY_NAME }},
{ SCSI_DESCRIPTION_CONTROLLER_NAME, B_STRING_TYPE, { SCSI_DESCRIPTION_CONTROLLER_NAME, B_STRING_TYPE,
{ string: VIRTIO_SCSI_DEVICE_MODULE_NAME }}, { .string = VIRTIO_SCSI_DEVICE_MODULE_NAME }},
{ B_DMA_MAX_TRANSFER_BLOCKS, B_UINT32_TYPE, { ui32: 255 }}, { B_DMA_MAX_TRANSFER_BLOCKS, B_UINT32_TYPE, { .ui32 = 255 }},
{ VIRTIO_SCSI_ID_ITEM, B_UINT32_TYPE, { ui32: (uint32)id }}, { VIRTIO_SCSI_ID_ITEM, B_UINT32_TYPE, { .ui32 = (uint32)id }},
{ NULL } { NULL }
}; };
src/add-ons/kernel/busses/usb/ehci.cpp
+6 -6
View File
@@ -107,9 +107,9 @@ register_child_devices(void* cookie)
device_attr attrs[] = { device_attr attrs[] = {
// properties of this controller for the usb bus manager // properties of this controller for the usb bus manager
{ B_DEVICE_PRETTY_NAME, B_STRING_TYPE, { B_DEVICE_PRETTY_NAME, B_STRING_TYPE,
{ string: prettyName }}, { .string = prettyName }},
{ B_DEVICE_FIXED_CHILD, B_STRING_TYPE, { B_DEVICE_FIXED_CHILD, B_STRING_TYPE,
{ string: USB_FOR_CONTROLLER_MODULE_NAME }}, { .string = USB_FOR_CONTROLLER_MODULE_NAME }},
// private data to identify the device // private data to identify the device
{ NULL } { NULL }
@@ -165,7 +165,7 @@ register_device(device_node* parent)
{ {
CALLED(); CALLED();
device_attr attrs[] = { device_attr attrs[] = {
{B_DEVICE_PRETTY_NAME, B_STRING_TYPE, {string: "EHCI PCI"}}, {B_DEVICE_PRETTY_NAME, B_STRING_TYPE, {.string = "EHCI PCI"}},
{} {}
}; };
@@ -401,9 +401,9 @@ EHCI::EHCI(pci_info *info, pci_device_module_info* pci, pci_device* device, Stac
device_node *pciNode = NULL; device_node *pciNode = NULL;
device_node* deviceRoot = gDeviceManager->get_root_node(); device_node* deviceRoot = gDeviceManager->get_root_node();
device_attr acpiAttrs[] = { device_attr acpiAttrs[] = {
{ B_DEVICE_BUS, B_STRING_TYPE, { string: "pci" }}, { B_DEVICE_BUS, B_STRING_TYPE, { .string = "pci" }},
{ B_DEVICE_VENDOR_ID, B_UINT16_TYPE, {ui16: AMD_SBX00_VENDOR}}, { B_DEVICE_VENDOR_ID, B_UINT16_TYPE, { .ui16 = AMD_SBX00_VENDOR }},
{ B_DEVICE_ID, B_UINT16_TYPE, {ui16: AMD_SBX00_SMBUS_CONTROLLER}}, { B_DEVICE_ID, B_UINT16_TYPE, { .ui16 = AMD_SBX00_SMBUS_CONTROLLER }},
{ NULL } { NULL }
}; };
if (gDeviceManager->find_child_node(deviceRoot, acpiAttrs, if (gDeviceManager->find_child_node(deviceRoot, acpiAttrs,
src/add-ons/kernel/busses/usb/ohci.cpp
+3 -3
View File
@@ -109,9 +109,9 @@ register_child_devices(void* cookie)
device_attr attrs[] = { device_attr attrs[] = {
// properties of this controller for the usb bus manager // properties of this controller for the usb bus manager
{ B_DEVICE_PRETTY_NAME, B_STRING_TYPE, { B_DEVICE_PRETTY_NAME, B_STRING_TYPE,
{ string: prettyName }}, { .string = prettyName }},
{ B_DEVICE_FIXED_CHILD, B_STRING_TYPE, { B_DEVICE_FIXED_CHILD, B_STRING_TYPE,
{ string: USB_FOR_CONTROLLER_MODULE_NAME }}, { .string = USB_FOR_CONTROLLER_MODULE_NAME }},
// private data to identify the device // private data to identify the device
{ NULL } { NULL }
@@ -166,7 +166,7 @@ register_device(device_node* parent)
{ {
CALLED(); CALLED();
device_attr attrs[] = { device_attr attrs[] = {
{B_DEVICE_PRETTY_NAME, B_STRING_TYPE, {string: "OHCI PCI"}}, {B_DEVICE_PRETTY_NAME, B_STRING_TYPE, {.string = "OHCI PCI"}},
{} {}
}; };
src/add-ons/kernel/busses/usb/uhci.cpp
+3 -3
View File
@@ -107,9 +107,9 @@ register_child_devices(void* cookie)
device_attr attrs[] = { device_attr attrs[] = {
// properties of this controller for the usb bus manager // properties of this controller for the usb bus manager
{ B_DEVICE_PRETTY_NAME, B_STRING_TYPE, { B_DEVICE_PRETTY_NAME, B_STRING_TYPE,
{ string: prettyName }}, { .string = prettyName }},
{ B_DEVICE_FIXED_CHILD, B_STRING_TYPE, { B_DEVICE_FIXED_CHILD, B_STRING_TYPE,
{ string: USB_FOR_CONTROLLER_MODULE_NAME }}, { .string = USB_FOR_CONTROLLER_MODULE_NAME }},
// private data to identify the device // private data to identify the device
{ NULL } { NULL }
@@ -164,7 +164,7 @@ register_device(device_node* parent)
{ {
CALLED(); CALLED();
device_attr attrs[] = { device_attr attrs[] = {
{B_DEVICE_PRETTY_NAME, B_STRING_TYPE, {string: "UHCI PCI"}}, {B_DEVICE_PRETTY_NAME, B_STRING_TYPE, {.string = "UHCI PCI"}},
{} {}
}; };
src/add-ons/kernel/busses/usb/xhci.cpp
+3 -3
View File
@@ -113,9 +113,9 @@ register_child_devices(void* cookie)
device_attr attrs[] = { device_attr attrs[] = {
// properties of this controller for the usb bus manager // properties of this controller for the usb bus manager
{ B_DEVICE_PRETTY_NAME, B_STRING_TYPE, { B_DEVICE_PRETTY_NAME, B_STRING_TYPE,
{ string: prettyName }}, { .string = prettyName }},
{ B_DEVICE_FIXED_CHILD, B_STRING_TYPE, { B_DEVICE_FIXED_CHILD, B_STRING_TYPE,
{ string: USB_FOR_CONTROLLER_MODULE_NAME }}, { .string = USB_FOR_CONTROLLER_MODULE_NAME }},
// private data to identify the device // private data to identify the device
{ NULL } { NULL }
@@ -170,7 +170,7 @@ register_device(device_node* parent)
{ {
CALLED(); CALLED();
device_attr attrs[] = { device_attr attrs[] = {
{B_DEVICE_PRETTY_NAME, B_STRING_TYPE, {string: "XHCI PCI"}}, {B_DEVICE_PRETTY_NAME, B_STRING_TYPE, {.string = "XHCI PCI"}},
{} {}
}; };
src/add-ons/kernel/busses/virtio/virtio_mmio/virtio_mmio.cpp
+6 -7
View File
@@ -229,13 +229,12 @@ virtio_device_register_device(device_node* parent)
TRACE(" vendorId: 0x%08" B_PRIx32 "\n", mappedRegs->vendorId); TRACE(" vendorId: 0x%08" B_PRIx32 "\n", mappedRegs->vendorId);
device_attr attrs[] = { device_attr attrs[] = {
{ B_DEVICE_PRETTY_NAME, B_STRING_TYPE, {string: "Virtio MMIO"} }, { B_DEVICE_PRETTY_NAME, B_STRING_TYPE, {.string = "Virtio MMIO"} },
{ B_DEVICE_BUS, B_STRING_TYPE, {string: "virtio"} }, { B_DEVICE_BUS, B_STRING_TYPE, {.string = "virtio"} },
{ "virtio/version", B_UINT32_TYPE, {ui32: mappedRegs->version} }, { "virtio/version", B_UINT32_TYPE, {.ui32 = mappedRegs->version} },
{ "virtio/device_id", B_UINT32_TYPE, {ui32: mappedRegs->deviceId} }, { "virtio/device_id", B_UINT32_TYPE, {.ui32 = mappedRegs->deviceId} },
{ "virtio/type", B_UINT16_TYPE, { "virtio/type", B_UINT16_TYPE, {.ui16 = (uint16)mappedRegs->deviceId} },
{ui16: (uint16)mappedRegs->deviceId} }, { "virtio/vendor_id", B_UINT32_TYPE, {.ui32 = mappedRegs->vendorId} },
{ "virtio/vendor_id", B_UINT32_TYPE, {ui32: mappedRegs->vendorId} },
{ NULL } { NULL }
}; };
src/add-ons/kernel/busses/virtio/virtio_pci/virtio_pci.cpp
+5 -5
View File
@@ -554,15 +554,15 @@ register_child_devices(void* cookie)
device_attr attrs[] = { device_attr attrs[] = {
// properties of this controller for virtio bus manager // properties of this controller for virtio bus manager
{ B_DEVICE_PRETTY_NAME, B_STRING_TYPE, { B_DEVICE_PRETTY_NAME, B_STRING_TYPE,
{ string: prettyName }}, { .string = prettyName }},
{ B_DEVICE_FIXED_CHILD, B_STRING_TYPE, { B_DEVICE_FIXED_CHILD, B_STRING_TYPE,
{ string: VIRTIO_FOR_CONTROLLER_MODULE_NAME }}, { .string = VIRTIO_FOR_CONTROLLER_MODULE_NAME }},
// private data to identify the device // private data to identify the device
{ VIRTIO_DEVICE_TYPE_ITEM, B_UINT16_TYPE, { VIRTIO_DEVICE_TYPE_ITEM, B_UINT16_TYPE,
{ ui16: pciSubDeviceId }}, { .ui16 = pciSubDeviceId }},
{ VIRTIO_VRING_ALIGNMENT_ITEM, B_UINT16_TYPE, { VIRTIO_VRING_ALIGNMENT_ITEM, B_UINT16_TYPE,
{ ui16: VIRTIO_PCI_VRING_ALIGN }}, { .ui16 = VIRTIO_PCI_VRING_ALIGN }},
{ NULL } { NULL }
}; };
@@ -584,7 +584,7 @@ static status_t
register_device(device_node* parent) register_device(device_node* parent)
{ {
device_attr attrs[] = { device_attr attrs[] = {
{B_DEVICE_PRETTY_NAME, B_STRING_TYPE, {string: "Virtio PCI"}}, {B_DEVICE_PRETTY_NAME, B_STRING_TYPE, {.string = "Virtio PCI"}},
{} {}
}; };
src/add-ons/kernel/drivers/bus/scsi/scsi_raw.c
+4 -4
View File
@@ -211,18 +211,18 @@ raw_device_added(device_node_handle node)
// ready to register // ready to register
{ {
device_attr attrs[] = { device_attr attrs[] = {
{ B_DRIVER_MODULE, B_STRING_TYPE, { string: SCSI_RAW_MODULE_NAME }}, { B_DRIVER_MODULE, B_STRING_TYPE, { .string = SCSI_RAW_MODULE_NAME }},
// default connection is used by peripheral drivers, and as we don't // default connection is used by peripheral drivers, and as we don't
// want to kick them out, we use concurrent "raw" connection // want to kick them out, we use concurrent "raw" connection
// (btw: this shows nicely that something goes wrong: one device // (btw: this shows nicely that something goes wrong: one device
// and two drivers means begging for trouble) // and two drivers means begging for trouble)
{ PNP_DRIVER_CONNECTION, B_STRING_TYPE, { string: "raw" }}, { PNP_DRIVER_CONNECTION, B_STRING_TYPE, { .string = "raw" }},
// we want devfs on top of us (who wouldn't?) // we want devfs on top of us (who wouldn't?)
{ B_DRIVER_FIXED_CHILD, B_STRING_TYPE, { string: PNP_DEVFS_MODULE_NAME }}, { B_DRIVER_FIXED_CHILD, B_STRING_TYPE, { .string = PNP_DEVFS_MODULE_NAME }},
// tell which name we want to have in devfs // tell which name we want to have in devfs
{ PNP_DEVFS_FILENAME, B_STRING_TYPE, { string: name }}, { PNP_DEVFS_FILENAME, B_STRING_TYPE, { .string = name }},
{ NULL } { NULL }
}; };
src/add-ons/kernel/drivers/disk/mmc/mmc_disk.cpp
+1 -1
View File
@@ -114,7 +114,7 @@ mmc_disk_register_device(device_node* node)
CALLED(); CALLED();
device_attr attrs[] = { device_attr attrs[] = {
{ B_DEVICE_PRETTY_NAME, B_STRING_TYPE, { string: "SD Card" }}, { B_DEVICE_PRETTY_NAME, B_STRING_TYPE, { .string = "SD Card" }},
{ NULL } { NULL }
}; };
src/add-ons/kernel/drivers/disk/nvme/nvme_disk.cpp
+1 -1
View File
@@ -1045,7 +1045,7 @@ nvme_disk_register_device(device_node* parent)
CALLED(); CALLED();
device_attr attrs[] = { device_attr attrs[] = {
{ B_DEVICE_PRETTY_NAME, B_STRING_TYPE, { string: "NVMe Disk" } }, { B_DEVICE_PRETTY_NAME, B_STRING_TYPE, { .string = "NVMe Disk" } },
{ NULL } { NULL }
}; };
src/add-ons/kernel/drivers/disk/scsi/scsi_cd/scsi_cd.cpp
+3 -3
View File
@@ -1098,9 +1098,9 @@ cd_register_device(device_node* node)
// ready to register // ready to register
device_attr attrs[] = { device_attr attrs[] = {
{B_DEVICE_PRETTY_NAME, B_STRING_TYPE, {string: "SCSI CD-ROM Drive"}}, {B_DEVICE_PRETTY_NAME, B_STRING_TYPE, {.string = "SCSI CD-ROM Drive"}},
{"removable", B_UINT8_TYPE, {ui8: deviceInquiry->removable_medium}}, {"removable", B_UINT8_TYPE, {.ui8 = deviceInquiry->removable_medium}},
{B_DMA_MAX_TRANSFER_BLOCKS, B_UINT32_TYPE, {ui32: maxBlocks}}, {B_DMA_MAX_TRANSFER_BLOCKS, B_UINT32_TYPE, {.ui32 = maxBlocks}},
{ NULL } { NULL }
}; };
src/add-ons/kernel/drivers/disk/scsi/scsi_disk/scsi_disk.cpp
+3 -3
View File
@@ -583,11 +583,11 @@ das_register_device(device_node *node)
// ready to register // ready to register
device_attr attrs[] = { device_attr attrs[] = {
{ B_DEVICE_PRETTY_NAME, B_STRING_TYPE, { string: "SCSI Disk" }}, { B_DEVICE_PRETTY_NAME, B_STRING_TYPE, { .string = "SCSI Disk" }},
// tell block_io whether the device is removable // tell block_io whether the device is removable
{"removable", B_UINT8_TYPE, {ui8: deviceInquiry->removable_medium}}, {"removable", B_UINT8_TYPE, {.ui8 = deviceInquiry->removable_medium}},
// impose own max block restriction // impose own max block restriction
{B_DMA_MAX_TRANSFER_BLOCKS, B_UINT32_TYPE, {ui32: maxBlocks}}, {B_DMA_MAX_TRANSFER_BLOCKS, B_UINT32_TYPE, {.ui32 = maxBlocks}},
{ NULL } { NULL }
}; };
src/add-ons/kernel/drivers/disk/virtual/ram_disk/ram_disk.cpp
+5 -5
View File
@@ -196,10 +196,10 @@ struct ControlDevice : Device {
device_attr attrs[] = { device_attr attrs[] = {
{B_DEVICE_PRETTY_NAME, B_STRING_TYPE, {B_DEVICE_PRETTY_NAME, B_STRING_TYPE,
{string: "RAM Disk Raw Device"}}, {.string = "RAM Disk Raw Device"}},
{kDeviceSizeItem, B_UINT64_TYPE, {ui64: deviceSize}}, {kDeviceSizeItem, B_UINT64_TYPE, {.ui64 = deviceSize}},
{kDeviceIDItem, B_UINT32_TYPE, {ui32: (uint32)id}}, {kDeviceIDItem, B_UINT32_TYPE, {.ui32 = (uint32)id}},
{kFilePathItem, B_STRING_TYPE, {string: filePath}}, {kFilePathItem, B_STRING_TYPE, {.string = filePath}},
{NULL} {NULL}
}; };
@@ -1140,7 +1140,7 @@ ram_disk_driver_register_device(device_node* parent)
{ {
device_attr attrs[] = { device_attr attrs[] = {
{B_DEVICE_PRETTY_NAME, B_STRING_TYPE, {B_DEVICE_PRETTY_NAME, B_STRING_TYPE,
{string: "RAM Disk Control Device"}}, {.string = "RAM Disk Control Device"}},
{NULL} {NULL}
}; };
src/add-ons/kernel/drivers/disk/virtual/virtio_block/virtio_block.cpp
+1 -1
View File
@@ -561,7 +561,7 @@ virtio_block_register_device(device_node *node)
CALLED(); CALLED();
device_attr attrs[] = { device_attr attrs[] = {
{ B_DEVICE_PRETTY_NAME, B_STRING_TYPE, {string: "Virtio Block"} }, { B_DEVICE_PRETTY_NAME, B_STRING_TYPE, {.string = "Virtio Block"} },
{ NULL } { NULL }
}; };
src/add-ons/kernel/drivers/display/display_adapter.cpp
+4 -4
View File
@@ -226,8 +226,8 @@ register_displays(const char *parentName, device_node *node)
if (i == pkgData->package.count) continue; if (i == pkgData->package.count) continue;
device_attr attrs[] = { device_attr attrs[] = {
{ B_DEVICE_PRETTY_NAME, B_STRING_TYPE, { string: name }}, { B_DEVICE_PRETTY_NAME, B_STRING_TYPE, { .string = name }},
{ B_DEVICE_FLAGS, B_UINT32_TYPE, { ui32: B_KEEP_DRIVER_LOADED }}, { B_DEVICE_FLAGS, B_UINT32_TYPE, { .ui32 = B_KEEP_DRIVER_LOADED }},
{ NULL } { NULL }
}; };
@@ -252,9 +252,9 @@ static status_t
displayadapter_register_device(device_node *node) displayadapter_register_device(device_node *node)
{ {
device_attr attrs[] = { device_attr attrs[] = {
{ B_DEVICE_PRETTY_NAME, B_STRING_TYPE, { string: "Display Adapter" }}, { B_DEVICE_PRETTY_NAME, B_STRING_TYPE, { .string = "Display Adapter" }},
{ B_DEVICE_FLAGS, B_UINT32_TYPE, { { B_DEVICE_FLAGS, B_UINT32_TYPE, {
ui32: B_KEEP_DRIVER_LOADED | B_FIND_MULTIPLE_CHILDREN }}, .ui32 = B_KEEP_DRIVER_LOADED | B_FIND_MULTIPLE_CHILDREN }},
{ NULL } { NULL }
}; };
src/add-ons/kernel/drivers/input/i2c_hid/Driver.cpp
+2 -2
View File
@@ -328,8 +328,8 @@ i2c_hid_register_device(device_node *node)
uint32 descriptorAddress = object->integer.integer; uint32 descriptorAddress = object->integer.integer;
free(object); free(object);
device_attr attrs[] = { device_attr attrs[] = {
{ B_DEVICE_PRETTY_NAME, B_STRING_TYPE, { string: "I2C HID Device" }}, { B_DEVICE_PRETTY_NAME, B_STRING_TYPE, { .string = "I2C HID Device" }},
{ "descriptorAddress", B_UINT32_TYPE, { ui32: descriptorAddress }}, { "descriptorAddress", B_UINT32_TYPE, { .ui32 = descriptorAddress }},
{ NULL } { NULL }
}; };
src/add-ons/kernel/drivers/input/virtio_input/virtio_input.cpp
+1 -1
View File
@@ -441,7 +441,7 @@ virtio_input_register_device(device_node *node)
CALLED(); CALLED();
device_attr attrs[] = { device_attr attrs[] = {
{ B_DEVICE_PRETTY_NAME, B_STRING_TYPE, { string: "VirtIO input" }}, { B_DEVICE_PRETTY_NAME, B_STRING_TYPE, { .string = "VirtIO input" }},
{ NULL } { NULL }
}; };
src/add-ons/kernel/drivers/network/ether/usb_ecm/Driver.cpp
+1 -1
View File
@@ -190,7 +190,7 @@ usb_ecm_register_device(device_node *node)
CALLED(); CALLED();
device_attr attrs[] = { device_attr attrs[] = {
{ B_DEVICE_PRETTY_NAME, B_STRING_TYPE, {string: "USB ECM"} }, { B_DEVICE_PRETTY_NAME, B_STRING_TYPE, {.string = "USB ECM"} },
{ NULL } { NULL }
}; };
src/add-ons/kernel/drivers/network/ether/virtio/virtio_net.cpp
+1 -1
View File
@@ -896,7 +896,7 @@ virtio_net_register_device(device_node* node)
CALLED(); CALLED();
device_attr attrs[] = { device_attr attrs[] = {
{ B_DEVICE_PRETTY_NAME, B_STRING_TYPE, {string: "Virtio Network"} }, { B_DEVICE_PRETTY_NAME, B_STRING_TYPE, {.string = "Virtio Network"} },
{ NULL } { NULL }
}; };
src/add-ons/kernel/drivers/power/acpi_ac/acpi_ac.cpp
+1 -1
View File
@@ -162,7 +162,7 @@ static status_t
acpi_ac_register_device(device_node *node) acpi_ac_register_device(device_node *node)
{ {
device_attr attrs[] = { device_attr attrs[] = {
{ B_DEVICE_PRETTY_NAME, B_STRING_TYPE, { string: "ACPI AC" }}, { B_DEVICE_PRETTY_NAME, B_STRING_TYPE, { .string = "ACPI AC" }},
{ NULL } { NULL }
}; };
src/add-ons/kernel/drivers/power/acpi_battery/acpi_battery.cpp
+1 -1
View File
@@ -523,7 +523,7 @@ static status_t
acpi_battery_register_device(device_node *node) acpi_battery_register_device(device_node *node)
{ {
device_attr attrs[] = { device_attr attrs[] = {
{ B_DEVICE_PRETTY_NAME, B_STRING_TYPE, { string: "ACPI Battery" }}, { B_DEVICE_PRETTY_NAME, B_STRING_TYPE, { .string = "ACPI Battery" }},
{ NULL } { NULL }
}; };
src/add-ons/kernel/drivers/power/acpi_button/acpi_button.cpp
+1 -1
View File
@@ -288,7 +288,7 @@ static status_t
acpi_button_register_device(device_node *node) acpi_button_register_device(device_node *node)
{ {
device_attr attrs[] = { device_attr attrs[] = {
{ B_DEVICE_PRETTY_NAME, B_STRING_TYPE, { string: "ACPI Button" }}, { B_DEVICE_PRETTY_NAME, B_STRING_TYPE, { .string = "ACPI Button" }},
{ NULL } { NULL }
}; };
src/add-ons/kernel/drivers/power/acpi_lid/acpi_lid.cpp
+1 -1
View File
@@ -229,7 +229,7 @@ static status_t
acpi_lid_register_device(device_node *node) acpi_lid_register_device(device_node *node)
{ {
device_attr attrs[] = { device_attr attrs[] = {
{ B_DEVICE_PRETTY_NAME, B_STRING_TYPE, { string: "ACPI Lid" }}, { B_DEVICE_PRETTY_NAME, B_STRING_TYPE, { .string = "ACPI Lid" }},
{ NULL } { NULL }
}; };
src/add-ons/kernel/drivers/power/acpi_thermal/acpi_thermal.c
+1 -1
View File
@@ -213,7 +213,7 @@ static status_t
acpi_thermal_register_device(device_node *node) acpi_thermal_register_device(device_node *node)
{ {
device_attr attrs[] = { device_attr attrs[] = {
{ B_DEVICE_PRETTY_NAME, B_STRING_TYPE, { string: "ACPI Thermal" }}, { B_DEVICE_PRETTY_NAME, B_STRING_TYPE, { .string = "ACPI Thermal" }},
{ NULL } { NULL }
}; };
src/add-ons/kernel/drivers/power/pch_thermal/pch_thermal.cpp
+1 -1
View File
@@ -221,7 +221,7 @@ static status_t
pch_thermal_register_device(device_node *node) pch_thermal_register_device(device_node *node)
{ {
device_attr attrs[] = { device_attr attrs[] = {
{ B_DEVICE_PRETTY_NAME, B_STRING_TYPE, { string: "PCH Thermal" }}, { B_DEVICE_PRETTY_NAME, B_STRING_TYPE, { .string = "PCH Thermal" }},
{ NULL } { NULL }
}; };
src/add-ons/kernel/drivers/power/x86_cpuidle/acpi_cpuidle.cpp
+1 -1
View File
@@ -533,7 +533,7 @@ static status_t
acpi_cpuidle_register_device(device_node *node) acpi_cpuidle_register_device(device_node *node)
{ {
device_attr attrs[] = { device_attr attrs[] = {
{ B_DEVICE_PRETTY_NAME, B_STRING_TYPE, { string: "ACPI CPU IDLE" }}, { B_DEVICE_PRETTY_NAME, B_STRING_TYPE, { .string = "ACPI CPU IDLE" }},
{ NULL } { NULL }
}; };
src/add-ons/kernel/drivers/sensor/acpi_als/acpi_als.cpp
+1 -1
View File
@@ -221,7 +221,7 @@ static status_t
acpi_als_register_device(device_node *node) acpi_als_register_device(device_node *node)
{ {
device_attr attrs[] = { device_attr attrs[] = {
{ B_DEVICE_PRETTY_NAME, B_STRING_TYPE, { string: "ACPI ALS" }}, { B_DEVICE_PRETTY_NAME, B_STRING_TYPE, { .string = "ACPI ALS" }},
{ NULL } { NULL }
}; };
src/add-ons/kernel/drivers/wmi/WMIACPI.cpp
+5 -5
View File
@@ -108,15 +108,15 @@ WMIACPI::Scan()
_GuidToGuidString(guid, guidString); _GuidToGuidString(guid, guidString);
device_attr attrs[] = { device_attr attrs[] = {
// connection // connection
{ WMI_GUID_STRING_ITEM, B_STRING_TYPE, { string: guidString }}, { WMI_GUID_STRING_ITEM, B_STRING_TYPE, { .string = guidString }},
{ WMI_BUS_COOKIE, B_UINT32_TYPE, { ui32: index }}, { WMI_BUS_COOKIE, B_UINT32_TYPE, { .ui32 = index }},
// description of peripheral drivers // description of peripheral drivers
{ B_DEVICE_BUS, B_STRING_TYPE, { string: "wmi" }}, { B_DEVICE_BUS, B_STRING_TYPE, { .string = "wmi" }},
{ B_DEVICE_FLAGS, B_UINT32_TYPE, { B_DEVICE_FLAGS, B_UINT32_TYPE,
{ ui32: B_FIND_MULTIPLE_CHILDREN }}, { .ui32 = B_FIND_MULTIPLE_CHILDREN }},
{ NULL } { NULL }
}; };
@@ -412,7 +412,7 @@ wmi_acpi_register_device(device_node *node)
{ {
CALLED(); CALLED();
device_attr attrs[] = { device_attr attrs[] = {
{ B_DEVICE_PRETTY_NAME, B_STRING_TYPE, { string: "WMI ACPI" }}, { B_DEVICE_PRETTY_NAME, B_STRING_TYPE, { .string = "WMI ACPI" }},
{ NULL } { NULL }
}; };
src/add-ons/kernel/drivers/wmi/WMIAsus.cpp
+1 -1
View File
@@ -261,7 +261,7 @@ wmi_asus_register_device(device_node *node)
{ {
CALLED(); CALLED();
device_attr attrs[] = { device_attr attrs[] = {
{ B_DEVICE_PRETTY_NAME, B_STRING_TYPE, { string: "WMI ASUS" }}, { B_DEVICE_PRETTY_NAME, B_STRING_TYPE, { .string = "WMI ASUS" }},
{ NULL } { NULL }
}; };
src/add-ons/kernel/generic/ata_adapter/ata_adapter.cpp
+16 -16
View File
@@ -496,18 +496,18 @@ ata_adapter_publish_channel(device_node *controller_node,
device_attr attrs[] = { device_attr attrs[] = {
// info about ourself and our consumer // info about ourself and our consumer
{ B_DEVICE_PRETTY_NAME, B_STRING_TYPE, { B_DEVICE_PRETTY_NAME, B_STRING_TYPE,
{ string: prettyName }}, { .string = prettyName }},
{ B_DEVICE_FIXED_CHILD, B_STRING_TYPE, { B_DEVICE_FIXED_CHILD, B_STRING_TYPE,
{ string: ATA_FOR_CONTROLLER_MODULE_NAME }}, { .string = ATA_FOR_CONTROLLER_MODULE_NAME }},
// private data to identify channel // private data to identify channel
{ ATA_ADAPTER_COMMAND_BLOCK_BASE, B_UINT16_TYPE, { ATA_ADAPTER_COMMAND_BLOCK_BASE, B_UINT16_TYPE,
{ ui16: command_block_base }}, { .ui16 = command_block_base }},
{ ATA_ADAPTER_CONTROL_BLOCK_BASE, B_UINT16_TYPE, { ATA_ADAPTER_CONTROL_BLOCK_BASE, B_UINT16_TYPE,
{ ui16: control_block_base }}, { .ui16 = control_block_base }},
{ ATA_CONTROLLER_CAN_DMA_ITEM, B_UINT8_TYPE, { ui8: can_dma }}, { ATA_CONTROLLER_CAN_DMA_ITEM, B_UINT8_TYPE, { .ui8 = can_dma }},
{ ATA_ADAPTER_INTNUM, B_UINT8_TYPE, { ui8: intnum }}, { ATA_ADAPTER_INTNUM, B_UINT8_TYPE, { .ui8 = intnum }},
{ ATA_ADAPTER_CHANNEL_INDEX, B_UINT8_TYPE, { ui8: channel_index }}, { ATA_ADAPTER_CHANNEL_INDEX, B_UINT8_TYPE, { .ui8 = channel_index }},
{ NULL } { NULL }
}; };
@@ -714,28 +714,28 @@ ata_adapter_publish_controller(device_node *parent, uint16 bus_master_base,
// there are always max. 2 devices // there are always max. 2 devices
// (unless this is a Compact Flash Card with a built-in IDE controller, // (unless this is a Compact Flash Card with a built-in IDE controller,
// which has exactly 1 device) // which has exactly 1 device)
{ ATA_CONTROLLER_MAX_DEVICES_ITEM, B_UINT8_TYPE, { ui8: 2 }}, { ATA_CONTROLLER_MAX_DEVICES_ITEM, B_UINT8_TYPE, { .ui8 = 2 }},
// of course we can DMA // of course we can DMA
{ ATA_CONTROLLER_CAN_DMA_ITEM, B_UINT8_TYPE, { ui8: can_dma }}, { ATA_CONTROLLER_CAN_DMA_ITEM, B_UINT8_TYPE, { .ui8 = can_dma }},
// choose any name here // choose any name here
{ ATA_CONTROLLER_CONTROLLER_NAME_ITEM, B_STRING_TYPE, { ATA_CONTROLLER_CONTROLLER_NAME_ITEM, B_STRING_TYPE,
{ string: controller_name }}, { .string = controller_name }},
// DMA properties // DMA properties
// data must be word-aligned; // data must be word-aligned;
// warning: some controllers are more picky! // warning: some controllers are more picky!
{ B_DMA_ALIGNMENT, B_UINT32_TYPE, { ui32: dma_alignment /*1*/}}, { B_DMA_ALIGNMENT, B_UINT32_TYPE, { .ui32 = dma_alignment /*1*/}},
// one S/G block must not cross 64K boundary // one S/G block must not cross 64K boundary
{ B_DMA_BOUNDARY, B_UINT32_TYPE, { ui32: dma_boundary/*0xffff*/ }}, { B_DMA_BOUNDARY, B_UINT32_TYPE, { .ui32 = dma_boundary/*0xffff*/ }},
// max size of S/G block is 16 bits with zero being 64K // max size of S/G block is 16 bits with zero being 64K
{ B_DMA_MAX_SEGMENT_BLOCKS, B_UINT32_TYPE, { B_DMA_MAX_SEGMENT_BLOCKS, B_UINT32_TYPE,
{ ui32: max_sg_block_size/*0x10000*/ }}, { .ui32 = max_sg_block_size/*0x10000*/ }},
{ B_DMA_MAX_SEGMENT_COUNT, B_UINT32_TYPE, { B_DMA_MAX_SEGMENT_COUNT, B_UINT32_TYPE,
{ ui32: ATA_ADAPTER_MAX_SG_COUNT }}, { .ui32 = ATA_ADAPTER_MAX_SG_COUNT }},
{ B_DMA_HIGH_ADDRESS, B_UINT64_TYPE, { ui64: 0x100000000LL }}, { B_DMA_HIGH_ADDRESS, B_UINT64_TYPE, { .ui64 = 0x100000000LL }},
// private data to find controller // private data to find controller
{ ATA_ADAPTER_BUS_MASTER_BASE, B_UINT16_TYPE, { ui16: bus_master_base }}, { ATA_ADAPTER_BUS_MASTER_BASE, B_UINT16_TYPE, { .ui16 = bus_master_base }},
{ NULL } { NULL }
}; };
src/add-ons/kernel/interrupt_controllers/openpic/openpic.cpp
+3 -3
View File
@@ -315,10 +315,10 @@ openpic_register_device(device_node *parent)
device_node *newNode; device_node *newNode;
device_attr attrs[] = { device_attr attrs[] = {
// info about ourself // info about ourself
{ B_DEVICE_TYPE, B_UINT16_TYPE, { ui16: PCI_base_peripheral }}, { B_DEVICE_TYPE, B_UINT16_TYPE, { .ui16 = PCI_base_peripheral }},
{ B_DEVICE_SUB_TYPE, B_UINT16_TYPE, { ui16: PCI_pic }}, { B_DEVICE_SUB_TYPE, B_UINT16_TYPE, { .ui16 = PCI_pic }},
// TODO How do we identify ourselves as OpenPIC? // TODO How do we identify ourselves as OpenPIC?
{ B_DEVICE_INTERFACE, B_UINT16_TYPE, { ui16: PCI_pic_8259 }}, { B_DEVICE_INTERFACE, B_UINT16_TYPE, { .ui16 = PCI_pic_8259 }},
{} {}
}; };
io_resource resources[] = { io_resource resources[] = {
src/system/kernel/device_manager/device_manager.cpp
+6 -6
View File
@@ -2381,10 +2381,10 @@ static void
init_node_tree(void) init_node_tree(void)
{ {
device_attr attrs[] = { device_attr attrs[] = {
{B_DEVICE_PRETTY_NAME, B_STRING_TYPE, {string: "Devices Root"}}, {B_DEVICE_PRETTY_NAME, B_STRING_TYPE, {.string = "Devices Root"}},
{B_DEVICE_BUS, B_STRING_TYPE, {string: "root"}}, {B_DEVICE_BUS, B_STRING_TYPE, {.string = "root"}},
{B_DEVICE_FLAGS, B_UINT32_TYPE, {B_DEVICE_FLAGS, B_UINT32_TYPE,
{ui32: B_FIND_MULTIPLE_CHILDREN | B_KEEP_DRIVER_LOADED }}, {.ui32 = B_FIND_MULTIPLE_CHILDREN | B_KEEP_DRIVER_LOADED }},
{NULL} {NULL}
}; };
@@ -2395,9 +2395,9 @@ init_node_tree(void)
} }
device_attr genericAttrs[] = { device_attr genericAttrs[] = {
{B_DEVICE_PRETTY_NAME, B_STRING_TYPE, {string: "Generic"}}, {B_DEVICE_PRETTY_NAME, B_STRING_TYPE, {.string = "Generic"}},
{B_DEVICE_BUS, B_STRING_TYPE, {string: "generic"}}, {B_DEVICE_BUS, B_STRING_TYPE, {.string = "generic"}},
{B_DEVICE_FLAGS, B_UINT32_TYPE, {ui32: B_FIND_MULTIPLE_CHILDREN {B_DEVICE_FLAGS, B_UINT32_TYPE, {.ui32 = B_FIND_MULTIPLE_CHILDREN
| B_KEEP_DRIVER_LOADED | B_FIND_CHILD_ON_DEMAND}}, | B_KEEP_DRIVER_LOADED | B_FIND_CHILD_ON_DEMAND}},
{NULL} {NULL}
}; };