/*
* read an entry
*/
hal_prop_t *hd_manual_read_entry_old(const char *id)
{
char path[PATH_MAX];
int line;
str_list_t *sl, *sl0;
char *s, *s1, *s2;
hal_prop_t *prop_list = NULL, *prop = NULL;
if(!id) return NULL;
snprintf(path, sizeof path, "%s/%s", hd_get_hddb_path("unique-keys"), id);
if(!(sl0 = read_file(path, 0, 0))) return prop_list;
for(line = 1, sl = sl0; sl; sl = sl->next, line++) {
s = sl->str;
while(isspace(*s)) s++;
if(!*s || *s == '#' || *s == ';') continue; /* empty lines & comments */
s2 = s;
s1 = strsep(&s2, "=");
if(!s2 && *s == '[') continue;
if(!s2) break;
if(s1) {
if(prop) {
prop->next = new_mem(sizeof *prop);
prop = prop->next;
}
else {
prop_list = prop = new_mem(sizeof *prop);
}
prop->type = p_string;
for(s = s1; *s; s++) if(*s >= 'A' && *s <= 'Z') *s += 'a' - 'A';
str_printf(&prop->key, 0, "hwinfo.%s", s1);
prop->val.str = canon_str(s2, strlen(s2));
}
}
free_str_list(sl0);
return prop_list;
}
void get_usb_devs(hd_data_t *hd_data)
{
uint64_t ul0;
unsigned u1, u2, u3;
hd_t *hd, *hd1;
usb_t *usb;
str_list_t *sl, *usb_devs = NULL;
char *s, *s1, *t;
hd_res_t *res;
size_t l;
str_list_t *sf_bus, *sf_bus_e;
char *sf_dev, *sf_dev_2;
sf_bus = read_dir("/sys/bus/usb/devices", 'l');
if(!sf_bus) {
ADD2LOG("sysfs: no such bus: usb\n");
return;
}
for(sf_bus_e = sf_bus; sf_bus_e; sf_bus_e = sf_bus_e->next) {
sf_dev = hd_read_sysfs_link("/sys/bus/usb/devices", sf_bus_e->str);
if(hd_attr_uint(get_sysfs_attr_by_path(sf_dev, "bNumInterfaces"), &ul0, 0)) {
add_str_list(&usb_devs, sf_dev);
ADD2LOG(" usb dev: %s\n", hd_sysfs_id(sf_dev));
}
}
for(sf_bus_e = sf_bus; sf_bus_e; sf_bus_e = sf_bus_e->next) {
sf_dev = new_str(hd_read_sysfs_link("/sys/bus/usb/devices", sf_bus_e->str));
ADD2LOG(
" usb device: name = %s\n path = %s\n",
sf_bus_e->str,
hd_sysfs_id(sf_dev)
);
if(
hd_attr_uint(get_sysfs_attr_by_path(sf_dev, "bInterfaceNumber"), &ul0, 16)
) {
hd = add_hd_entry(hd_data, __LINE__, 0);
hd->detail = new_mem(sizeof *hd->detail);
hd->detail->type = hd_detail_usb;
hd->detail->usb.data = usb = new_mem(sizeof *usb);
hd->sysfs_id = new_str(hd_sysfs_id(sf_dev));
hd->sysfs_bus_id = new_str(sf_bus_e->str);
hd->bus.id = bus_usb;
hd->func = ul0;
usb->ifdescr = ul0;
if((s = get_sysfs_attr_by_path(sf_dev, "modalias"))) {
s = canon_str(s, strlen(s));
ADD2LOG(" modalias = \"%s\"\n", s);
if(s && *s) {
hd->modalias = s;
s = NULL;
}
s = free_mem(s);
}
ADD2LOG(" bInterfaceNumber = %u\n", hd->func);
if(hd_attr_uint(get_sysfs_attr_by_path(sf_dev, "bInterfaceClass"), &ul0, 16)) {
usb->i_cls = ul0;
ADD2LOG(" bInterfaceClass = %u\n", usb->i_cls);
}
if(hd_attr_uint(get_sysfs_attr_by_path(sf_dev, "bInterfaceSubClass"), &ul0, 16)) {
usb->i_sub = ul0;
ADD2LOG(" bInterfaceSubClass = %u\n", usb->i_sub);
}
if(hd_attr_uint(get_sysfs_attr_by_path(sf_dev, "bInterfaceProtocol"), &ul0, 16)) {
usb->i_prot = ul0;
ADD2LOG(" bInterfaceProtocol = %u\n", usb->i_prot);
}
/* device has longest matching sysfs id */
u2 = strlen(sf_dev);
s = NULL;
for(u3 = 0, sl = usb_devs; sl; sl = sl->next) {
u1 = strlen(sl->str);
if(u1 > u3 && u1 <= u2 && !strncmp(sf_dev, sl->str, u1)) {
u3 = u1;
s = sl->str;
}
}
if(s) {
ADD2LOG(" if: %s @ %s\n", hd->sysfs_bus_id, hd_sysfs_id(s));
sf_dev_2 = new_str(s);
if(sf_dev_2) {
if(hd_attr_uint(get_sysfs_attr_by_path(sf_dev_2, "bDeviceClass"), &ul0, 16)) {
usb->d_cls = ul0;
ADD2LOG(" bDeviceClass = %u\n", usb->d_cls);
}
if(hd_attr_uint(get_sysfs_attr_by_path(sf_dev_2, "bDeviceSubClass"), &ul0, 16)) {
usb->d_sub = ul0;
ADD2LOG(" bDeviceSubClass = %u\n", usb->d_sub);
}
if(hd_attr_uint(get_sysfs_attr_by_path(sf_dev_2, "bDeviceProtocol"), &ul0, 16)) {
usb->d_prot = ul0;
ADD2LOG(" bDeviceProtocol = %u\n", usb->d_prot);
}
if(hd_attr_uint(get_sysfs_attr_by_path(sf_dev_2, "idVendor"), &ul0, 16)) {
usb->vendor = ul0;
ADD2LOG(" idVendor = 0x%04x\n", usb->vendor);
}
if(hd_attr_uint(get_sysfs_attr_by_path(sf_dev_2, "idProduct"), &ul0, 16)) {
usb->device = ul0;
ADD2LOG(" idProduct = 0x%04x\n", usb->device);
}
if((s = get_sysfs_attr_by_path(sf_dev_2, "manufacturer"))) {
usb->manufact = canon_str(s, strlen(s));
ADD2LOG(" manufacturer = \"%s\"\n", usb->manufact);
}
if((s = get_sysfs_attr_by_path(sf_dev_2, "product"))) {
usb->product = canon_str(s, strlen(s));
ADD2LOG(" product = \"%s\"\n", usb->product);
}
if((s = get_sysfs_attr_by_path(sf_dev_2, "serial"))) {
usb->serial = canon_str(s, strlen(s));
ADD2LOG(" serial = \"%s\"\n", usb->serial);
}
if(hd_attr_uint(get_sysfs_attr_by_path(sf_dev_2, "bcdDevice"), &ul0, 16)) {
usb->rev = ul0;
ADD2LOG(" bcdDevice = %04x\n", usb->rev);
}
if((s = get_sysfs_attr_by_path(sf_dev_2, "speed"))) {
s = canon_str(s, strlen(s));
if(!strcmp(s, "1.5")) usb->speed = 15*100000;
else if(!strcmp(s, "12")) usb->speed = 12*1000000;
else if(!strcmp(s, "480")) usb->speed = 480*1000000;
ADD2LOG(" speed = \"%s\"\n", s);
s = free_mem(s);
}
sf_dev_2 = free_mem(sf_dev_2);
}
}
if(usb->vendor || usb->device) {
hd->vendor.id = MAKE_ID(TAG_USB, usb->vendor);
hd->device.id = MAKE_ID(TAG_USB, usb->device);
}
if(usb->manufact) hd->vendor.name = new_str(usb->manufact);
if(usb->product) hd->device.name = new_str(usb->product);
if(usb->serial) hd->serial = new_str(usb->serial);
if(usb->rev) str_printf(&hd->revision.name, 0, "%x.%02x", usb->rev >> 8, usb->rev & 0xff);
if(usb->speed) {
res = add_res_entry(&hd->res, new_mem(sizeof *res));
res->baud.type = res_baud;
res->baud.speed = usb->speed;
}
s = hd_sysfs_find_driver(hd_data, hd->sysfs_id, 1);
if(s) add_str_list(&hd->drivers, s);
set_class_entries(hd_data, hd, usb);
if(!hd_data->scanner_db) {
hd_data->scanner_db = hd_module_list(hd_data, 1);
}
if(
hd->drivers &&
search_str_list(hd_data->scanner_db, hd->drivers->str)
) {
hd->base_class.id = bc_scanner;
}
// ###### FIXME
if(hd->base_class.id == bc_modem) {
hd->unix_dev_name = new_str("/dev/ttyACM0");
}
}
sf_dev = free_mem(sf_dev);
}
/*
* Get the (raw) PCI data, taken from /sys/bus/pci.
*
* Note: non-root users can only read the first 64 bytes (of 256)
* of the device headers.
*/
void hd_pci_read_data(hd_data_t *hd_data)
{
uint64_t ul0, ul1, ul2;
unsigned u, u0, u1, u2, u3;
unsigned char nxt;
str_list_t *sl;
char *s;
pci_t *pci;
int fd, i;
str_list_t *sf_bus, *sf_bus_e;
char *sf_dev;
sf_bus = reverse_str_list(read_dir("/sys/bus/pci/devices", 'l'));
if(!sf_bus) {
ADD2LOG("sysfs: no such bus: pci\n");
return;
}
for(sf_bus_e = sf_bus; sf_bus_e; sf_bus_e = sf_bus_e->next) {
sf_dev = new_str(hd_read_sysfs_link("/sys/bus/pci/devices", sf_bus_e->str));
ADD2LOG(
" pci device: name = %s\n path = %s\n",
sf_bus_e->str,
hd_sysfs_id(sf_dev)
);
if(sscanf(sf_bus_e->str, "%x:%x:%x.%x", &u0, &u1, &u2, &u3) != 4) continue;
pci = add_pci_entry(hd_data, new_mem(sizeof *pci));
pci->sysfs_id = new_str(sf_dev);
pci->sysfs_bus_id = new_str(sf_bus_e->str);
pci->bus = (u0 << 8) + u1;
pci->slot = u2;
pci->func = u3;
if((s = get_sysfs_attr_by_path(sf_dev, "modalias"))) {
pci->modalias = canon_str(s, strlen(s));
ADD2LOG(" modalias = \"%s\"\n", pci->modalias);
}
if(hd_attr_uint(get_sysfs_attr_by_path(sf_dev, "class"), &ul0, 0)) {
ADD2LOG(" class = 0x%x\n", (unsigned) ul0);
pci->prog_if = ul0 & 0xff;
pci->sub_class = (ul0 >> 8) & 0xff;
pci->base_class = (ul0 >> 16) & 0xff;
}
if(hd_attr_uint(get_sysfs_attr_by_path(sf_dev, "vendor"), &ul0, 0)) {
ADD2LOG(" vendor = 0x%x\n", (unsigned) ul0);
pci->vend = ul0 & 0xffff;
}
if(hd_attr_uint(get_sysfs_attr_by_path(sf_dev, "device"), &ul0, 0)) {
ADD2LOG(" device = 0x%x\n", (unsigned) ul0);
pci->dev = ul0 & 0xffff;
}
if(hd_attr_uint(get_sysfs_attr_by_path(sf_dev, "subsystem_vendor"), &ul0, 0)) {
ADD2LOG(" subvendor = 0x%x\n", (unsigned) ul0);
pci->sub_vend = ul0 & 0xffff;
}
if(hd_attr_uint(get_sysfs_attr_by_path(sf_dev, "subsystem_device"), &ul0, 0)) {
ADD2LOG(" subdevice = 0x%x\n", (unsigned) ul0);
pci->sub_dev = ul0 & 0xffff;
}
if(hd_attr_uint(get_sysfs_attr_by_path(sf_dev, "irq"), &ul0, 0)) {
ADD2LOG(" irq = %d\n", (unsigned) ul0);
pci->irq = ul0;
}
sl = hd_attr_list(get_sysfs_attr_by_path(sf_dev, "resource"));
for(u = 0; sl; sl = sl->next, u++) {
if(
sscanf(sl->str, "0x%"SCNx64" 0x%"SCNx64" 0x%"SCNx64, &ul0, &ul1, &ul2) == 3 &&
ul1 &&
u < sizeof pci->base_addr / sizeof *pci->base_addr
) {
ADD2LOG(" res[%u] = 0x%"PRIx64" 0x%"PRIx64" 0x%"PRIx64"\n", u, ul0, ul1, ul2);
pci->base_addr[u] = ul0;
pci->base_len[u] = ul1 + 1 - ul0;
pci->addr_flags[u] = ul2;
}
}
s = NULL;
str_printf(&s, 0, "%s/config", sf_dev);
if((fd = open(s, O_RDONLY)) != -1) {
pci->data_len = pci->data_ext_len = read(fd, pci->data, 0x40);
ADD2LOG(" config[%u]\n", pci->data_len);
if(pci->data_len >= 0x40) {
pci->hdr_type = pci->data[PCI_HEADER_TYPE] & 0x7f;
pci->cmd = pci->data[PCI_COMMAND] + (pci->data[PCI_COMMAND + 1] << 8);
if(pci->hdr_type == 1 || pci->hdr_type == 2) { /* PCI or CB bridge */
pci->secondary_bus = pci->data[PCI_SECONDARY_BUS];
/* PCI_SECONDARY_BUS == PCI_CB_CARD_BUS */
}
for(u = 0; u < sizeof pci->base_addr / sizeof *pci->base_addr; u++) {
if((pci->addr_flags[u] & IORESOURCE_IO)) {
if(!(pci->cmd & PCI_COMMAND_IO)) pci->addr_flags[u] |= IORESOURCE_DISABLED;
}
if((pci->addr_flags[u] & IORESOURCE_MEM)) {
if(!(pci->cmd & PCI_COMMAND_MEMORY)) pci->addr_flags[u] |= IORESOURCE_DISABLED;
}
}
/* let's go through the capability list */
if(
pci->hdr_type == PCI_HEADER_TYPE_NORMAL &&
(nxt = pci->data[PCI_CAPABILITY_LIST])
) {
/*
* Cut out after 16 capabilities to avoid infinite recursion due
* to (potentially) malformed data. 16 is more or less
* arbitrary, though (the capabilities are bits in a byte, so 8 entries
* should suffice).
*/
for(u = 0; u < 16 && nxt && nxt <= 0xfe; u++) {
switch(pci_cfg_byte(pci, fd, nxt)) {
case PCI_CAP_ID_PM:
pci->flags |= (1 << pci_flag_pm);
break;
case PCI_CAP_ID_AGP:
pci->flags |= (1 << pci_flag_agp);
break;
}
nxt = pci_cfg_byte(pci, fd, nxt + 1);
}
}
}
close(fd);
}
str_printf(&s, 0, "%s/edid1", sf_dev);
if((fd = open(s, O_RDONLY)) != -1) {
pci->edid_len = read(fd, pci->edid, sizeof pci->edid);
ADD2LOG(" edid[%u]\n", pci->edid_len);
if(pci->edid_len > 0) {
for(i = 0; i < sizeof pci->edid; i += 0x10) {
ADD2LOG(" ");
hexdump(&hd_data->log, 1, 0x10, pci->edid + i);
ADD2LOG("\n");
}
}
close(fd);
}
s = free_mem(s);
pci->rev = pci->data[PCI_REVISION_ID];
if((pci->addr_flags[6] & IORESOURCE_MEM)) {
if(!(pci->data[PCI_ROM_ADDRESS] & PCI_ROM_ADDRESS_ENABLE)) {
pci->addr_flags[6] |= IORESOURCE_DISABLED;
}
}
pci->flags |= (1 << pci_flag_ok);
free_mem(sf_dev);
}
void guess_modem_name(hd_data_t *hd_data, ser_device_t *modem)
{
ser_device_t *sm;
str_list_t *sl;
char *s;
#ifdef __PPC__
char *s1, *s2;
unsigned u;
#endif
for(sm = hd_data->ser_modem; sm; sm = sm->next) sm->do_io = 0;
(sm = modem)->do_io = 1;
#ifdef __PPC__
at_cmd(hd_data, "ATI0\r", 0, 1);
sl = sm->at_resp;
if(sl && !strcmp(sl->str, "ATI0")) sl = sl->next; /* skip AT cmd echo */
s1 = NULL;
if(sl) {
if(strstr(sl->str, "PowerBook")) {
sm->vend = new_str("Apple");
sm->user_name = new_str(sl->str);
return;
}
s1 = new_str(sl->str);
}
at_cmd(hd_data, "ATI1\r", 0, 1);
sl = sm->at_resp;
if(sl && !strcmp(sl->str, "ATI1")) sl = sl->next; /* skip AT cmd echo */
if(sl) {
if(strstr(sl->str, "APPLE")) {
sm->vend = new_str("Apple");
str_printf(&sm->user_name, 0, "AT Modem");
if(s1) {
u = strtoul(s1, &s2, 10);
if(u && !*s2 && !(u % 1000)) {
str_printf(&sm->user_name, 0, "%uk AT Modem", u / 1000);
}
}
s1 = free_mem(s1);
return;
}
}
s1 = free_mem(s1);
#endif
/* ATI3 command */
at_cmd(hd_data, "ATI3\r", 0, 1);
sl = sm->at_resp;
if(sl && !strcmp(sl->str, "ATI3")) sl = sl->next; /* skip AT cmd echo */
if(sl) {
if(*sl->str == 'U' && strstr(sl->str, "Robotics ")) {
/* looks like an U.S. Robotics... */
sm->vend = new_str("U.S. Robotics, Inc.");
/* strip revision code */
if((s = strstr(sl->str, " Rev. "))) *s = 0;
sm->user_name = canon_str(sl->str, strlen(sl->str));
return;
}
if(strstr(sl->str, "3Com U.S. Robotics ") == sl->str) {
/* looks like an 3Com U.S. Robotics... */
sm->vend = new_str("3Com U.S. Robotics, Inc.");
sm->user_name = canon_str(sl->str, strlen(sl->str));
return;
}
if(strstr(sl->str, "-V34_DS -d Z201 2836")) {
/* looks like a Zoom V34X */
sm->vend = new_str("Zoom Telephonics, Inc.");
sm->user_name = new_str("Zoom FaxModem V.34X Plus Model 2836");
return;
}
if(strstr(sl->str, "FM560 VER 3.01 V.90")) {
/* looks like a Microcom DeskPorte 56K Voice ... */
sm->vend = new_str("Microcom");
sm->user_name = new_str("TravelCard 56K");
return;
}
if(strstr(sl->str, "Compaq Microcom 550 56K Modem")) {
/* looks like a Microcom DeskPorte Pocket ... */
sm->vend = new_str("Compaq");
sm->user_name = new_str("Microcom 550 56K Modem");
return;
}
}
/* ATI0 command */
at_cmd(hd_data, "ATI0\r", 0, 1);
sl = sm->at_resp;
if(sl && !strcmp(sl->str, "ATI0")) sl = sl->next; /* skip AT cmd echo */
if(sl) {
if(strstr(sl->str, "DP Pocket")) {
/* looks like a Microcom DeskPorte Pocket ... */
sm->vend = new_str("Microcom");
sm->user_name = new_str("DeskPorte Pocket");
return;
}
}
/* ATI6 command */
at_cmd(hd_data, "ATI6\r", 0, 1);
sl = sm->at_resp;
if(sl && !strcmp(sl->str, "ATI6")) sl = sl->next; /* skip AT cmd echo */
if(sl) {
if(strstr(sl->str, "RCV56DPF-PLL L8571A")) {
/* looks like a Microcom DeskPorte 56K Voice ... */
sm->vend = new_str("Microcom");
sm->user_name = new_str("DeskPorte 56K Voice");
return;
}
}
/* ATI2 command */
at_cmd(hd_data, "ATI2\r", 0, 1);
sl = sm->at_resp;
if(sl && !strcmp(sl->str, "ATI2")) sl = sl->next; /* skip AT cmd echo */
if(sl) {
if(strstr(sl->str, "ZyXEL ")) {
/* looks like a ZyXEL... */
sm->vend = new_str("ZyXEL");
at_cmd(hd_data, "ATI1\r", 0, 1);
sl = sm->at_resp;
if(sl && !strcmp(sl->str, "ATI1")) sl = sl->next;
if(sl && sl->next) {
sl = sl->next;
if((s = strstr(sl->str, " V "))) *s = 0;
sm->user_name = canon_str(sl->str, strlen(sl->str));
}
return;
}
}
}
void hd_scan_net(hd_data_t *hd_data)
{
unsigned u;
int if_type, if_carrier;
hd_t *hd, *hd_card;
char *s, *t, *hw_addr;
hd_res_t *res, *res1, *res2;
uint64_t ul0;
str_list_t *sf_class, *sf_class_e;
char *sf_cdev = NULL, *sf_dev = NULL;
char *sf_drv_name, *sf_drv;
if(!hd_probe_feature(hd_data, pr_net)) return;
hd_data->module = mod_net;
/* some clean-up */
remove_hd_entries(hd_data);
hd_data->net = free_str_list(hd_data->net);
PROGRESS(1, 0, "get network data");
sf_class = read_dir("/sys/class/net", 'l');
if(!sf_class) sf_class = read_dir("/sys/class/net", 'd');
if(!sf_class) {
ADD2LOG("sysfs: no such class: net\n");
return;
}
for(sf_class_e = sf_class; sf_class_e; sf_class_e = sf_class_e->next) {
str_printf(&sf_cdev, 0, "/sys/class/net/%s", sf_class_e->str);
hd_card = NULL;
ADD2LOG(
" net interface: name = %s, path = %s\n",
sf_class_e->str,
hd_sysfs_id(sf_cdev)
);
if_type = -1;
if(hd_attr_uint(get_sysfs_attr_by_path(sf_cdev, "type"), &ul0, 0)) {
if_type = ul0;
ADD2LOG(" type = %d\n", if_type);
}
if_carrier = -1;
if(hd_attr_uint(get_sysfs_attr_by_path(sf_cdev, "carrier"), &ul0, 0)) {
if_carrier = ul0;
ADD2LOG(" carrier = %d\n", if_carrier);
}
hw_addr = NULL;
if((s = get_sysfs_attr_by_path(sf_cdev, "address"))) {
hw_addr = canon_str(s, strlen(s));
ADD2LOG(" hw_addr = %s\n", hw_addr);
}
sf_dev = new_str(hd_read_sysfs_link(sf_cdev, "device"));
if(sf_dev) {
ADD2LOG(" net device: path = %s\n", hd_sysfs_id(sf_dev));
}
sf_drv_name = NULL;
sf_drv = hd_read_sysfs_link(sf_dev, "driver");
if(sf_drv) {
sf_drv_name = strrchr(sf_drv, '/');
if(sf_drv_name) sf_drv_name++;
ADD2LOG(
" net driver: name = %s, path = %s\n",
sf_drv_name,
hd_sysfs_id(sf_drv)
);
}
hd = add_hd_entry(hd_data, __LINE__, 0);
hd->base_class.id = bc_network_interface;
hd->sub_class.id = sc_nif_other;
res1 = NULL;
if(hw_addr && strspn(hw_addr, "0:") != strlen(hw_addr)) {
res1 = new_mem(sizeof *res1);
res1->hwaddr.type = res_hwaddr;
res1->hwaddr.addr = new_str(hw_addr);
add_res_entry(&hd->res, res1);
}
res2 = NULL;
if(if_carrier >= 0) {
res = new_mem(sizeof *res);
res->link.type = res_link;
res->link.state = if_carrier ? 1 : 0;
add_res_entry(&hd->res, res);
}
hd->unix_dev_name = new_str(sf_class_e->str);
hd->sysfs_id = new_str(hd_sysfs_id(sf_cdev));
if(sf_drv_name) {
add_str_list(&hd->drivers, sf_drv_name);
}
else if(hd->res) {
get_driverinfo(hd_data, hd);
}
switch(if_type) {
case ARPHRD_ETHER: /* eth */
hd->sub_class.id = sc_nif_ethernet;
break;
case ARPHRD_LOOPBACK: /* lo */
hd->sub_class.id = sc_nif_loopback;
break;
case ARPHRD_SIT: /* sit */
hd->sub_class.id = sc_nif_sit;
break;
case ARPHRD_FDDI: /* fddi */
hd->sub_class.id = sc_nif_fddi;
break;
case ARPHRD_IEEE802_TR: /* tr */
hd->sub_class.id = sc_nif_tokenring;
break;
#if 0
case ARPHRD_IEEE802: /* fc */
hd->sub_class.id = sc_nif_fc;
break;
#endif
default:
hd->sub_class.id = sc_nif_other;
}
if(!strcmp(hd->unix_dev_name, "lo")) {
hd->sub_class.id = sc_nif_loopback;
}
else if(sscanf(hd->unix_dev_name, "eth%u", &u) == 1) {
hd->sub_class.id = sc_nif_ethernet;
hd->slot = u;
}
else if(sscanf(hd->unix_dev_name, "tr%u", &u) == 1) {
hd->sub_class.id = sc_nif_tokenring;
hd->slot = u;
}
else if(sscanf(hd->unix_dev_name, "fddi%u", &u) == 1) {
hd->sub_class.id = sc_nif_fddi;
hd->slot = u;
}
else if(sscanf(hd->unix_dev_name, "ctc%u", &u) == 1) {
hd->sub_class.id = sc_nif_ctc;
hd->slot = u;
}
else if(sscanf(hd->unix_dev_name, "iucv%u", &u) == 1) {
hd->sub_class.id = sc_nif_iucv;
hd->slot = u;
}
else if(sscanf(hd->unix_dev_name, "hsi%u", &u) == 1) {
hd->sub_class.id = sc_nif_hsi;
hd->slot = u;
}
else if(sscanf(hd->unix_dev_name, "qeth%u", &u) == 1) {
hd->sub_class.id = sc_nif_qeth;
hd->slot = u;
}
else if(sscanf(hd->unix_dev_name, "escon%u", &u) == 1) {
hd->sub_class.id = sc_nif_escon;
hd->slot = u;
}
else if(sscanf(hd->unix_dev_name, "myri%u", &u) == 1) {
hd->sub_class.id = sc_nif_myrinet;
hd->slot = u;
}
else if(sscanf(hd->unix_dev_name, "sit%u", &u) == 1) {
hd->sub_class.id = sc_nif_sit; /* ipv6 over ipv4 tunnel */
hd->slot = u;
}
else if(sscanf(hd->unix_dev_name, "wlan%u", &u) == 1) {
hd->sub_class.id = sc_nif_wlan;
hd->slot = u;
}
else if(sscanf(hd->unix_dev_name, "xp%u", &u) == 1) {
hd->sub_class.id = sc_nif_xp;
hd->slot = u;
}
else if(sscanf(hd->unix_dev_name, "usb%u", &u) == 1) {
hd->sub_class.id = sc_nif_usb;
hd->slot = u;
}
/* ##### add more interface names here */
else {
for(s = hd->unix_dev_name; *s; s++) if(isdigit(*s)) break;
if(*s && (u = strtoul(s, &s, 10), !*s)) {
hd->slot = u;
}
}
hd->bus.id = bus_none;
hd_card = NULL;
if(sf_dev) {
s = new_str(hd_sysfs_id(sf_dev));
hd->sysfs_device_link = new_str(s);
hd_card = hd_find_sysfs_id(hd_data, s);
// try one above, if not found
if(!hd_card) {
t = strrchr(s, '/');
if(t) {
*t = 0;
hd_card = hd_find_sysfs_id(hd_data, s);
}
}
/* if one card has several interfaces (as with PS3), check interface names, too */
if(
hd_card &&
hd_card->unix_dev_name &&
hd->unix_dev_name &&
strcmp(hd->unix_dev_name, hd_card->unix_dev_name)
) {
hd_card = hd_find_sysfs_id_devname(hd_data, s, hd->unix_dev_name);
}
s = free_mem(s);
if(hd_card) {
hd->attached_to = hd_card->idx;
/* for cards with strange pci classes */
hd_set_hw_class(hd_card, hw_network_ctrl);
/* add hw addr to network card */
if(res1) {
u = 0;
for(res = hd_card->res; res; res = res->next) {
if(
res->any.type == res_hwaddr &&
!strcmp(res->hwaddr.addr, res1->hwaddr.addr)
) {
u = 1;
break;
}
}
if(!u) {
res = new_mem(sizeof *res);
res->hwaddr.type = res_hwaddr;
res->hwaddr.addr = new_str(res1->hwaddr.addr);
add_res_entry(&hd_card->res, res);
}
}
/*
* add interface names...
* but not wmasterX (bnc #441778)
*/
if(if_type != 801) add_if_name(hd_card, hd);
}
}
if(!hd_card && hw_addr) {
/* try to find card based on hwaddr (for prom-based cards) */
for(hd_card = hd_data->hd; hd_card; hd_card = hd_card->next) {
if(
hd_card->base_class.id != bc_network ||
hd_card->sub_class.id != 0
) continue;
for(res = hd_card->res; res; res = res->next) {
if(
res->any.type == res_hwaddr &&
!strcmp(hw_addr, res->hwaddr.addr)
) break;
}
if(res) {
hd->attached_to = hd_card->idx;
break;
}
}
}
hw_addr = free_mem(hw_addr);
/* fix card type */
if(hd_card) {
if(
(hd_card->base_class.id == 0 && hd_card->sub_class.id == 0) ||
(hd_card->base_class.id == bc_network && hd_card->sub_class.id == 0x80)
) {
switch(hd->sub_class.id) {
case sc_nif_ethernet:
hd_card->base_class.id = bc_network;
hd_card->sub_class.id = 0;
break;
case sc_nif_usb:
hd_card->base_class.id = bc_network;
hd_card->sub_class.id = 0x91;
break;
}
}
}
sf_dev = free_mem(sf_dev);
}
sf_cdev = free_mem(sf_cdev);
sf_class = free_str_list(sf_class);
if(hd_is_sgi_altix(hd_data)) add_xpnet(hd_data);
add_uml(hd_data);
add_kma(hd_data);
/* add link status info & dump eeprom */
for(hd = hd_data->hd ; hd; hd = hd->next) {
if(
hd->module == hd_data->module &&
hd->base_class.id == bc_network_interface
) {
char *buf = NULL;
str_list_t *sl0, *sl;
if(hd_probe_feature(hd_data, pr_net_eeprom) && hd->unix_dev_name) {
PROGRESS(2, 0, "eeprom dump");
str_printf(&buf, 0, "|/usr/sbin/ethtool -e %s 2>/dev/null", hd->unix_dev_name);
if((sl0 = read_file(buf, 0, 0))) {
ADD2LOG("----- %s %s -----\n", hd->unix_dev_name, "EEPROM dump");
for(sl = sl0; sl; sl = sl->next) {
ADD2LOG("%s", sl->str);
}
ADD2LOG("----- %s end -----\n", "EEPROM dump");
free_str_list(sl0);
}
free(buf);
}
for(res = hd->res; res; res = res->next) {
if(res->any.type == res_link) break;
}
if(!res) get_linkstate(hd_data, hd);
if(!(hd_card = hd_get_device_by_idx(hd_data, hd->attached_to))) continue;
for(res = hd->res; res; res = res->next) {
if(res->any.type == res_link) break;
}
if(res) {
for(res1 = hd_card->res; res1; res1 = res1->next) {
if(res1->any.type == res_link) break;
}
if(res && !res1) {
res1 = new_mem(sizeof *res1);
res1->link.type = res_link;
res1->link.state = res->link.state;
add_res_entry(&hd_card->res, res1);
}
}
}
}
}
void get_input_devices(hd_data_t *hd_data)
{
hd_t *hd;
str_list_t *input, *sl, *sl1;
char *s;
unsigned ok, u, is_mouse, is_joystick;
unsigned bus, vendor, product, version;
unsigned mouse_buttons, mouse_wheels;
char *name = NULL, *handlers = NULL, *key = NULL, *rel = NULL, *abso = NULL;
size_t len;
str_list_t *handler_list;
hd_dev_num_t dev_num = { type: 'c', range: 1 };
input = read_file("/proc/bus/input/devices", 0, 0);
ADD2LOG("----- /proc/bus/input/devices -----\n");
for(sl = input; sl; sl = sl->next) {
ADD2LOG(" %s", sl->str);
}
ADD2LOG("----- /proc/bus/input/devices end -----\n");
for(ok = 0, sl = input; sl; sl = sl->next) {
if(*sl->str == '\n') {
ADD2LOG("bus = %u, name = %s\n", bus, name);
if(handlers) ADD2LOG(" handlers = %s\n", handlers);
if(key) ADD2LOG(" key = %s\n", key);
if(rel) ADD2LOG(" rel = %s\n", rel);
if(abso) ADD2LOG(" abs = %s\n", abso);
mouse_buttons = 0;
if(key) {
for(u = BTN_MOUSE; u < BTN_MOUSE + 8; u++) {
if(test_bit(key, u)) mouse_buttons++;
}
}
ADD2LOG(" mouse buttons = %u\n", mouse_buttons);
mouse_wheels = 0;
if(rel) {
for(u = REL_HWHEEL; u <= REL_MAX; u++) {
if(test_bit(rel, u)) mouse_wheels++;
}
}
ADD2LOG(" mouse wheels = %u\n", mouse_wheels);
if(ok && handlers) {
handler_list = hd_split(' ', handlers);
is_mouse = strstr(handlers, "mouse") ? 1 : 0;
is_joystick = strstr(handlers, "js") ? 1 : 0;
if( // HP Virtual Management Device
vendor == 0x03f0 &&
product == 0x1126 &&
mouse_buttons >= 3
) is_mouse = 1;
ADD2LOG(" is_mouse = %u\n", is_mouse);
ADD2LOG(" is_joystick = %u\n", is_joystick);
if(bus == BUS_USB) {
s = NULL;
for(sl1 = handler_list; sl1; sl1 = sl1->next) {
if(sscanf(sl1->str, "mouse%u", &u) == 1) {
str_printf(&s, 0, "/dev/input/mouse%u", u);
break;
}
}
if(!s && (is_mouse || is_joystick)) for(sl1 = handler_list; sl1; sl1 = sl1->next) {
if(sscanf(sl1->str, "event%u", &u) == 1) {
str_printf(&s, 0, "/dev/input/event%u", u);
break;
}
}
if(s) {
for(hd = hd_data->hd; hd; hd = hd->next) {
if(
(hd->unix_dev_name2 && !strcmp(hd->unix_dev_name2, s)) ||
(hd->unix_dev_name && !strcmp(hd->unix_dev_name, s))
) {
if(!hd->base_class.id) {
if (is_mouse)
{
hd->base_class.id = bc_mouse;
hd->sub_class.id = sc_mou_usb;
}
else if (is_joystick)
{
hd->base_class.id = bc_joystick;
}
}
if (is_mouse)
{
hd_set_hw_class(hd, hw_mouse);
hd->compat_vendor.id = MAKE_ID(TAG_SPECIAL, 0x0210);
hd->compat_device.id = MAKE_ID(TAG_SPECIAL, (mouse_wheels << 4) + mouse_buttons);
}
else if (is_joystick)
{
hd_set_hw_class(hd, hw_joystick);
/* add buttons and axis details */
add_joystick_details(hd_data, hd, key, abso);
}
if(hd->unix_dev_name) add_str_list(&hd->unix_dev_names, hd->unix_dev_name);
if(hd->unix_dev_name2) add_str_list(&hd->unix_dev_names, hd->unix_dev_name2);
for(sl1 = handler_list; sl1; sl1 = sl1->next) {
if(sscanf(sl1->str, "event%u", &u) == 1) {
str_printf(&s, 0, "/dev/input/event%u", u);
if(!search_str_list(hd->unix_dev_names, s)) add_str_list(&hd->unix_dev_names, s);
s = free_mem(s);
}
/* add /dev/input/jsN joystick device name */
else if (is_joystick)
{
if(sscanf(sl1->str, "js%u", &u) == 1) {
str_printf(&s, 0, "/dev/input/js%u", u);
if(!search_str_list(hd->unix_dev_names, s)) add_str_list(&hd->unix_dev_names, s);
if(!hd->unix_dev_name2) hd->unix_dev_name2 = new_str(s);
s = free_mem(s);
}
}
}
break;
}
}
}
s = free_mem(s);
}
else {
// keyboard
if(search_str_list(handler_list, "kbd") && test_bit(key, KEY_1)) {
hd = add_hd_entry(hd_data, __LINE__, 0);
hd->base_class.id = bc_keyboard;
hd->sub_class.id = sc_keyboard_kbd;
hd->bus.id = bus_ps2;
hd->vendor.id = MAKE_ID(0, vendor);
hd->device.id = MAKE_ID(0, product);
hd->compat_vendor.id = MAKE_ID(TAG_SPECIAL, 0x0211);
hd->compat_device.id = MAKE_ID(TAG_SPECIAL, 0x0001);
hd->device.name = new_str(name);
for(sl1 = handler_list; sl1; sl1 = sl1->next) {
if(sscanf(sl1->str, "event%u", &u) == 1) {
str_printf(&hd->unix_dev_name, 0, "/dev/input/event%u", u);
dev_num.major = 13;
dev_num.minor = 64 + u;
hd->unix_dev_num = dev_num;
break;
}
}
}
// mouse
else if(is_mouse) {
hd = add_hd_entry(hd_data, __LINE__, 0);
hd->vendor.id = MAKE_ID(0, vendor);
hd->device.id = MAKE_ID(0, product);
hd->compat_vendor.id = MAKE_ID(TAG_SPECIAL, 0x0210);
hd->compat_device.id = MAKE_ID(TAG_SPECIAL, (mouse_wheels << 4) + mouse_buttons);
hd->base_class.id = bc_mouse;
if(bus == BUS_ADB) {
hd->sub_class.id = sc_mou_bus;
hd->bus.id = bus_adb;
}
else {
hd->sub_class.id = sc_mou_ps2;
hd->bus.id = bus_ps2;
}
hd->device.name = new_str(name);
#if 0
/* Synaptics/Alps TouchPad */
if(
vendor == 2 &&
(product == 7 || product == 8) &&
test_bit(abso, ABS_X) &&
test_bit(abso, ABS_Y) &&
test_bit(abso, ABS_PRESSURE) &&
test_bit(key, BTN_TOOL_FINGER)
) {
}
#endif
hd->unix_dev_name = new_str(DEV_MICE);
dev_num.major = 13;
dev_num.minor = 63;
hd->unix_dev_num = dev_num;
for(sl1 = handler_list; sl1; sl1 = sl1->next) {
if(sscanf(sl1->str, "mouse%u", &u) == 1) {
str_printf(&hd->unix_dev_name2, 0, "/dev/input/mouse%u", u);
dev_num.major = 13;
dev_num.minor = 32 + u;
hd->unix_dev_num2 = dev_num;
break;
}
}
add_str_list(&hd->unix_dev_names, hd->unix_dev_name);
add_str_list(&hd->unix_dev_names, hd->unix_dev_name2);
for(sl1 = handler_list; sl1; sl1 = sl1->next) {
if(sscanf(sl1->str, "event%u", &u) == 1) {
s = NULL;
str_printf(&s, 0, "/dev/input/event%u", u);
add_str_list(&hd->unix_dev_names, s);
s = free_mem(s);
break;
}
}
}
// joystick
else if(is_joystick) {
hd = add_hd_entry(hd_data, __LINE__, 0);
hd->vendor.id = MAKE_ID(0, vendor);
hd->device.id = MAKE_ID(0, product);
hd_set_hw_class(hd, hw_joystick);
hd->base_class.id = bc_joystick;
hd->device.name = new_str(name);
// gameport? (see <linux/input.h>)
if (bus == BUS_GAMEPORT) hd->bus.id = bus_gameport;
/* add buttons and axis details */
add_joystick_details(hd_data, hd, key, abso);
// add eventX device
for(sl1 = handler_list; sl1; sl1 = sl1->next) {
if(sscanf(sl1->str, "event%u", &u) == 1) {
str_printf(&hd->unix_dev_name, 0, "/dev/input/event%u", u);
dev_num.major = 13;
dev_num.minor = 64 + u;
hd->unix_dev_num = dev_num;
break;
}
}
// add jsX device
for(sl1 = handler_list; sl1; sl1 = sl1->next) {
if(sscanf(sl1->str, "js%u", &u) == 1) {
str_printf(&hd->unix_dev_name2, 0, "/dev/input/js%u", u);
break;
}
}
add_str_list(&hd->unix_dev_names, hd->unix_dev_name);
add_str_list(&hd->unix_dev_names, hd->unix_dev_name2);
}
else
{
ADD2LOG("unknown non-USB input device\n");
}
}
handler_list = free_str_list(handler_list);
}
ok = 0;
name = free_mem(name);
handlers = free_mem(handlers);
key = free_mem(key);
rel = free_mem(rel);
abso = free_mem(abso);
}
if(sscanf(sl->str, "I: Bus=%04x Vendor=%04x Product=%04x Version=%04x", &bus, &vendor, &product, &version) == 4) {
ok = 1;
continue;
}
if(!strncmp(sl->str, INP_NAME, sizeof INP_NAME - 1)) {
s = sl->str + sizeof INP_NAME;
len = strlen(s);
if(len > 2) {
name = canon_str(s, len - 2);
}
continue;
}
if(!strncmp(sl->str, INP_HANDLERS, sizeof INP_HANDLERS - 1)) {
s = sl->str + sizeof INP_HANDLERS - 1;
handlers = canon_str(s, strlen(s));
continue;
}
if(!strncmp(sl->str, INP_KEY, sizeof INP_KEY - 1)) {
s = sl->str + sizeof INP_KEY - 1;
key = canon_str(s, strlen(s));
key = all_bits(key);
continue;
}
if(!strncmp(sl->str, INP_REL, sizeof INP_REL - 1)) {
s = sl->str + sizeof INP_REL - 1;
rel = canon_str(s, strlen(s));
rel = all_bits(rel);
continue;
}
if(!strncmp(sl->str, INP_ABS, sizeof INP_ABS - 1)) {
s = sl->str + sizeof INP_ABS - 1;
abso = canon_str(s, strlen(s));
abso = all_bits(abso);
continue;
}
}
free_str_list(input);
}
char *all_bits(char *str)
{
str_list_t *sl, *sl0;
char *s = NULL;
unsigned long u;
if(!str) return NULL;
sl = sl0 = hd_split(' ', str);
for(; sl; sl = sl->next) {
u = strtoul(sl->str, NULL, 16);
str_printf(&s, -1, "%0*lx", (int) sizeof (unsigned long) * 2, u);
}
free_str_list(sl0);
free_mem(str);
return s;
}
void pcmcia_read_data(hd_data_t *hd_data)
{
hd_t *hd, *hd2;
unsigned u0, u1, func_id;
uint64_t ul0;
char *s, *t;
char *prod1, *prod2, *prod3, *prod4;
str_list_t *sl;
str_list_t *sf_bus, *sf_bus_e;
char *sf_dev;
sf_bus = reverse_str_list(read_dir("/sys/bus/pcmcia/devices", 'l'));
if(!sf_bus) {
ADD2LOG("sysfs: no such bus: pcmcia\n");
return;
}
for(sf_bus_e = sf_bus; sf_bus_e; sf_bus_e = sf_bus_e->next) {
sf_dev = new_str(hd_read_sysfs_link("/sys/bus/pcmcia/devices", sf_bus_e->str));
ADD2LOG(
" pcmcia device: name = %s\n path = %s\n",
sf_bus_e->str,
hd_sysfs_id(sf_dev)
);
if(sscanf(sf_bus_e->str, "%x.%x", &u0, &u1) != 2) continue;
hd = add_hd_entry(hd_data, __LINE__, 0);
hd->sysfs_id = new_str(hd_sysfs_id(sf_dev));
hd->sysfs_bus_id = new_str(sf_bus_e->str);
hd->bus.id = bus_pcmcia;
hd->slot = u0;
hd->func = u1;
hd->hotplug_slot = u0 + 1;
hd->hotplug = hp_pcmcia;
s = hd_sysfs_find_driver(hd_data, hd->sysfs_id, 1);
if(s) add_str_list(&hd->drivers, s);
if((s = get_sysfs_attr_by_path(sf_dev, "modalias"))) {
hd->modalias = canon_str(s, strlen(s));
ADD2LOG(" modalias = \"%s\"\n", s);
}
if(hd_attr_uint(get_sysfs_attr_by_path(sf_dev, "manf_id"), &ul0, 0)) {
ADD2LOG(" manf_id = 0x%04x\n", (unsigned) ul0);
hd->vendor.id = MAKE_ID(TAG_PCMCIA, ul0);
}
if(hd_attr_uint(get_sysfs_attr_by_path(sf_dev, "card_id"), &ul0, 0)) {
ADD2LOG(" card_id = 0x%04x\n", (unsigned) ul0);
hd->device.id = MAKE_ID(TAG_PCMCIA, ul0);
}
/*
* "multifunction", "memory", "serial", "parallel",
* "fixed disk", "video", "network", "AIMS",
* "SCSI"
*/
func_id = 0;
if(hd_attr_uint(get_sysfs_attr_by_path(sf_dev, "func_id"), &ul0, 0)) {
func_id = ul0;
ADD2LOG(" func_id = 0x%04x\n", func_id);
}
prod1 = NULL;
if((s = get_sysfs_attr_by_path(sf_dev, "prod_id1"))) {
prod1 = canon_str(s, strlen(s));
ADD2LOG(" prod_id1 = \"%s\"\n", prod1);
}
prod2 = NULL;
if((s = get_sysfs_attr_by_path(sf_dev, "prod_id2"))) {
prod2 = canon_str(s, strlen(s));
ADD2LOG(" prod_id2 = \"%s\"\n", prod2);
}
prod3 = NULL;
if((s = get_sysfs_attr_by_path(sf_dev, "prod_id3"))) {
prod3 = canon_str(s, strlen(s));
ADD2LOG(" prod_id3 = \"%s\"\n", prod3);
}
prod4 = NULL;
if((s = get_sysfs_attr_by_path(sf_dev, "prod_id4"))) {
prod4 = canon_str(s, strlen(s));
ADD2LOG(" prod_id4 = \"%s\"\n", prod4);
}
if(func_id == 6) {
hd->base_class.id = bc_network;
hd->sub_class.id = 0x80; /* other */
}
if(prod1 && *prod1) {
add_str_list(&hd->extra_info, prod1);
hd->vendor.name = prod1;
prod1 = NULL;
}
if(prod2 && *prod2) {
add_str_list(&hd->extra_info, prod2);
hd->device.name = prod2;
prod2 = NULL;
}
if(prod3 && *prod3) add_str_list(&hd->extra_info, prod3);
if(prod4 && *prod4) add_str_list(&hd->extra_info, prod4);
for(sl = hd->extra_info; sl ; sl = sl->next) {
if(strstr(sl->str, "Ethernet")) hd->sub_class.id = 0; /* ethernet */
if(
!hd->revision.name &&
!sl->next &&
(
!strncasecmp(sl->str, "rev.", sizeof "rev." - 1) ||
(
(sl->str[0] == 'V' || sl->str[0] == 'v') &&
(sl->str[1] >= '0' && sl->str[1] <= '9')
)
)
) {
hd->revision.name = new_str(sl->str);
}
}
prod1 = free_mem(prod1);
prod2 = free_mem(prod2);
prod3 = free_mem(prod3);
prod4 = free_mem(prod4);
s = new_str(hd->sysfs_id);
if((t = strrchr(s, '/'))) {
*t = 0;
if((hd2 = hd_find_sysfs_id(hd_data, s))) {
hd->attached_to = hd2->idx;
}
}
free_mem(s);
free_mem(sf_dev);
}
free_str_list(sf_bus);
}