bool open_stream(std::string const & input_device, unsigned int inchans, std::string const & output_device, unsigned int outchans, unsigned int samplerate, unsigned int pa_blocksize, unsigned int blocksize) { int input_device_index, output_device_index; if (!match_device(input_device, input_device_index) || !match_device(output_device, output_device_index)) return false; PaStreamParameters in_parameters, out_parameters; if (inchans) { in_parameters.channelCount = inchans; in_parameters.device = input_device_index; in_parameters.sampleFormat = paFloat32 | paNonInterleaved; in_parameters.suggestedLatency = Pa_GetDeviceInfo(in_parameters.device)->defaultLowInputLatency; in_parameters.hostApiSpecificStreamInfo = NULL; } if (outchans) { out_parameters.channelCount = outchans; out_parameters.device = output_device_index; out_parameters.sampleFormat = paFloat32 | paNonInterleaved; out_parameters.suggestedLatency = Pa_GetDeviceInfo(out_parameters.device)->defaultLowOutputLatency; out_parameters.hostApiSpecificStreamInfo = NULL; } PaStreamParameters * in_stream_parameters = inchans ? &in_parameters : NULL; PaStreamParameters * out_stream_parameters = outchans ? &out_parameters : NULL; PaError supported = Pa_IsFormatSupported(in_stream_parameters, out_stream_parameters, samplerate); report_error(supported); if (supported != 0) return false; callback_initialized = false; blocksize_ = blocksize; PaError opened = Pa_OpenStream(&stream, in_stream_parameters, out_stream_parameters, samplerate, pa_blocksize, paNoFlag, &portaudio_backend::pa_process, this); report_error(opened); if (opened != paNoError) return false; input_channels = inchans; super::input_samples.resize(inchans); output_channels = outchans; super::output_samples.resize(outchans); samplerate_ = samplerate; return true; }
static int find_devices(struct device_info *devinfo, size_t size) { struct usb_bus *bus; struct usb_device *dev; struct device_id *id; unsigned int count = 0; usb_find_busses(); usb_find_devices(); for (bus = usb_get_busses(); bus; bus = bus->next) for (dev = bus->devices; dev; dev = dev->next) { id = match_device(dev->descriptor.idVendor, dev->descriptor.idProduct); if (!id) continue; if (count < size) { devinfo[count].dev = dev; devinfo[count].id = id; count++; } } return count; }
static struct usb_device *match_device(struct usb_device *dev, u16 vendor_id, u16 product_id) { struct usb_device *ret_dev = NULL; int child; dev_dbg(&dev->dev, "check for vendor %04x, product %04x ...\n", le16_to_cpu(dev->descriptor.idVendor), le16_to_cpu(dev->descriptor.idProduct)); /* see if this device matches */ if ((vendor_id == le16_to_cpu(dev->descriptor.idVendor)) && (product_id == le16_to_cpu(dev->descriptor.idProduct))) { dev_dbg(&dev->dev, "matched this device!\n"); ret_dev = usb_get_dev(dev); goto exit; } /* look through all of the children of this device */ for (child = 0; child < dev->maxchild; ++child) { if (dev->children[child]) { usb_lock_device(dev->children[child]); ret_dev = match_device(dev->children[child], vendor_id, product_id); usb_unlock_device(dev->children[child]); if (ret_dev) goto exit; } } exit: return ret_dev; }
static int pnp_bus_match(struct device *dev, struct device_driver *drv) { struct pnp_dev * pnp_dev = to_pnp_dev(dev); struct pnp_driver * pnp_drv = to_pnp_driver(drv); if (match_device(pnp_drv, pnp_dev) == NULL) return 0; return 1; }
error context::update_list() { std::unique_lock<std::recursive_mutex> lock(m_mutex); /* fetch new list */ std::vector<ctx_dev_t> new_list; void* ptr; error err = fetch_device_list(new_list, ptr); if(err != error::SUCCESS) return err; /* determine devices that have left */ std::vector<std::shared_ptr<device>> to_del; for(auto dev : m_devlist) { bool still_there = false; for(auto new_dev : new_list) if(match_device(new_dev, dev)) still_there = true; if(!still_there) to_del.push_back(dev); } for(auto dev : to_del) change_device(false, dev); /* determine new devices */ std::vector<ctx_dev_t> to_add; for(auto new_dev : new_list) { bool exists = false; for(auto dev : m_devlist) if(match_device(new_dev, dev)) exists = true; if(!exists) to_add.push_back(new_dev); } /* create new devices */ for(auto dev : to_add) { std::shared_ptr<device> new_dev; err = create_device(dev, new_dev); if(err == error::SUCCESS) change_device(true, new_dev); } /* destroy list */ destroy_device_list(ptr); return error::SUCCESS; }
int xenbus_match(struct device *_dev, struct device_driver *_drv) { struct xenbus_driver *drv = to_xenbus_driver(_drv); if (!drv->ids) return 0; return match_device(drv->ids, to_xenbus_device(_dev)) != NULL; }
static int match_and_count(struct device * dev, void * data) { struct match_count * m = data; struct parisc_device * pdev = to_parisc_device(dev); if (check_dev(dev)) { if (match_device(m->driver, pdev)) m->count++; } return 0; }
int xenbus_dev_probe(struct device *_dev) { struct xenbus_device *dev = to_xenbus_device(_dev); struct xenbus_driver *drv = to_xenbus_driver(_dev->driver); const struct xenbus_device_id *id; int err; DPRINTK("%s", dev->nodename); if (!drv->probe) { err = -ENODEV; goto fail; } id = match_device(drv->ids, dev); if (!id) { err = -ENODEV; goto fail; } err = talk_to_otherend(dev); if (err) { dev_warn(&dev->dev, "xenbus_probe: talk_to_otherend on %s failed.\n", dev->nodename); return err; } err = drv->probe(dev, id); if (err) goto fail; err = watch_otherend(dev); if (err) { dev_warn(&dev->dev, "xenbus_probe: watch_otherend on %s failed.\n", dev->nodename); return err; } return 0; fail: xenbus_dev_error(dev, err, "xenbus_dev_probe on %s", dev->nodename); xenbus_switch_state(dev, XenbusStateClosed); #if defined(CONFIG_XEN) || defined(MODULE) return -ENODEV; #else return err; #endif }
static int xenbus_dev_probe(struct device *_dev) { struct xenbus_device *dev = to_xenbus_device(_dev); struct xenbus_driver *drv = to_xenbus_driver(_dev->driver); const struct xenbus_device_id *id; int err; DPRINTK("%s", dev->nodename); if (!drv->probe) { err = -ENODEV; goto fail; } id = match_device(drv->ids, dev); if (!id) { err = -ENODEV; goto fail; } err = talk_to_otherend(dev); if (err) { printk(KERN_WARNING "xenbus_probe: talk_to_otherend on %s failed.\n", dev->nodename); return err; } err = drv->probe(dev, id); if (err) goto fail; err = watch_otherend(dev); if (err) { printk(KERN_WARNING "xenbus_probe: watch_otherend on %s failed.\n", dev->nodename); return err; } return 0; fail: xenbus_dev_error(dev, err, "xenbus_dev_probe on %s", dev->nodename); xenbus_switch_state(dev, XenbusStateClosed); return -ENODEV; }
static int pnp_device_probe(struct device *dev) { int error; struct pnp_driver *pnp_drv; struct pnp_dev *pnp_dev; const struct pnp_device_id *dev_id = NULL; pnp_dev = to_pnp_dev(dev); pnp_drv = to_pnp_driver(dev->driver); pnp_dbg("match found with the PnP device '%s' and the driver '%s'", dev->bus_id, pnp_drv->name); error = pnp_device_attach(pnp_dev); if (error < 0) return error; if (pnp_dev->active == 0) { if (!(pnp_drv->flags & PNP_DRIVER_RES_DO_NOT_CHANGE)) { error = pnp_activate_dev(pnp_dev); if (error < 0) return error; } } else if ((pnp_drv->flags & PNP_DRIVER_RES_DISABLE) == PNP_DRIVER_RES_DISABLE) { error = pnp_disable_dev(pnp_dev); if (error < 0) return error; } error = 0; if (pnp_drv->probe) { dev_id = match_device(pnp_drv, pnp_dev); if (dev_id != NULL) error = pnp_drv->probe(pnp_dev, dev_id); } if (error >= 0) { pnp_dev->driver = pnp_drv; error = 0; } else goto fail; return error; fail: pnp_device_detach(pnp_dev); return error; }
/** * usb_find_device - find a specific usb device in the system * @vendor_id: the vendor id of the device to find * @product_id: the product id of the device to find * * Returns a pointer to a struct usb_device if such a specified usb * device is present in the system currently. The usage count of the * device will be incremented if a device is found. Make sure to call * usb_put_dev() when the caller is finished with the device. * * If a device with the specified vendor and product id is not found, * NULL is returned. */ struct usb_device *usb_find_device(u16 vendor_id, u16 product_id) { struct list_head *buslist; struct usb_bus *bus; struct usb_device *dev = NULL; mutex_lock(&usb_bus_list_lock); for (buslist = usb_bus_list.next; buslist != &usb_bus_list; buslist = buslist->next) { bus = container_of(buslist, struct usb_bus, bus_list); if (!bus->root_hub) continue; usb_lock_device(bus->root_hub); dev = match_device(bus->root_hub, vendor_id, product_id); usb_unlock_device(bus->root_hub); if (dev) goto exit; } exit: mutex_unlock(&usb_bus_list_lock); return dev; }