void
print_devs()
{
I32 i;
U32 pci_id;
if ( pdevs[0].devven_id != 0xFFFFFFFF)
printf("PCI Devices Found :\n\r");
else
printf("PCI Devices not Found :\n\r");
i = 0;
while(pdevs[i].devven_id != 0xFFFFFFFF) {
pci_id = pdevs[i].pci_id;
if ( get_devname(pdevs[i].devven_id))
printf(get_devname(pdevs[i].devven_id));
else {
printf("%08X ", (pdevs[i].devven_id));
}
printf(": pciid :%X, Bus :%x, Idsel :%x", pci_id, PCI_GET_BUS(pci_id),
PCI_GET_DEV(pci_id));
if ( pdevs[i].devven_id == 0x00261011 ) {
printf(", SBus :%x, SubBus :%x",
pciconf_readb(pci_id, PCI_BCONF_SECBUS),
pciconf_readb(pci_id, PCI_BCONF_SUBBUS));
}
printf("\n\r");
i++;
}
}
static void
packet_cb(omphalos_packet *op){
// We won't have l2s/l2d on critically malformed frames, or UI-driving
// frames (clock ticks, interface events, etc).
if(op->l2s && op->l2d){
const wchar_t *ns = NULL,*nd = NULL;
//ns = get_name(op->l2s);
ns = ns ? ns : get_devname(op->l2s);
//nd = get_name(op->l2d);
nd = nd ? nd : get_devname(op->l2d);
//printf("[%s] %s -> %s %04hx\n",op->i->name,ns,nd,op->l3proto);
}
}
struct offsets* get_offsets()
{
char* devname = calloc(1, DEVNAME_LEN);
char* kernelver = calloc(1, KERNELVER_LEN);
unsigned int i;
struct offsets* o = NULL;
if(!get_devname(devname))
goto end;
if(!get_kernelver(kernelver))
goto end;
for(i = 0; i < ARRAYELEMS(offsets); i++)
{
if(strcmp(devname, offsets[i].devname))
continue;
if(strcmp(kernelver, offsets[i].kernelver))
continue;
o = &offsets[i];
break;
}
end:
if(o == NULL)
printf("Error: Device not supported\n");
free(devname);
free(kernelver);
return o;
}
int
I2C::init()
{
int ret = PX4_OK;
// Assume the driver set the desired bus frequency. There is no standard
// way to set it from user space.
// do base class init, which will create device node, etc
ret = VDev::init();
if (ret != PX4_OK) {
DEVICE_DEBUG("VDev::init failed");
return ret;
}
_fd = px4_open(get_devname(), PX4_F_RDONLY | PX4_F_WRONLY);
if (_fd < 0) {
DEVICE_DEBUG("px4_open failed of device %s", get_devname());
return PX4_ERROR;
}
#ifdef __PX4_QURT
simulate = true;
#endif
if (simulate) {
_fd = 10000;
}
else {
#ifndef __PX4_QURT
// Open the actual I2C device and map to the virtual dev name
_fd = ::open(get_devname(), O_RDWR);
if (_fd < 0) {
warnx("could not open %s", get_devname());
px4_errno = errno;
return PX4_ERROR;
}
#endif
}
return ret;
}
BAROSIM::~BAROSIM()
{
/* make sure we are truly inactive */
stop_cycle();
if (_class_instance != -1) {
unregister_class_devname(get_devname(), _class_instance);
}
/* free any existing reports */
if (_reports != nullptr) {
delete _reports;
}
// free perf counters
perf_free(_sample_perf);
perf_free(_measure_perf);
perf_free(_comms_errors);
perf_free(_buffer_overflows);
delete _interface;
}
int
I2C::transfer(struct i2c_msg *msgv, unsigned msgs)
{
#ifndef __PX4_LINUX
return 1;
#else
struct i2c_rdwr_ioctl_data packets;
int ret;
unsigned retry_count = 0;
/* force the device address into the message vector */
for (unsigned i = 0; i < msgs; i++)
msgv[i].addr = _address;
do {
packets.msgs = msgv;
packets.nmsgs = msgs;
if (simulate) {
warnx("I2C SIM: transfer_2 on %s", get_devname());
ret = PX4_OK;
}
else {
ret = ::ioctl(_fd, I2C_RDWR, (unsigned long)&packets);
}
if (ret < 0) {
warnx("I2C transfer failed");
return 1;
}
/* success */
if (ret == PX4_OK)
break;
} while (retry_count++ < _retries);
return ret;
#endif
}
const char *LidarLiteI2C::get_dev_name()
{
return get_devname();
}
char *
obj2devname(uint32_t tag, set_t setno, md_dev64_t dev)
{
char *setname;
char *uname;
char name[MD_MAX_CTDLEN];
mdsetname_t *sp;
md_error_t status = mdnullerror;
md_set_record *md_sr;
minor_t mnum = meta_getminor(dev);
int rtn = 0;
setname = NULL;
if ((setno != MD_SET_BAD) &&
((sp = metasetnosetname(setno, &status)) != NULL)) {
setname = sp->setname;
}
name[0] = '\0';
switch (tag) {
case SVM_TAG_HS:
case SVM_TAG_METADEVICE:
case SVM_TAG_MIRROR:
case SVM_TAG_RAID5:
case SVM_TAG_STRIPE:
case SVM_TAG_TRANS:
uname = get_mdname(sp, mnum);
if (uname == NULL)
return (NULL);
(void) strcpy(name, uname);
break;
case SVM_TAG_HSP:
uname = get_hspname(sp, mnum);
if (uname == NULL)
return (NULL);
(void) strcpy(name, uname);
break;
case SVM_TAG_DRIVE:
(void) sprintf(name, "drive");
break;
case SVM_TAG_HOST:
md_sr = NULL;
if (setname != NULL) {
md_sr = getsetbyname(setname, &status);
}
if ((md_sr != NULL) && (md_sr->sr_nodes[mnum] != NULL)) {
/*
* Get the host data from the node array.
*/
rtn = snprintf(name, sizeof (name), "%s",
md_sr->sr_nodes[mnum]);
}
if ((name[0] == '\0') || (rtn >= sizeof (name))) {
(void) sprintf(name, "host");
rtn = 0;
}
break;
case SVM_TAG_SET:
if (setname == NULL) {
(void) sprintf(name, "diskset");
} else {
rtn = snprintf(name, sizeof (name), "%s", setname);
}
break;
default:
if ((setname = get_devname(setno, dev)) != NULL) {
rtn = snprintf(name, sizeof (name), "%s", setname);
}
break;
}
mdclrerror(&status);
/* Check if we got any rubbish for any of the snprintf's */
if ((name[0] == '\0') || (rtn >= sizeof (name))) {
return (NULL);
}
return (strdup(name));
}
