* Copyright 2006-2012, Haiku, Inc. All Rights Reserved.
* Distributed under the terms of the MIT License.
*
* Authors:
* Jérôme Duval
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <drivers/device_manager.h>
#include <drivers/module.h>
#include <drivers/PCI.h>
#include <drivers/bus/PCI.h>
#include <drivers/bus/SCSI.h>
#include <drivers/bus/USB.h>
extern "C" {
#include "dm_wrapper.h"
#include "pcihdr.h"
#include "pci-utils.h"
#include "usb-utils.h"
}
extern const char *__progname;
#define DUMP_MODE 0
#define USER_MODE 1
int gMode = USER_MODE;
#define BUS_ISA 1
#define BUS_PCI 2
#define BUS_SCSI 3
#define BUS_USB 4
static const char *
get_scsi_device_type(uint8 type)
{
switch (type) {
case 0x0: return "Direct Access";
case 0x1: return "Sequential Access";
case 0x2: return "Printer";
case 0x3: return "Processor";
case 0x4: return "WORM";
case 0x5: return "CDROM";
case 0x6: return "Scanner";
case 0x7: return "Optical memory";
case 0x8: return "Medium changer";
case 0x9: return "Communication";
case 0xc: return "Storage array controller";
case 0xd: return "Enclosure services";
case 0xe: return "Simplified Direct Access";
default: return "";
}
}
static void
usage()
{
fprintf(stderr, "usage: %s [-d]\n", __progname);
fprintf(stderr, "Displays devices in a user friendly way\n");
fprintf(stderr, "-d : dumps the tree\n");
exit(0);
}
static void
put_level(int32 level)
{
while (level-- > 0)
printf(" ");
}
static void
dump_attribute(struct device_attr_info *attr, int32 level)
{
if (attr == NULL)
return;
put_level(level);
printf("\"%s\" : ", attr->name);
switch (attr->type) {
case B_STRING_TYPE:
printf("string : \"%s\"", attr->value.string);
break;
case B_UINT8_TYPE:
printf("uint8 : %" B_PRIu8 " (%#" B_PRIx8 ")", attr->value.ui8,
attr->value.ui8);
break;
case B_UINT16_TYPE:
printf("uint16 : %" B_PRIu16 " (%#" B_PRIx16 ")", attr->value.ui16,
attr->value.ui16);
break;
case B_UINT32_TYPE:
printf("uint32 : %" B_PRIu32 " (%#" B_PRIx32 ")", attr->value.ui32,
attr->value.ui32);
break;
case B_UINT64_TYPE:
printf("uint64 : %" B_PRIu64 " (%#" B_PRIx64 ")", attr->value.ui64,
attr->value.ui64);
break;
default:
printf("raw data");
}
printf("\n");
}
static void
dump_device(device_node_cookie *node, uint8 level)
{
char data[256];
struct device_attr_info attr;
attr.cookie = 0;
attr.node_cookie = *node;
attr.value.raw.data = data;
attr.value.raw.length = sizeof(data);
put_level(level);
printf("(%d)\n", level);
while (dm_get_next_attr(&attr) == B_OK) {
dump_attribute(&attr, level);
}
}
static void
dump_nodes(device_node_cookie *node, uint8 level)
{
status_t err;
device_node_cookie child = *node;
dump_device(node, level);
if (get_child(&child) != B_OK)
return;
do {
dump_nodes(&child, level + 1);
} while ((err = get_next_child(&child)) == B_OK);
}
static int32
display_device(device_node_cookie *node, uint8 level)
{
uint8 new_level = level;
char data[256];
struct device_attr_info attr;
char device_bus[64];
uint8 scsi_path_id = 255;
int bus = 0;
uint16 vendor_id = 0;
uint16 device_id = 0;
uint8 pci_class_base_id = 0;
uint8 pci_class_sub_id = 0;
uint8 pci_class_api_id = 0;
uint16 pci_subsystem_vendor_id = 0;
uint16 pci_subsystem_id = 0;
uint8 scsi_target_lun = 0;
uint8 scsi_target_id = 0;
uint8 scsi_type = 255;
char scsi_vendor[64];
char scsi_product[64];
uint8 usb_class_base_id = 0;
uint8 usb_class_sub_id = 0;
uint8 usb_class_proto_id = 0;
attr.cookie = 0;
attr.node_cookie = *node;
attr.value.raw.data = data;
attr.value.raw.length = sizeof(data);
while (dm_get_next_attr(&attr) == B_OK) {
if (!strcmp(attr.name, B_DEVICE_BUS)
&& attr.type == B_STRING_TYPE) {
strlcpy(device_bus, attr.value.string, 64);
} else if (!strcmp(attr.name, "scsi/path_id")
&& attr.type == B_UINT8_TYPE) {
scsi_path_id = attr.value.ui8;
} else if (!strcmp(attr.name, B_DEVICE_TYPE)
&& attr.type == B_UINT16_TYPE)
pci_class_base_id = attr.value.ui8;
else if (!strcmp(attr.name, B_DEVICE_SUB_TYPE)
&& attr.type == B_UINT16_TYPE)
pci_class_sub_id = attr.value.ui8;
else if (!strcmp(attr.name, B_DEVICE_INTERFACE)
&& attr.type == B_UINT16_TYPE)
pci_class_api_id = attr.value.ui8;
else if (!strcmp(attr.name, B_DEVICE_VENDOR_ID)
&& attr.type == B_UINT16_TYPE)
vendor_id = attr.value.ui16;
else if (!strcmp(attr.name, B_DEVICE_ID)
&& attr.type == B_UINT16_TYPE)
device_id = attr.value.ui16;
else if (!strcmp(attr.name, SCSI_DEVICE_TARGET_LUN_ITEM)
&& attr.type == B_UINT8_TYPE)
scsi_target_lun = attr.value.ui8;
else if (!strcmp(attr.name, SCSI_DEVICE_TARGET_ID_ITEM)
&& attr.type == B_UINT8_TYPE)
scsi_target_id = attr.value.ui8;
else if (!strcmp(attr.name, SCSI_DEVICE_TYPE_ITEM)
&& attr.type == B_UINT8_TYPE)
scsi_type = attr.value.ui8;
else if (!strcmp(attr.name, SCSI_DEVICE_VENDOR_ITEM)
&& attr.type == B_STRING_TYPE)
strlcpy(scsi_vendor, attr.value.string, 64);
else if (!strcmp(attr.name, SCSI_DEVICE_PRODUCT_ITEM)
&& attr.type == B_STRING_TYPE)
strlcpy(scsi_product, attr.value.string, 64);
else if (!strcmp(attr.name, USB_DEVICE_CLASS)
&& attr.type == B_UINT8_TYPE)
usb_class_base_id = attr.value.ui8;
else if (!strcmp(attr.name, USB_DEVICE_SUBCLASS)
&& attr.type == B_UINT8_TYPE)
usb_class_sub_id = attr.value.ui8;
else if (!strcmp(attr.name, USB_DEVICE_PROTOCOL)
&& attr.type == B_UINT8_TYPE)
usb_class_proto_id = attr.value.ui8;
if (!strcmp(device_bus, "isa"))
bus = BUS_ISA;
else if (!strcmp(device_bus, "pci"))
bus = BUS_PCI;
else if (!strcmp(device_bus, "usb"))
bus = BUS_USB;
else if (scsi_path_id < 255)
bus = BUS_SCSI;
&& attr.type == B_UINT16_TYPE)
pci_subsystem_vendor_id = attr.value.ui16;
else if (!strcmp(attr.name, PCI_DEVICE_SUBSYSTEM_ID_ITEM)
&& attr.type == B_UINT16_TYPE)
pci_subsystem_id = attr.value.ui16;*/
attr.value.raw.data = data;
attr.value.raw.length = sizeof(data);
}
switch (bus) {
case BUS_ISA:
new_level = level + 1;
break;
case BUS_PCI:
printf("\n");
{
char classInfo[128];
get_class_info(pci_class_base_id, pci_class_sub_id,
pci_class_api_id, classInfo, 64);
put_level(level);
printf("device %s [%x|%x|%x]\n", classInfo, pci_class_base_id,
pci_class_sub_id, pci_class_api_id);
}
put_level(level);
printf(" ");
const char *venShort;
const char *venFull;
const char *devShort;
const char *devFull;
get_vendor_info(vendor_id, &venShort, &venFull);
if (!venShort && !venFull) {
printf("vendor %04x: Unknown\n", vendor_id);
} else if (venShort && venFull) {
printf("vendor %04x: %s - %s\n", vendor_id,
venShort, venFull);
} else {
printf("vendor %04x: %s\n", vendor_id,
venShort ? venShort : venFull);
}
put_level(level);
printf(" ");
get_device_info(vendor_id, device_id, pci_subsystem_vendor_id, pci_subsystem_id,
&devShort, &devFull);
if (!devShort && !devFull) {
printf("device %04x: Unknown\n", device_id);
} else if (devShort && devFull) {
printf("device %04x: %s (%s)\n", device_id,
devShort, devFull);
} else {
printf("device %04x: %s\n", device_id,
devShort ? devShort : devFull);
}
new_level = level + 1;
break;
case BUS_SCSI:
if (scsi_type == 255)
break;
put_level(level);
printf(" device [%x|%x]\n", scsi_target_id, scsi_target_lun);
put_level(level);
printf(" vendor %15s\tmodel %15s\ttype %s\n", scsi_vendor,
scsi_product, get_scsi_device_type(scsi_type));
new_level = level + 1;
break;
case BUS_USB:
{
printf("\n");
char classInfo[128];
usb_get_class_info(usb_class_base_id, usb_class_sub_id, usb_class_proto_id,
classInfo, sizeof(classInfo));
put_level(level);
printf("device %s [%x|%x|%x]\n", classInfo, usb_class_base_id,
usb_class_sub_id, usb_class_proto_id);
put_level(level);
printf(" ");
const char* vendorName = NULL;
const char* deviceName = NULL;
usb_get_vendor_info(vendor_id, &vendorName);
usb_get_device_info(vendor_id, device_id, &deviceName);
printf("vendor %04x: %s\n", vendor_id, vendorName != NULL ? vendorName : "Unknown");
put_level(level);
printf(" ");
printf("device %04x: %s\n", device_id, deviceName != NULL ? deviceName : "Unknown");
new_level = level + 1;
break;
}
}
return new_level;
}
static void
display_nodes(device_node_cookie *node, uint8 level)
{
status_t err;
device_node_cookie child = *node;
level = display_device(node, level);
if (get_child(&child) != B_OK)
return;
do {
display_nodes(&child, level);
} while ((err = get_next_child(&child)) == B_OK);
}
int
main(int argc, char **argv)
{
status_t error;
device_node_cookie root;
if ((error = init_dm_wrapper()) < 0) {
printf("Error initializing device manager (%s)\n", strerror(error));
return error;
}
if (argc > 2)
usage();
if (argc == 2) {
if (!strcmp(argv[1], "-d")) {
gMode = DUMP_MODE;
} else {
usage();
}
}
if (gMode == DUMP_MODE) {
get_root(&root);
dump_nodes(&root, 0);
} else {
get_root(&root);
display_nodes(&root, 0);
}
uninit_dm_wrapper();
return 0;
}
