hd.h

Go to the documentation of this file.

#ifndef _HD_H
#define _HD_H

 
#ifdef __cplusplus
extern "C" {
#endif
 
 
/* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
 *
 *                      libhd data structures
 *
 * - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
 */

#define HD_VERSION              0       /* will be set during install */
#define HD_MINOR_VERSION        0       /* will be set during install */
#define HD_FULL_VERSION         (HD_VERSION * 1000 + HD_MINOR_VERSION)

#define HD_DEB_SHOW_LOG         (1 <<  0)
#define HD_DEB_PROGRESS         (1 <<  1)
#define HD_DEB_CREATION         (1 <<  2)
#define HD_DEB_DRIVER_INFO      (1 <<  3)
#define HD_DEB_PCI              (1 <<  4)
#define HD_DEB_ISAPNP           (1 <<  5)
#define HD_DEB_CDROM            (1 <<  6)
#define HD_DEB_NET              (1 <<  7)
#define HD_DEB_FLOPPY           (1 <<  8)
#define HD_DEB_MISC             (1 <<  9)
#define HD_DEB_SERIAL           (1 << 10)
#define HD_DEB_MONITOR          (1 << 11)
#define HD_DEB_CPU              (1 << 12)
#define HD_DEB_BIOS             (1 << 13)
#define HD_DEB_MOUSE            (1 << 14)
#define HD_DEB_IDE              (1 << 15)
#define HD_DEB_SCSI             (1 << 16)
#define HD_DEB_USB              (1 << 17)
#define HD_DEB_ADB              (1 << 18)
#define HD_DEB_MODEM            (1 << 19)
#define HD_DEB_PARALLEL         (1 << 20)
#define HD_DEB_ISA              (1 << 21)
#define HD_DEB_BOOT             (1 << 22)
#define HD_DEB_HDDB             (1 << 23)
 
#include <stdio.h>
#include <inttypes.h>
#include <termios.h>
#include <sys/types.h>
 
//typedef struct vm_s vm_t;

#define HARDWARE_DIR            "/var/lib/hardware"

 
#define TAG_PCI         1       
#define TAG_EISA        2       
#define TAG_USB         3       
#define TAG_SPECIAL     4       
#define TAG_PCMCIA      5       
#define TAG_SDIO        6       

#define ID_VALUE(id)            ((id) & 0xffff)

#define ID_TAG(id)              (((id) >> 16) & 0xf)

#define MAKE_ID(tag, id_val)    ((tag << 16) | (id_val))


typedef enum probe_feature {
  pr_memory = 1, pr_pci, pr_isapnp, pr_net, pr_floppy, pr_misc,
  pr_misc_serial, pr_misc_par, pr_misc_floppy, pr_serial, pr_cpu, pr_bios,
  pr_monitor, pr_mouse, pr_scsi, pr_usb, pr_usb_mods, pr_adb, pr_modem,
  pr_modem_usb, pr_parallel, pr_parallel_lp, pr_parallel_zip, pr_isa,
  pr_isa_isdn, pr_isdn, pr_kbd, pr_prom, pr_sbus, pr_int, pr_braille,
  pr_braille_alva, pr_braille_fhp, pr_braille_ht, pr_ignx11, pr_sys,
  pr_bios_vbe, pr_isapnp_old, pr_isapnp_new, pr_isapnp_mod, pr_braille_baum,
  pr_manual, pr_fb, pr_veth, pr_pppoe, pr_scan, pr_pcmcia, pr_fork,
  pr_parallel_imm, pr_s390, pr_cpuemu, pr_sysfs, pr_s390disks, pr_udev,
  pr_block, pr_block_cdrom, pr_block_part, pr_edd, pr_edd_mod, pr_bios_ddc,
  pr_bios_fb, pr_bios_mode, pr_input, pr_block_mods, pr_bios_vesa,
  pr_cpuemu_debug, pr_scsi_noserial, pr_wlan, pr_bios_crc, pr_hal,
  pr_bios_vram, pr_bios_acpi, pr_bios_ddc_ports, pr_modules_pata,
  pr_net_eeprom, pr_x86emu,
  pr_max, pr_lxrc, pr_default, 
  pr_all                
} hd_probe_feature_t;

typedef enum hw_item {
  hw_none = 0, hw_sys, hw_cpu, hw_keyboard, hw_braille, hw_mouse,
  hw_joystick, hw_printer, hw_scanner, hw_chipcard, hw_monitor, hw_tv,
  hw_display, hw_framebuffer, hw_camera, hw_sound, hw_storage_ctrl,
  hw_network_ctrl, hw_isdn, hw_modem, hw_network, hw_disk, hw_partition,
  hw_cdrom, hw_floppy, hw_manual, hw_usb_ctrl, hw_usb, hw_bios, hw_pci,
  hw_isapnp, hw_bridge, hw_hub, hw_scsi, hw_ide, hw_memory, hw_dvb,
  hw_pcmcia, hw_pcmcia_ctrl, hw_ieee1394, hw_ieee1394_ctrl, hw_hotplug,
  hw_hotplug_ctrl, hw_zip, hw_pppoe, hw_wlan, hw_redasd, hw_dsl, hw_block,
  hw_tape, hw_vbe, hw_bluetooth, hw_fingerprint, hw_mmc_ctrl,
  hw_unknown, hw_all                            
} hd_hw_item_t;


typedef enum base_classes {
  // these *must* match standard PCI class numbers
  bc_none, bc_storage, bc_network, bc_display, bc_multimedia,
  bc_memory, bc_bridge, bc_comm, bc_system, bc_input, bc_docking,
  bc_processor, bc_serial, bc_wireless, bc_i2o, bc_other = 0xff,
 
  // add our own classes here (starting at 0x100 as PCI values are 8 bit)
  bc_monitor = 0x100, bc_internal, bc_modem, bc_isdn, bc_ps2, bc_mouse,
  bc_storage_device, bc_network_interface, bc_keyboard, bc_printer,
  bc_hub, bc_braille, bc_scanner, bc_joystick, bc_chipcard, bc_camera,
  bc_framebuffer, bc_dvb, bc_tv, bc_partition, bc_dsl, bc_bluetooth, bc_fingerprint,
  bc_mmc_ctrl
} hd_base_classes_t;

typedef enum sc_monitor {
  sc_mon_other, sc_mon_crt, sc_mon_lcd
} hd_sc_monitor_t;

typedef enum sc_storage {
  sc_sto_scsi, sc_sto_ide, sc_sto_floppy, sc_sto_ipi, sc_sto_raid,
  sc_sto_other = 0x80
} hd_sc_storage_t;

typedef enum sc_display {
  sc_dis_vga, sc_dis_xga, sc_dis_other = 0x80
} hd_sc_display_t;

typedef enum sc_framebuffer {
  sc_fb_vesa = 1
} hd_sc_framebuffer_t;

typedef enum sc_bridge { 
  sc_bridge_host, sc_bridge_isa, sc_bridge_eisa, sc_bridge_mc,
  sc_bridge_pci, sc_bridge_pcmcia, sc_bridge_nubus, sc_bridge_cardbus,
  sc_bridge_other = 0x80
} hd_sc_bridge_t;

typedef enum sc_comm { 
  sc_com_ser, sc_com_par, sc_com_multi, sc_com_modem, sc_com_other = 0x80
} hd_sc_comm_t;

typedef enum sc_system {
  sc_sys_pic, sc_sys_dma, sc_sys_timer, sc_sys_rtc, sc_sys_other = 0x80
} hd_sc_system_t;

typedef enum sc_input {
  sc_inp_keyb, sc_inp_digit, sc_inp_mouse, sc_inp_other = 0x80
} hd_sc_input_t;

typedef enum sc_serial {
  sc_ser_fire, sc_ser_access, sc_ser_ssa, sc_ser_usb, sc_ser_fiber,
  sc_ser_smbus, sc_ser_infiniband, sc_ser_other = 0x80
} hd_sc_serial_t;

typedef enum sc_internal {
  sc_int_none, sc_int_isapnp_if, sc_int_main_mem, sc_int_cpu, sc_int_fpu,
  sc_int_bios, sc_int_prom, sc_int_sys
} hd_sc_internal_t;

typedef enum sc_mouse {
  sc_mou_ps2, sc_mou_ser, sc_mou_bus, sc_mou_usb, sc_mou_sun,
  sc_mou_other = 0x80
} hd_sc_mouse_t;

typedef enum sc_std {
  sc_sdev_disk, sc_sdev_tape, sc_sdev_cdrom, sc_sdev_floppy, sc_sdev_scanner,
  sc_sdev_other = 0x80
} hd_sc_std_t;

typedef enum sc_net_if {
  sc_nif_loopback, sc_nif_ethernet, sc_nif_tokenring, sc_nif_fddi,
  sc_nif_ctc, sc_nif_iucv, sc_nif_hsi, sc_nif_qeth,
  sc_nif_escon, sc_nif_myrinet, sc_nif_wlan, sc_nif_xp,
  sc_nif_usb, sc_nif_other = 0x80, sc_nif_sit
} hd_sc_net_if_t;

typedef enum sc_multimedia {
  sc_multi_video, sc_multi_audio, sc_multi_other
} hd_sc_multimedia_t;

typedef enum sc_keyboard {
  sc_keyboard_kbd, sc_keyboard_console
} hd_sc_keyboard_t;

typedef enum sc_hub {
  sc_hub_other, sc_hub_usb
} hd_sc_hub_t;

typedef enum sc_camera {
  sc_camera_webcam, sc_camera_digital
} hd_sc_camera_t;

typedef enum sc_modem {
  sc_mod_at, sc_mod_win1, sc_mod_win2, sc_mod_win3, sc_mod_win4
} hd_sc_modem_t;

typedef enum sc_dsl {
  sc_dsl_unknown, sc_dsl_pppoe, sc_dsl_capi, sc_dsl_capiisdn
} hd_sc_dsl_t;

typedef enum pif_usb_e {
  pif_usb_uhci = 0, pif_usb_ohci = 0x10, pif_usb_ehci = 0x20, pif_usb_xhci = 0x30,
  pif_usb_other = 0x80, pif_usb_device = 0xfe
} hd_pif_usb_t;

typedef enum pif_cdrom {
  pif_cdrom, pif_cdr, pif_cdrw, pif_dvd, pif_dvdr, pif_dvdram
} hd_pif_cdrom_t ;

typedef enum pif_s390disk {
  pif_scsi, pif_dasd, pif_dasd_fba
} hd_pif_s390disk_t;

typedef enum bus_types {
  bus_none, bus_isa, bus_eisa, bus_mc, bus_pci, bus_pcmcia, bus_nubus,
  bus_cardbus, bus_other,

  bus_ps2 = 0x80, bus_serial, bus_parallel, bus_floppy, bus_scsi, bus_ide, bus_usb,
  bus_adb, bus_raid, bus_sbus, bus_i2o, bus_vio, bus_ccw, bus_iucv, bus_ps3_system_bus,
  bus_virtio, bus_ibmebus, bus_gameport, bus_uisvirtpci, bus_mmc, bus_sdio, bus_nd
} hd_bus_types_t;


typedef struct {
  unsigned invalid:1;

  unsigned reconfig:3;

  unsigned configured:3;

  unsigned available:3;

  unsigned needed:3;

  unsigned available_orig:3;

  unsigned active:3;
} hd_status_t;

typedef enum {
  status_no = 1, status_yes, status_unknown, status_new
} hd_status_value_t;

typedef enum {
  hp_none,      
  hp_pcmcia,    
  hp_cardbus,   
  hp_pci,       
  hp_usb,       
  hp_ieee1394   
} hd_hotplug_t;


typedef struct {
  unsigned id;          
  char *name;           
} hd_id_t;
 

typedef struct s_str_list_t {
  struct s_str_list_t *next;    
  char *str;                    
} str_list_t;
 

typedef struct {
  unsigned char bitmap[16];     
  unsigned bits;                
  unsigned not_empty:1;         
  str_list_t *str;              
} hd_bitmap_t;

 



typedef struct {
  unsigned start, size;         
  unsigned char *data;          
} memory_range_t;
 

typedef struct {
  unsigned ok:1;                
  unsigned rev;                 
  unsigned mpfp;                
  unsigned mpconfig_ok:1;       
  unsigned mpconfig;            
  unsigned mpconfig_size;       
  unsigned char feature[5];     
  char oem_id[9];               
  char prod_id[13];             
  unsigned cpus, cpus_en;       
} smp_info_t;
 

typedef struct vbe_mode_info_s {
  unsigned number;              
  unsigned attributes;          
  unsigned width, height;       
  unsigned bytes_p_line;        
  unsigned pixel_size;          
  unsigned fb_start;            
  unsigned win_A_start;         
  unsigned win_A_attr;          
  unsigned win_B_start;         
  unsigned win_B_attr;          
  unsigned win_size;            
  unsigned win_gran;            
  unsigned pixel_clock;         
} vbe_mode_info_t;

typedef struct {
  unsigned ok:1;                
  unsigned version;             
  unsigned oem_version;         
  unsigned memory;              
  unsigned fb_start;            
  char *oem_name;               
  char *vendor_name;            
  char *product_name;           
  char *product_revision;       
  unsigned modes;               
  vbe_mode_info_t *mode;        
  unsigned current_mode;        
  unsigned ddc_ports;           
  unsigned char ddc_port[4][0x80];      
} vbe_info_t;
 

typedef struct {
    unsigned id;
    unsigned char slot;
    unsigned char bus;
    unsigned char devfn;
    unsigned char misc;
} cpq_ctlorder_t; 
 
 
typedef struct {
  unsigned ok:1;                
  unsigned entry;               
  unsigned compaq:1;            
  cpq_ctlorder_t cpq_ctrl[32];  
} bios32_info_t;



typedef enum {
  sm_biosinfo, sm_sysinfo, sm_boardinfo, sm_chassis,
  sm_processor, sm_memctrl, sm_memmodule, sm_cache,
  sm_connect, sm_slot, sm_onboard, sm_oem,
  sm_config, sm_lang, sm_group, sm_eventlog,
  sm_memarray, sm_memdevice, sm_memerror, sm_memarraymap,
  sm_memdevicemap, sm_mouse, sm_battery, sm_reset,
  sm_secure, sm_power, sm_voltage, sm_cool,
  sm_temperature, sm_current, sm_outofband, sm_bis,
  sm_boot, sm_mem64error, sm_mandev, sm_mandevcomp,
  sm_mdtd, sm_inactive = 126, sm_end = 127
} hd_smbios_type_t;
 

typedef struct {
  union u_hd_smbios_t *next;    
  hd_smbios_type_t type;        
  int data_len;                 
  unsigned char *data;          
  str_list_t *strings;          
  int handle;                   
} smbios_any_t;
 

typedef struct {
  union u_hd_smbios_t *next;
  hd_smbios_type_t type;
  int data_len;
  unsigned char *data;
  str_list_t *strings;
  int handle;
  char *vendor;                 
  char *version;                
  char *date;                   
  hd_bitmap_t feature;          
  unsigned start;               
  unsigned rom_size;            
} smbios_biosinfo_t;
 

typedef struct {
  union u_hd_smbios_t *next;
  hd_smbios_type_t type;
  int data_len;
  unsigned char *data;
  str_list_t *strings;
  int handle;
  char *manuf;                  
  char *product;                
  char *version;                
  char *serial;                 
  unsigned char uuid[16];       
  hd_id_t wake_up;              
} smbios_sysinfo_t;
 

typedef struct {
  union u_hd_smbios_t *next;
  hd_smbios_type_t type;
  int data_len;
  unsigned char *data;
  str_list_t *strings;
  int handle;
  char *manuf;                  
  char *product;                
  char *version;                
  char *serial;                 
  char *asset;                  
  hd_id_t board_type;           
  hd_bitmap_t feature;          
  char *location;               
  int chassis;                  
  int objects_len;              
  int *objects;                 
} smbios_boardinfo_t;
 

typedef struct {
  union u_hd_smbios_t *next;
  hd_smbios_type_t type;
  int data_len;
  unsigned char *data;
  str_list_t *strings;
  int handle;
  char *manuf;                  
  char *version;                
  char *serial;                 
  char *asset;                  
  hd_id_t ch_type;              
  unsigned lock;                
  hd_id_t bootup;               
  hd_id_t power;                
  hd_id_t thermal;              
  hd_id_t security;             
  unsigned oem;                 
} smbios_chassis_t;
 

typedef struct {
  union u_hd_smbios_t *next;
  hd_smbios_type_t type;
  int data_len;
  unsigned char *data;
  str_list_t *strings;
  int handle;
  char *socket;                 
  hd_id_t upgrade;              
  char *manuf;                  
  char *version;                
  char *serial;                 
  char *asset;                  
  char *part;                   
  hd_id_t pr_type;              
  hd_id_t family;               
  uint64_t cpu_id;              
  unsigned voltage;             
  unsigned ext_clock;           
  unsigned max_speed;           
  unsigned current_speed;       
  unsigned sock_status;         
  hd_id_t cpu_status;           
  int l1_cache;                 
  int l2_cache;                 
  int l3_cache;                 
} smbios_processor_t;
 

typedef struct {
  union u_hd_smbios_t *next;
  hd_smbios_type_t type;
  int data_len;
  unsigned char *data;
  str_list_t *strings;
  int handle;
  char *socket;                 
  unsigned max_size;            
  unsigned current_size;        
  unsigned speed;               
  hd_id_t mode;                 
  unsigned state;               
  hd_id_t location;             
  unsigned socketed;            
  unsigned level;               
  hd_id_t ecc;                  
  hd_id_t cache_type;           
  hd_id_t assoc;                
  hd_bitmap_t supp_sram;        
  hd_bitmap_t sram;             
} smbios_cache_t;
 

typedef struct {
  union u_hd_smbios_t *next;
  hd_smbios_type_t type;
  int data_len;
  unsigned char *data;
  str_list_t *strings;
  int handle;
  hd_id_t port_type;            
  char *i_des;                  
  hd_id_t i_type;               
  char *x_des;                  
  hd_id_t x_type;               
} smbios_connect_t;
 

typedef struct {
  union u_hd_smbios_t *next;
  hd_smbios_type_t type;
  int data_len;
  unsigned char *data;
  str_list_t *strings;
  int handle;
  char *desig;                  
  hd_id_t slot_type;            
  hd_id_t bus_width;            
  hd_id_t usage;                
  hd_id_t length;               
  unsigned id;                  
  hd_bitmap_t feature;          
} smbios_slot_t;
 

typedef struct {
  union u_hd_smbios_t *next;
  hd_smbios_type_t type;
  int data_len;
  unsigned char *data;
  str_list_t *strings;
  int handle;
  unsigned dev_len;             
  struct {
    char *name;                 
    hd_id_t type;               
    unsigned status;            
  } *dev;                       
} smbios_onboard_t;
 

typedef struct {
  union u_hd_smbios_t *next;
  hd_smbios_type_t type;
  int data_len;
  unsigned char *data;
  str_list_t *strings;
  int handle;
  str_list_t *oem_strings;      
} smbios_oem_t;
 

typedef struct {
  union u_hd_smbios_t *next;
  hd_smbios_type_t type;
  int data_len;
  unsigned char *data;
  str_list_t *strings;
  int handle;
  str_list_t *options;          
} smbios_config_t;
 

typedef struct {
  union u_hd_smbios_t *next;
  hd_smbios_type_t type;
  int data_len;
  unsigned char *data;
  str_list_t *strings;          
  int handle;
  char *current;                
} smbios_lang_t;
 

typedef struct {
  union u_hd_smbios_t *next;
  hd_smbios_type_t type;
  int data_len;
  unsigned char *data;
  str_list_t *strings;
  int handle;
  char *name;                   
  int items_len;                
  int *item_handles;            
} smbios_group_t;
 

typedef struct {
  union u_hd_smbios_t *next;
  hd_smbios_type_t type;
  int data_len;
  unsigned char *data;
  str_list_t *strings;
  int handle;
  hd_id_t location;             
  hd_id_t use;                  
  hd_id_t ecc;                  
  unsigned max_size;            
  int error_handle;             
  unsigned slots;               
} smbios_memarray_t;
 

typedef struct {
  union u_hd_smbios_t *next;
  hd_smbios_type_t type;
  int data_len;
  unsigned char *data;
  str_list_t *strings;
  int handle;
  char *location;               
  char *bank;                   
  char *manuf;                  
  char *serial;                 
  char *asset;                  
  char *part;                   
  int array_handle;             
  int error_handle;             
  unsigned width;               
  unsigned eccbits;             
  unsigned size;                
  hd_id_t form;                 
  unsigned set;                 
  hd_id_t mem_type;             
  hd_bitmap_t type_detail;      
  unsigned speed;               
} smbios_memdevice_t;
 

typedef struct {
  union u_hd_smbios_t *next;
  hd_smbios_type_t type;
  int data_len;
  unsigned char *data;
  str_list_t *strings;
  int handle;
  hd_id_t err_type;             
  hd_id_t granularity;          
  hd_id_t operation;            
  unsigned syndrome;            
  unsigned array_addr;          
  unsigned device_addr;         
  unsigned range;               
} smbios_memerror_t;
 

typedef struct {
  union u_hd_smbios_t *next;
  hd_smbios_type_t type;
  int data_len;
  unsigned char *data;
  str_list_t *strings;
  int handle;
  int array_handle;             
  uint64_t start_addr;          
  uint64_t end_addr;            
  unsigned part_width;          
} smbios_memarraymap_t;
 

typedef struct {
  union u_hd_smbios_t *next;
  hd_smbios_type_t type;
  int data_len;
  unsigned char *data;
  str_list_t *strings;
  int handle;
  int memdevice_handle;         
  int arraymap_handle;          
  uint64_t start_addr;          
  uint64_t end_addr;            
  unsigned row_pos;             
  unsigned interleave_pos;      
  unsigned interleave_depth;    
} smbios_memdevicemap_t;
 

typedef struct {
  union u_hd_smbios_t *next;
  hd_smbios_type_t type;
  int data_len;
  unsigned char *data;
  str_list_t *strings;
  int handle;
  hd_id_t mtype;                
  hd_id_t interface;            
  unsigned buttons;             
} smbios_mouse_t;
 

typedef struct {
  union u_hd_smbios_t *next;
  hd_smbios_type_t type;
  int data_len;
  unsigned char *data;
  str_list_t *strings;
  int handle;
  hd_id_t power;                
  hd_id_t keyboard;             
  hd_id_t admin;                
  hd_id_t reset;                
} smbios_secure_t;
 

typedef struct {
  union u_hd_smbios_t *next;
  hd_smbios_type_t type;
  int data_len;
  unsigned char *data;
  str_list_t *strings;
  int handle;
  unsigned month;               
  unsigned day;                 
  unsigned hour;                
  unsigned minute;              
  unsigned second;              
} smbios_power_t;
 

typedef struct {
  union u_hd_smbios_t *next;
  hd_smbios_type_t type;
  int data_len;
  unsigned char *data;
  str_list_t *strings;
  int handle;
  hd_id_t err_type;             
  hd_id_t granularity;          
  hd_id_t operation;            
  unsigned syndrome;            
  uint64_t array_addr;          
  uint64_t device_addr;         
  unsigned range;               
} smbios_mem64error_t;
 

typedef union u_hd_smbios_t {
  union u_hd_smbios_t *next;  
  smbios_any_t any;
  smbios_biosinfo_t biosinfo;
  smbios_sysinfo_t sysinfo;
  smbios_boardinfo_t boardinfo;
  smbios_chassis_t chassis;
  smbios_processor_t processor;
  smbios_cache_t cache;
  smbios_connect_t connect;
  smbios_slot_t slot;
  smbios_onboard_t onboard;
  smbios_oem_t oem;
  smbios_config_t config;
  smbios_lang_t lang;
  smbios_group_t group;
  smbios_memarray_t memarray;
  smbios_memdevice_t memdevice;
  smbios_memerror_t memerror;
  smbios_memarraymap_t memarraymap;
  smbios_memdevicemap_t memdevicemap;
  smbios_mouse_t mouse;
  smbios_secure_t secure;
  smbios_power_t power;
  smbios_mem64error_t mem64error;
} hd_smbios_t;

 
 

typedef struct s_udevinfo_t {
  struct s_udevinfo_t *next;
  char *sysfs;
  char *name;
  str_list_t *links;
} hd_udevinfo_t;
 

typedef struct s_sysfsdrv_t {
  struct s_sysfsdrv_t *next;
  char *driver;
  char *device;
  char *module;
} hd_sysfsdrv_t;
 

typedef struct {
  int type;
  unsigned major, minor, range;
} hd_dev_num_t;
 

 

typedef struct s_pci_t {
  struct s_pci_t *next;                         
  unsigned data_len;                            
  unsigned data_ext_len;                        
  unsigned char data[256];                      
  char *log;                                    
  unsigned flags,                               
           cmd,                                 
           hdr_type,                            
           secondary_bus;                       
  unsigned bus,                                 
           slot, func;                          
  unsigned base_class, sub_class, prog_if;      
  unsigned dev, vend, sub_dev, sub_vend, rev;   
  unsigned irq;                                 
  uint64_t base_addr[7];                        
  uint64_t base_len[7];                         
  unsigned addr_flags[7];                       
  uint64_t rom_base_addr;                       
  uint64_t rom_base_len;                        
  char *sysfs_id;                               
  char *sysfs_bus_id;                           
  char *modalias;                               
  char *label;                                  
  unsigned edid_len[6];                         
  unsigned char edid_data[6][0x80];             
} pci_t;

typedef enum pci_flags {
  pci_flag_ok, pci_flag_pm, pci_flag_agp
} hd_pci_flags_t;
 

typedef struct usb_s {
  struct usb_s *next;
  unsigned hd_idx;
  unsigned hd_base_idx;
  str_list_t *c, *d, *e, *i, *p, *s, *t;
  struct usb_s *cloned;
  int bus, dev_nr, lev, parent, port, count, conns, used_conns, ifdescr;
  unsigned speed;
  unsigned vendor, device, rev;
  char *manufact, *product, *serial;
  char *driver;
  memory_range_t raw_descr;
  int d_cls, d_sub, d_prot;
  int i_alt, i_cls, i_sub, i_prot;
  unsigned country;
} usb_t;
 

typedef struct {
  int len;
  int type;
  unsigned char *data;
} isapnp_res_t;

typedef struct {
  int csn;
  int log_devs;
  unsigned char *serial;
  unsigned char *card_regs;
  unsigned char (*ldev_regs)[0xd0];
  int res_len;
  unsigned broken:1;            
  isapnp_res_t *res;
} isapnp_card_t;

typedef struct {
  int read_port;
  int cards;
  isapnp_card_t *card;
} isapnp_t;

typedef struct {
  isapnp_card_t *card;
  int dev;
  unsigned flags;               
  unsigned ref:1;               
} isapnp_dev_t;

typedef enum isapnp_flags {
  isapnp_flag_act
} hd_isapnp_flags_t;
 

typedef struct scsi_s {
  struct scsi_s *next;
  unsigned deleted:1;
  unsigned generic:1;
  unsigned fake:1;
  unsigned wwpn_ok:1;
  unsigned fcp_lun_ok:1;
  char *dev_name;
  char *guessed_dev_name;
  int generic_dev;
  unsigned host, channel, id, lun;
  char *vendor, *model, *rev, *type_str, *serial;
  int type;
  unsigned inode_low;
  char *proc_dir, *driver;
  unsigned unique;
  char *info;
  unsigned lgeo_c, lgeo_h, lgeo_s;
  unsigned pgeo_c, pgeo_h, pgeo_s;
  uint64_t size;
  unsigned sec_size;
  unsigned cache;
  str_list_t *host_info;
  char *usb_guid;
  unsigned pci_info;
  unsigned pci_bus;
  unsigned pci_slot;
  unsigned pci_func;
  uint64_t wwpn;
  uint64_t fcp_lun;
  char *controller_id;
} scsi_t;
 

typedef struct devtree_s {
  struct devtree_s *next;
  struct devtree_s *parent;
  unsigned idx;
  char *path, *filename;
  unsigned pci:1;
  char *name, *model, *device_type, *compatible;
  char *ccin, *fru_number, *loc_code, *serial_number, *part_number;
  char *description;
  int class_code;                       
  int vendor_id, device_id, subvendor_id, subdevice_id;
  int revision_id, interrupt;
  unsigned char *edid;                  
} devtree_t;
 
enum pmac_model {
        AAPL_3400,
        AAPL_3500,
        AAPL_7200,
        AAPL_7300,
        AAPL_7500,
        AAPL_8500,
        AAPL_9500,
        AAPL_Gossamer,
        AAPL_PowerBook1998,
        AAPL_PowerMac_G3,
        AAPL_ShinerESB,
        AAPL_e407,
        AAPL_e411,
        PowerBook1_1,
        PowerBook2_1,
        PowerBook2_2,
        PowerBook3_1,
        PowerBook3_2,
        PowerBook3_3,
        PowerBook3_4,
        PowerBook3_5,
        PowerBook4_1,
        PowerBook4_2,
        PowerBook4_3,
        PowerBook5_1,
        PowerBook5_2,
        PowerBook5_3,
        PowerBook5_4,
        PowerBook5_5,
        PowerBook5_6,
        PowerBook5_7,
        PowerBook5_8,
        PowerBook5_9,
        PowerBook6_1,
        PowerBook6_2,
        PowerBook6_3,
        PowerBook6_4,
        PowerBook6_5,
        PowerBook6_7,
        PowerBook6_8,
        PowerMac1_1,
        PowerMac1_2,
        PowerMac10_1,
        PowerMac11_2,
        PowerMac12_1,
        PowerMac2_1,
        PowerMac2_2,
        PowerMac3_1,
        PowerMac3_2,
        PowerMac3_3,
        PowerMac3_4,
        PowerMac3_5,
        PowerMac3_6,
        PowerMac4_1,
        PowerMac4_2,
        PowerMac4_4,
        PowerMac5_1,
        PowerMac6_1,
        PowerMac6_3,
        PowerMac6_4,
        PowerMac7_2,
        PowerMac7_3,
        PowerMac8_1,
        PowerMac9_1,
        RackMac1_1,
        RackMac1_2,
        RackMac3_1,
        iMac_1,
};

struct pmac_mb_def {
  enum pmac_model model;
  const char *string;
};

typedef struct ccw_s {
  unsigned char lcss;
  unsigned char cu_model;
  unsigned char dev_model;
} ccw_t;

typedef struct joystick_s {
  unsigned char buttons;
  unsigned char axes;
} joystick_t;

typedef struct cdrom_info_s {
  struct cdrom_info_s *next;
  char *name;
  unsigned speed;
  unsigned cdr:1, cdrw:1, dvd:1, dvdr:1, dvdram:1;
  unsigned cdrom:1;             
  struct {
    unsigned ok:1;
    char *volume, *publisher, *preparer, *application, *creation_date;
  } iso9660;
  struct {
    unsigned ok:1;
    unsigned platform;
    char *id_string;
    unsigned bootable:1;
    unsigned media_type;        
    unsigned load_address;
    unsigned load_count;        
    unsigned start;             
    unsigned catalog;           
    struct {
      unsigned c, h, s;
      unsigned size;
    } geo;
    char *label;
  } el_torito;
 
} cdrom_info_t;
 

typedef struct {
  unsigned char block0[512];
} floppy_info_t;
 

typedef struct {
  unsigned apm_supported:1;
  unsigned apm_enabled:1;
  unsigned apm_ver, apm_subver;
  unsigned apm_bios_flags;
 
  unsigned vbe_ver;
  unsigned vbe_video_mem;
 
  unsigned ser_port0, ser_port1, ser_port2, ser_port3;
  unsigned par_port0, par_port1, par_port2;

  unsigned is_pnp_bios:1;
  unsigned pnp_id;
  unsigned lba_support:1;
 
  unsigned low_mem_size;
  smp_info_t smp;
  vbe_info_t vbe;
 
  unsigned smbios_ver;
 
  struct {
    unsigned width;
    unsigned height;
    unsigned xsize;
    unsigned ysize;
    char *vendor;
    char *name;
  } lcd;
 
  struct {
    char *vendor;
    char *type;
    unsigned bus;
    unsigned compat_vend;
    unsigned compat_dev;
  } mouse;
 
  struct {
    unsigned ok:1;
    unsigned scroll_lock:1;
    unsigned num_lock:1;
    unsigned caps_lock:1;
  } led;
 
  bios32_info_t bios32;
 
} bios_info_t;
 

typedef struct {
  unsigned has_color:1;
  unsigned color;
} prom_info_t;
 

typedef struct {
  char *system_type;
  char *generation;
  char *vendor;
  char *model;
  char *serial;
  char *lang;
  char *formfactor;
} sys_info_t;
 

typedef struct {
  unsigned manu_year;
  unsigned manu_week;
  unsigned min_vsync, max_vsync;        
  unsigned min_hsync, max_hsync;        
  unsigned clock;                       
  unsigned width, height;               
  unsigned width_mm, height_mm;         
  unsigned hdisp, hsyncstart, hsyncend, htotal; 
  unsigned vdisp, vsyncstart, vsyncend, vtotal; 
  char hflag,vflag; 
  char *vendor;
  char *name;
  char *serial;
} monitor_info_t;

 

typedef enum cpu_arch {
  arch_unknown = 0,
  arch_intel,
  arch_alpha,
  arch_sparc, arch_sparc64,
  arch_ppc, arch_ppc64,
  arch_68k,
  arch_ia64,
  arch_s390, arch_s390x,
  arch_arm,
  arch_mips,
  arch_x86_64,
  arch_aarch64,
  arch_riscv
} hd_cpu_arch_t;

typedef enum boot_arch {
  boot_unknown = 0,
  boot_lilo, boot_milo, boot_aboot, boot_silo, boot_ppc, boot_elilo, boot_s390,
  boot_mips, boot_grub, boot_uboot,
} hd_boot_arch_t;
 


typedef struct {
  enum cpu_arch architecture;
  unsigned family;              
  unsigned model;               
  unsigned stepping;
  unsigned cache;
  unsigned clock;
  unsigned units;               
  char *vend_name;              
  char *model_name;             
  char *platform;               
  str_list_t *features;         
  double bogo;                  
} cpu_info_t;
 

typedef struct {
  uint64_t sectors;
  struct {
    unsigned cyls, heads, sectors;
  } edd;
  struct {
    unsigned cyls, heads, sectors;
  } legacy;
  unsigned ext_fixed_disk:1;
  unsigned ext_lock_eject:1;
  unsigned ext_edd:1;
  unsigned ext_64bit:1;
  unsigned assigned:1;
  unsigned valid:1;
  unsigned ext_fibre:1;
  unsigned ext_net:1;
  char *sysfs_id;
  unsigned hd_idx;
  unsigned signature;
} edd_info_t;


typedef struct {
  unsigned data_len, data_max;
  unsigned *data;
  unsigned names_len, names_max;
  char *names;
} hddb_data_t;

typedef uint32_t hddb_entry_mask_t;

typedef struct hddb_list_s {   
  hddb_entry_mask_t key_mask;
  hddb_entry_mask_t value_mask;
  unsigned key;
  unsigned value;
} hddb_list_t;

typedef struct {
  unsigned list_len, list_max;
  hddb_list_t *list;
  unsigned ids_len, ids_max;
  unsigned *ids;
  unsigned strings_len, strings_max;
  char *strings;
} hddb2_data_t;
 

typedef enum modinfo_type_e { mi_none = 0, mi_pci, mi_other } modinfo_type_t;

typedef struct {
  char *module;
  char *alias;
  modinfo_type_t type;
  union {
    struct {
      struct {
        unsigned vendor:1;
        unsigned device:1;
        unsigned sub_vendor:1;
        unsigned sub_device:1;
        unsigned base_class:1;
        unsigned sub_class:1;
        unsigned prog_if:1;
      } has;
      unsigned vendor;
      unsigned device;
      unsigned sub_vendor;
      unsigned sub_device;
      unsigned base_class;
      unsigned sub_class;
      unsigned prog_if;
    } pci;
 
    struct {
      struct {
        unsigned vendor:1;
        unsigned product:1;
        unsigned device_class:1;
        unsigned device_subclass:1;
      } has;
      unsigned vendor;
      unsigned product;
      unsigned device_class;
      unsigned device_subclass;
    } usb;
  };
} modinfo_t;
 

typedef enum {
  p_invalid, p_string, p_int32, p_uint64, p_double, p_bool, p_list
} hal_prop_type_t;
 

typedef struct hal_prop_s {
  struct hal_prop_s *next;
  hal_prop_type_t type;
  char *key;
  union {
    char *str;
    int32_t int32;
    uint64_t uint64;
    double d;     
    int b;
    str_list_t *list;
  } val;  
} hal_prop_t;
 

typedef struct hal_device_s {
  struct hal_device_s *next, *parent;
  char *udi;
  unsigned used:1;
  hal_prop_t *prop;
} hal_device_t;

typedef enum resource_types {
  res_any, res_phys_mem, res_mem, res_io, res_irq, res_dma, res_monitor,
  res_size, res_disk_geo, res_cache, res_baud, res_init_strings, res_pppd_option,
  res_framebuffer, res_hwaddr, res_link, res_wlan, res_fc, res_phwaddr
} hd_resource_types_t;
 

typedef enum size_units {
  size_unit_cm, size_unit_cinch, size_unit_byte, size_unit_sectors,
  size_unit_kbyte, size_unit_mbyte, size_unit_gbyte, size_unit_mm
} hd_size_units_t;

typedef enum access_flags {
  acc_unknown,          
  acc_ro,               
  acc_wo,               
  acc_rw                
} hd_access_flags_t;
 
 
typedef enum yes_no_flag {
  flag_unknown,         
  flag_no,              
  flag_yes              
} hd_yes_no_flag_t;
 
 
typedef enum geo_types {
  geo_physical = 0, 
  geo_logical, 
  geo_bios_edd, 
  geo_bios_legacy
} hd_geo_types_t;
 

 
typedef struct {
  union u_hd_res_t *next;
  enum resource_types type;
} res_any_t;
 
typedef struct {
  union u_hd_res_t *next;
  enum resource_types type;
  uint64_t base, range;
  unsigned
    enabled:1,                  
    access:2,                   
    prefetch:2;                 
} res_mem_t;
 
typedef struct {
  union u_hd_res_t *next;
  enum resource_types type;
  uint64_t range;
} res_phys_mem_t;
 
typedef struct {
  union u_hd_res_t *next;
  enum resource_types type;
  uint64_t base, range;
  unsigned
    enabled:1,                          
    access:2;                           
} res_io_t;
 
typedef struct {
  union u_hd_res_t *next;
  enum resource_types type;
  unsigned base;
  unsigned triggered;                   
  unsigned enabled:1;                   
} res_irq_t;
 
typedef struct {
  union u_hd_res_t *next;
  enum resource_types type;
  unsigned base;
  unsigned enabled:1;                   
} res_dma_t;
 
typedef struct {
  union u_hd_res_t *next;
  enum resource_types type;
  enum size_units unit;
  uint64_t val1, val2;                  
} res_size_t;
 
typedef struct {
  union u_hd_res_t *next;
  enum resource_types type;
  unsigned speed;
  unsigned bits, stopbits;
  char parity;                          
  char handshake;                       
} res_baud_t;
 
typedef struct {
  union u_hd_res_t *next;
  enum resource_types type;
  unsigned size;                        
} res_cache_t;
 
typedef struct {
  union u_hd_res_t *next;
  enum resource_types type;
  unsigned cyls, heads, sectors;
  uint64_t size;
  enum geo_types geotype;               
} res_disk_geo_t;
 
typedef struct {
  union u_hd_res_t *next;
  enum resource_types type;
  unsigned width, height;               
  unsigned vfreq;                       
  unsigned interlaced:1;                
} res_monitor_t;
 
typedef struct {
  union u_hd_res_t *next;
  enum resource_types type;
  char *init1;
  char *init2;
} res_init_strings_t;
 
typedef struct {
  union u_hd_res_t *next;
  enum resource_types type;
  char *option;
} res_pppd_option_t;
 
typedef struct {
  union u_hd_res_t *next;
  enum resource_types type;
  unsigned width, height;               
  unsigned bytes_p_line;                
  unsigned colorbits;                   
  unsigned mode;                        
} res_framebuffer_t;
 
typedef struct {
  union u_hd_res_t *next;
  enum resource_types type;
  char *addr;
} res_hwaddr_t;
 
typedef struct {
  union u_hd_res_t *next;
  enum resource_types type;
  unsigned state:1;                     
} res_link_t;

typedef struct {
  union u_hd_res_t *next;
  enum resource_types type;
  str_list_t *channels;
  str_list_t *frequencies; 
  str_list_t *bitrates;    
  str_list_t *auth_modes;  
  str_list_t *enc_modes;   
} res_wlan_t;
 
typedef struct {
  union u_hd_res_t *next;
  enum resource_types type;
  unsigned wwpn_ok:1;
  unsigned fcp_lun_ok:1;
  unsigned port_id_ok:1;
  uint64_t wwpn;
  uint64_t fcp_lun;
  unsigned port_id;
  char *controller_id;
} res_fc_t;

typedef union u_hd_res_t {
  union u_hd_res_t *next;  
  res_any_t any;
  res_io_t io;
  res_mem_t mem;
  res_phys_mem_t phys_mem;
  res_irq_t irq;
  res_dma_t dma;
  res_size_t size;
  res_cache_t cache;
  res_baud_t baud;
  res_disk_geo_t disk_geo;
  res_monitor_t monitor;
  res_init_strings_t init_strings;
  res_pppd_option_t pppd_option;
  res_framebuffer_t framebuffer;
  res_hwaddr_t hwaddr;
  res_link_t link;
  res_wlan_t wlan;
  res_fc_t fc;
} hd_res_t;


 
typedef struct {
  uint64_t addr, size;
  char *dev;
  unsigned tag;
} misc_io_t;
 
typedef struct {
  unsigned channel;
  char *dev;
  unsigned tag;
} misc_dma_t;
 
typedef struct {
  unsigned irq, events;
  int devs;
  char **dev;
  unsigned tag;
} misc_irq_t;
 
typedef struct {
  unsigned io_len, dma_len, irq_len;
  misc_io_t *io;
  misc_dma_t *dma;
  misc_irq_t *irq;
  str_list_t *proc_io, *proc_dma, *proc_irq;
} misc_t;


typedef struct s_serial_t {
  struct s_serial_t *next;
  char *name;
  char *device;
  unsigned line, port, irq, baud;
} serial_t;

typedef struct s_ser_device_t {
  struct s_ser_device_t *next;
  unsigned hd_idx;
  char *dev_name;
  str_list_t *at_resp;
  int fd;
  struct termios tio;
  unsigned max_baud, cur_baud;
  unsigned is_mouse:1;
  unsigned is_modem:1;
  unsigned do_io:1;
  unsigned char buf[0x1000];
  int buf_len;
  int garbage, non_pnp, pnp;
  unsigned char pnp_id[8];
  char *serial, *class_name, *dev_id, *user_name, *vend, *init_string1, *init_string2, *pppd_option;
  unsigned pnp_rev;
  unsigned bits;
} ser_device_t;


typedef struct isdn_parm_s {
  struct isdn_parm_s *next;
  char *name;                           
  unsigned valid:1;                     
  unsigned conflict:1;                  
  uint64_t value;                       
  unsigned type;                        
  unsigned flags;                       
  unsigned def_value;                   
  int alt_values;                       
  unsigned *alt_value;                  
} isdn_parm_t;

typedef enum driver_info_type {
  di_any, di_display, di_module, di_mouse, di_x11, di_isdn, di_kbd, di_dsl
} hd_driver_info_t;

typedef struct {
  union driver_info_u *next;
  enum driver_info_type type;           
  str_list_t *hddb0, *hddb1;            
} driver_info_any_t;

typedef struct {
  union driver_info_u *next;
  enum driver_info_type type;           
  str_list_t *hddb0, *hddb1;            
  unsigned width, height;               
  unsigned min_vsync, max_vsync;        
  unsigned min_hsync, max_hsync;        
  unsigned bandwidth;                   
  unsigned hdisp, hsyncstart, hsyncend, htotal; 
  unsigned vdisp, vsyncstart, vsyncend, vtotal; 
  char hflag,vflag; 
} driver_info_display_t;

typedef struct {
  union driver_info_u *next;
  enum driver_info_type type;           
  str_list_t *hddb0, *hddb1;            
  unsigned active:1;                    
  unsigned modprobe:1;                  
  str_list_t *names;                    
  str_list_t *mod_args;                 
  char *conf;                           
} driver_info_module_t;

typedef struct {
  union driver_info_u *next;
  enum driver_info_type type;           
  str_list_t *hddb0, *hddb1;            
  char *xf86;                           
  char *gpm;                            
  int buttons;                          
  int wheels;                           
} driver_info_mouse_t;

typedef struct {
  union driver_info_u *next;
  enum driver_info_type type;           
  str_list_t *hddb0, *hddb1;            
  char *server;                         
  char *xf86_ver;                       
  unsigned x3d:1;                       
  struct {
    unsigned all:5;                     
    unsigned c8:1, c15:1, c16:1, c24:1, c32:1;
  } colors;                             
  unsigned dacspeed;                    
  str_list_t *extensions;               
  str_list_t *options;                  
  str_list_t *raw;                      
  char *script;                         
} driver_info_x11_t;

typedef struct {
  union driver_info_u *next;
  enum driver_info_type type;           
  str_list_t *hddb0, *hddb1;            
  int i4l_type, i4l_subtype;            
  char *i4l_name;                       
  isdn_parm_t *params;                  
} driver_info_isdn_t;

typedef struct {
  union driver_info_u *next;
  enum driver_info_type type;           
  str_list_t *hddb0, *hddb1;            
  char *mode;                           
  char *name;                           
} driver_info_dsl_t;

typedef struct {
  union driver_info_u *next;
  enum driver_info_type type;           
  str_list_t *hddb0, *hddb1;            
  char *XkbRules;                       
  char *XkbModel;
  char *XkbLayout;
  char *keymap;                         
} driver_info_kbd_t;
 
/*
 * holds device driver info
 */
typedef union driver_info_u {
  union driver_info_u *next;
  driver_info_any_t any;
  driver_info_module_t module;
  driver_info_mouse_t mouse;
  driver_info_x11_t x11;
  driver_info_display_t display;
  driver_info_isdn_t isdn;
  driver_info_dsl_t dsl;
  driver_info_kbd_t kbd;
} driver_info_t;



typedef enum hd_detail_type {
  hd_detail_pci, hd_detail_usb, hd_detail_isapnp, hd_detail_cdrom,
  hd_detail_floppy, hd_detail_bios, hd_detail_cpu, hd_detail_prom,
  hd_detail_monitor, hd_detail_sys, hd_detail_scsi, hd_detail_devtree,
  hd_detail_ccw, hd_detail_joystick
} hd_detail_type_t;
 
typedef struct {
  enum hd_detail_type type;
  pci_t *data;
} hd_detail_pci_t;
 
typedef struct {
  enum hd_detail_type type;
  usb_t *data;
} hd_detail_usb_t;
 
typedef struct {
  enum hd_detail_type type;
  isapnp_dev_t *data;
} hd_detail_isapnp_t;
 
typedef struct {
  enum hd_detail_type type;
  cdrom_info_t *data;
} hd_detail_cdrom_t;
 
typedef struct {
  enum hd_detail_type type;
  floppy_info_t *data;
} hd_detail_floppy_t;
 
typedef struct {
  enum hd_detail_type type;
  bios_info_t *data;
} hd_detail_bios_t;
 
typedef struct {
  enum hd_detail_type type;
  cpu_info_t *data;
} hd_detail_cpu_t;
 
typedef struct {
  enum hd_detail_type type;
  prom_info_t *data;
} hd_detail_prom_t;
 
typedef struct hd_detail_monitor_s {
  enum hd_detail_type type;
  monitor_info_t *data;
  struct hd_detail_monitor_s *next;
} hd_detail_monitor_t;
 
typedef struct {
  enum hd_detail_type type;
  sys_info_t *data;
} hd_detail_sys_t;
 
typedef struct {
  enum hd_detail_type type;
  scsi_t *data;
} hd_detail_scsi_t;
 
typedef struct {
  enum hd_detail_type type;
  devtree_t *data;
} hd_detail_devtree_t;
 
typedef struct {
  enum hd_detail_type type;
  ccw_t *data;
} hd_detail_ccw_t;
 
typedef struct {
  enum hd_detail_type type;
  joystick_t *data;
} hd_detail_joystick_t;
 
typedef union {
  enum hd_detail_type type;
  hd_detail_pci_t pci;
  hd_detail_usb_t usb;
  hd_detail_isapnp_t isapnp;
  hd_detail_cdrom_t cdrom;
  hd_detail_floppy_t floppy;
  hd_detail_bios_t bios;
  hd_detail_cpu_t cpu;
  hd_detail_prom_t prom;
  hd_detail_monitor_t monitor;
  hd_detail_sys_t sys;
  hd_detail_scsi_t scsi;
  hd_detail_devtree_t devtree;
  hd_detail_ccw_t ccw;
  hd_detail_joystick_t joystick;
} hd_detail_t;



typedef struct hd_manual_s {
  struct hd_manual_s *next;
 
  char *unique_id;
  char *parent_id;
  char *child_ids;
  unsigned hw_class;
  char *model;
 
  hd_status_t status;
  char *config_string;
 
  /* More or less free-form key, value pairs.
   * key should not contain '=', however.
   */
  str_list_t *key;
  str_list_t *value;
} hd_manual_t;
 

typedef struct s_hd_t {
  struct s_hd_t *next;          
  unsigned idx;

  unsigned broken:1;
 
  hd_id_t bus;

  unsigned slot;

  unsigned func;

  hd_id_t base_class;

  hd_id_t sub_class;

  hd_id_t prog_if;

  hd_id_t vendor;

  hd_id_t device;

  hd_id_t sub_vendor;

  hd_id_t sub_device;

  hd_id_t revision;

  char *serial;

  hd_id_t compat_vendor;

  hd_id_t compat_device;

  hd_hw_item_t hw_class;

  unsigned char hw_class_list[(hw_all + 7) / 8];        

  char *model;

  unsigned attached_to;

  char *sysfs_id;

  char *sysfs_bus_id;

  char *sysfs_device_link;

  char *unix_dev_name;

  hd_dev_num_t unix_dev_num;

  str_list_t *unix_dev_names;

  char *unix_dev_name2;

  hd_dev_num_t unix_dev_num2;

  char *rom_id;

  char *udi;

  char *parent_udi;

  char *unique_id;

  str_list_t *unique_ids;

  unsigned module;

  unsigned line;

  unsigned count;

  hd_res_t *res;

  hd_detail_t *detail;

  str_list_t *extra_info;

  hd_status_t status;

  char *config_string;

  hd_hotplug_t hotplug;

  unsigned hotplug_slot;
 
  struct is_s {
    unsigned agp:1;             
    unsigned isapnp:1;          
    unsigned notready:1;        
    unsigned manual:1;          
    unsigned softraiddisk:1;    
    unsigned zip:1;             
    unsigned cdr:1;             
    unsigned cdrw:1;            
    unsigned dvd:1;             
    unsigned dvdr:1;            
    unsigned dvdrw:1;           
    unsigned dvdrdl:1;          
    unsigned dvdpr:1;           
    unsigned dvdprw:1;          
    unsigned dvdprdl:1;         
    unsigned dvdprwdl:1;        
    unsigned bd:1;              
    unsigned bdr:1;             
    unsigned bdre:1;            
    unsigned hd:1;              
    unsigned hdr:1;             
    unsigned hdrw:1;            
    unsigned dvdram:1;          
    unsigned mo:1;              
    unsigned mrw:1;             
    unsigned mrww:1;            
    unsigned pppoe:1;           
    unsigned wlan:1;            
    unsigned with_acpi:1;       
    unsigned hotpluggable:1;    
    unsigned dualport:1;        
    unsigned fcoe:1;            
    unsigned fcoe_offload:2;    
    unsigned iscsi_offload:2;   
    unsigned storage_only:2;    
  } is;
 
  struct tag_s {                
    unsigned remove:1;          
    unsigned freeit:1;          
    unsigned fixed:1;           
    unsigned skip_mouse:1;      
    unsigned skip_modem:1;      
    unsigned skip_braille:1;    
    unsigned ser_device:2;      
  } tag;

  unsigned char *block0;

  char *driver;

  char *driver_module;

  str_list_t *drivers;

  str_list_t *driver_modules;

  char *old_unique_id;

  char *parent_id;

  str_list_t *child_ids;

  char *unique_id1;

  char *usb_guid;
 
  driver_info_t *driver_info;   
 
  str_list_t *requires;         
 
  hal_prop_t *hal_prop;         
 
  hal_prop_t *persistent_prop;  
 
  char *modalias;               
  char *label;                  
 
  /*
   * These are used internally for memory management.
   * Do not even _think_ of modifying these!
   */
  unsigned ref_cnt;             
  struct s_hd_t *ref;           
} hd_t;
 

typedef struct {
  hd_t *hd;

  void (*progress)(char *pos, char *msg);
  
  char *log;

  unsigned debug;

  struct flag_struct {
    unsigned internal:1;        
    unsigned dformat:2;         
    unsigned no_parport:1;      
    unsigned iseries:1;         
    unsigned list_all:1;        
    unsigned fast:1;            
    unsigned list_md:1;         
    unsigned nofork:1;          
    unsigned nosysfs:1;         
    unsigned forked:1;          
    unsigned cpuemu:1;          
    unsigned udev:1;            
    unsigned edd_used:1;        
    unsigned keep_kmods:2;      
    unsigned nobioscrc:1;       
    unsigned biosvram:1;        
    unsigned nowpa:1;           
    unsigned pata:1;            
    unsigned vbox:1;            
    unsigned vmware:1;          
    unsigned vmware_mouse:1;    
  } flags;
 

  str_list_t *only;
 
  /*
   * The following entries should *not* be accessed outside of libhd!
   */
  unsigned char probe[(pr_all + 7) / 8];        
  unsigned char probe_set[(pr_all + 7) / 8];    
  unsigned char probe_clr[(pr_all + 7) / 8];    
  hal_prop_t *probe_val;        
  unsigned last_idx;            
  unsigned module;              
  enum boot_arch boot;          
  hd_t *old_hd;                 
  pci_t *pci;                   
  isapnp_t *isapnp;             
  cdrom_info_t *cdrom;          
  str_list_t *net;              
  str_list_t *floppy;           
  misc_t *misc;                 
  serial_t *serial;             
  scsi_t *scsi;                 
  ser_device_t *ser_mouse;      
  ser_device_t *ser_modem;      
  str_list_t *cpu;              
  str_list_t *klog;             
  str_list_t *proc_usb;         
  usb_t *usb;                   
  modinfo_t *modinfo_ext;       
  modinfo_t *modinfo;           
  hddb2_data_t *hddb2[2];       
  str_list_t *kmods;            
  uint64_t used_irqs;           
  uint64_t assigned_irqs;       
  memory_range_t bios_rom;      
  memory_range_t bios_ram;      
  memory_range_t bios_ebda;     
  unsigned display;             
  unsigned color_code;          
  char *cmd_line;               
  str_list_t *xtra_hd;          
  devtree_t *devtree;           
  unsigned kernel_version;      
  hd_t *manual;                 
  str_list_t *disks;            
  str_list_t *partitions;       
  str_list_t *cdroms;           
  hd_smbios_t *smbios;          
  struct {
    unsigned ok:1;
    unsigned size;
    unsigned used;
    void *data;
    int id;
    int updated;
  } shm;                        
  unsigned pci_config_type;     
  hd_udevinfo_t *udevinfo;      
  hd_sysfsdrv_t *sysfsdrv;      
  uint64_t sysfsdrv_id;         
  str_list_t *scanner_db;       
  edd_info_t edd[0x80];         
  hal_device_t *hal;            
  str_list_t *lsscsi;           
  struct vm_s *vm;              
  size_t log_size;              
  size_t log_max;               
  str_list_t *klog_raw;         
} hd_data_t;
 
 
/* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
 *
 *                      libhd interface functions
 *
 * - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
 */
 
/* implemented in hd.c */

void hd_scan(hd_data_t *hd_data);

hd_data_t *hd_free_hd_data(hd_data_t *hd_data);

hd_t *hd_free_hd_list(hd_t *hd);
 
void hd_set_probe_feature(hd_data_t *hd_data, enum probe_feature feature);
void hd_clear_probe_feature(hd_data_t *hd_data, enum probe_feature feature);
int hd_probe_feature(hd_data_t *hd_data, enum probe_feature feature);
void hd_set_probe_feature_hw(hd_data_t *hd_data, hd_hw_item_t item);
 
enum probe_feature hd_probe_feature_by_name(char *name);
char *hd_probe_feature_by_value(enum probe_feature feature);
 
int hd_module_is_active(hd_data_t *hd_data, char *mod);
 
hd_t *hd_base_class_list(hd_data_t *hd_data, unsigned base_class);
hd_t *hd_sub_class_list(hd_data_t *hd_data, unsigned base_class, unsigned sub_class);
hd_t *hd_bus_list(hd_data_t *hd_data, unsigned bus);
const char* hd_busid_to_hwcfg(int busid);
hd_t *hd_list(hd_data_t *hd_data, hd_hw_item_t item, int rescan, hd_t *hd_old);
hd_t *hd_list_with_status(hd_data_t *hd_data, hd_hw_item_t item, hd_status_t status);
hd_t *hd_list2(hd_data_t *hd_data, hd_hw_item_t *items, int rescan);
hd_t *hd_list_with_status2(hd_data_t *hd_data, hd_hw_item_t *items, hd_status_t status);
 
void hd_add_driver_data(hd_data_t *hd_data, hd_t *hd);
 
int hd_has_pcmcia(hd_data_t *hd_data);
#if 0
int hd_apm_enabled(hd_data_t *hd_data);
#endif
int hd_usb_support(hd_data_t *hd_data);
int hd_smp_support(hd_data_t *hd_data);
int hd_mac_color(hd_data_t *hd_data);
int hd_color(hd_data_t *hd_data);
int hd_is_uml(hd_data_t *hd_data);
int hd_is_xen(hd_data_t *hd_data);
unsigned hd_display_adapter(hd_data_t *hd_data);
unsigned hd_boot_disk(hd_data_t *hd_data, int *matches);
enum cpu_arch hd_cpu_arch(hd_data_t *hd_data);
enum boot_arch hd_boot_arch(hd_data_t *hd_data);
 
hd_t *hd_get_device_by_idx(hd_data_t *hd_data, unsigned idx);
 
void hd_set_hw_class(hd_t *hd, hd_hw_item_t hw_class);
int hd_is_hw_class(hd_t *hd, hd_hw_item_t hw_class);
 
int hd_is_sgi_altix(hd_data_t *hd_data);
 
char *hd_version(void);
 
hal_prop_t *hd_free_hal_properties(hal_prop_t *prop);
hal_prop_t *hd_read_properties(const char *udi);
int hd_write_properties(const char *udi, hal_prop_t *prop);
 
int hd_change_status(const char *id, hd_status_t status, const char *config_string);
int hd_change_config_status(hd_data_t *hd_data, const char *id, hd_status_t status, const char *config_string);
int hd_read_mmap(hd_data_t *hd_data, char *name, unsigned char *buf, off_t start, unsigned size);
 
/* implemented in hddb.c */

str_list_t *hddb_get_packages(hd_data_t *hd_data);
void hddb_add_info(hd_data_t *hd_data, hd_t *hd);
 
void hddb_dump_raw(hddb2_data_t *hddb, FILE *f);
void hddb_dump(hddb2_data_t *hddb, FILE *f);
 
 
/* implemented in hdp.c */
void hd_dump_entry(hd_data_t *hd_data, hd_t *hd, FILE *f);
 
/* implemented in cdrom.c */
cdrom_info_t *hd_read_cdrom_info(hd_data_t *hd_data, hd_t *hd);

 
hd_manual_t *hd_manual_read_entry(hd_data_t *hd_data, const char *id);
int hd_manual_write_entry(hd_data_t *hd_data, hd_manual_t *entry);
hd_manual_t *hd_free_manual(hd_manual_t *manual);
hd_t *hd_read_config(hd_data_t *hd_data, const char *id);
int hd_write_config(hd_data_t *hd_data, hd_t *hd);
char *hd_hw_item_name(hd_hw_item_t item);
hd_hw_item_t hd_hw_item_type(char *name);
char *hd_status_value_name(hd_status_value_t status);

 

 
#define CDBISDN_VERSION 0x0101
 
#ifndef PCI_ANY_ID
#define PCI_ANY_ID      0xffff
#endif
 
#define CDBISDN_P_NONE  0x0
#define CDBISDN_P_IRQ   0x1
#define CDBISDN_P_MEM   0x2
#define CDBISDN_P_IO    0x3

typedef struct {
        char    *name;
        char    *shortname;
        int     vnr;
        int     refcnt;
} cdb_isdn_vendor;
 
typedef struct  {
        int     handle;         
        int     vhandle;        
        char    *name;          
        char    *lname;         
        char    *Class;         
        char    *bus;           
        int     revision;       
        int     vendor;         
        int     device;         
        int     subvendor;      
        int     subdevice;      
        unsigned int features;  
        int     line_cnt;       
        int     vario_cnt;      
        int     vario;          
} cdb_isdn_card;
 
typedef struct  {
        int     handle;          
        int     next_vario;     
        int     drvid;          
        int     typ;            
        int     subtyp;         
        int     smp;            
        char    *mod_name;      
        char    *para_str;      
        char    *mod_preload;   
        char    *cfg_prog;      
        char    *firmware;      
        char    *description;   
        char    *need_pkg;      
        char    *info;          
        char    *protocol;      
        char    *interface;     
        char    *io;            
        char    *irq;           
        char    *membase;       
        char    *features;      
        int     card_ref;       
        char    *name;          
} cdb_isdn_vario;
 
 
extern cdb_isdn_vendor  *hd_cdbisdn_get_vendor(int);
extern cdb_isdn_card    *hd_cdbisdn_get_card(int);
extern cdb_isdn_vario   *hd_cdbisdn_get_vario_from_type(int, int);
extern cdb_isdn_card    *hd_cdbisdn_get_card_from_type(int, int);
extern cdb_isdn_card    *hd_cdbisdn_get_card_from_id(int, int, int, int);
extern cdb_isdn_vario   *hd_cdbisdn_get_vario(int);
extern int              hd_cdbisdn_get_version(void);
extern int              hd_cdbisdn_get_db_version(void);
extern char             *hd_cdbisdn_get_db_date(void);

 
#ifdef __cplusplus
}
#endif

 
#endif  /* _HD_H */