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;
}
