static void set_inactive_by_usb_device(GtkWidget *widget, gpointer user_data)
{
if (get_usb_device(widget) == user_data) {
GtkWidget *check = gtk_bin_get_child(GTK_BIN(widget));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check), FALSE);
}
}
/* USB::Device#usb_open */
static VALUE
rusb_device_open(VALUE vdevice)
{
struct usb_device *device = get_usb_device(vdevice);
usb_dev_handle *h = usb_open(device);
return rusb_dev_handle_new(h);
}
static void check_can_redirect(GtkWidget *widget, gpointer user_data)
{
SpiceUsbDeviceWidget *self = SPICE_USB_DEVICE_WIDGET(user_data);
SpiceUsbDeviceWidgetPrivate *priv = self->priv;
SpiceUsbDevice *device;
gboolean can_redirect;
GError *err = NULL;
device = get_usb_device(widget);
if (!device)
return; /* Non device widget, ie the info_bar */
can_redirect = spice_usb_device_manager_can_redirect_device(priv->manager,
device, &err);
gtk_widget_set_sensitive(widget, can_redirect);
/* If we can not redirect this device, append the error message to
err_msg, but only if it is *not* already there! */
if (!can_redirect) {
if (priv->err_msg) {
if (!strstr(priv->err_msg, err->message)) {
gchar *old_err_msg = priv->err_msg;
priv->err_msg = g_strdup_printf("%s\n%s", priv->err_msg,
err->message);
g_free(old_err_msg);
}
} else {
priv->err_msg = g_strdup(err->message);
}
}
g_clear_error(&err);
}
/* USB::Device#configurations */
static VALUE
rusb_device_config(VALUE v)
{
struct usb_device *device = get_usb_device(v);
int i;
VALUE children = rb_ary_new2(device->descriptor.bNumConfigurations);
for (i = 0; i < device->descriptor.bNumConfigurations; i++)
rb_ary_store(children, i, rusb_config_descriptor_make(&device->config[i], v));
return children;
}
/* USB::Device#descriptor_bDeviceProtocol */
static VALUE rusb_devdesc_bDeviceProtocol(VALUE v) { return INT2FIX(get_usb_device(v)->descriptor.bDeviceProtocol); }
/* USB::Device#descriptor_bNumConfigurations */
static VALUE rusb_devdesc_bNumConfigurations(VALUE v) { return INT2FIX(get_usb_device(v)->descriptor.bNumConfigurations); }
/* USB::Device#descriptor_iProduct */
static VALUE rusb_devdesc_iProduct(VALUE v) { return INT2FIX(get_usb_device(v)->descriptor.iProduct); }
/* USB::Device#descriptor_iSerialNumber */
static VALUE rusb_devdesc_iSerialNumber(VALUE v) { return INT2FIX(get_usb_device(v)->descriptor.iSerialNumber); }
/* USB::Device#descriptor_bcdDevice */
static VALUE rusb_devdesc_bcdDevice(VALUE v) { return INT2FIX(get_usb_device(v)->descriptor.bcdDevice); }
/* USB::Device#descriptor_iManufacturer */
static VALUE rusb_devdesc_iManufacturer(VALUE v) { return INT2FIX(get_usb_device(v)->descriptor.iManufacturer); }
static void destroy_widget_by_usb_device(GtkWidget *widget, gpointer user_data)
{
if (get_usb_device(widget) == user_data)
gtk_widget_destroy(widget);
}
/* USB::Device#descriptor_idVendor */
static VALUE rusb_devdesc_idVendor(VALUE v) { return INT2FIX(get_usb_device(v)->descriptor.idVendor); }
/* USB::Device#descriptor_bDeviceSubClass */
static VALUE rusb_devdesc_bDeviceSubClass(VALUE v) { return INT2FIX(get_usb_device(v)->descriptor.bDeviceSubClass); }
static void smdhsic_disconnect(struct usb_interface *intf)
{
int devid;
struct usb_interface *smd_intf;
struct str_intf_priv *intfpriv;
struct usb_device *device = NULL;
pr_info("%s: Called\n", __func__);
intfpriv = usb_get_intfdata(intf);
if (!intfpriv) {
pr_err("%s: intfpriv is NULL\n", __func__);
goto err_get_intfdata;
}
device = get_usb_device(intfpriv);
devid = GET_DEVID(intfpriv->devid);
pr_debug("%s : devid : %d\n", __func__, devid);
smd_intf = get_usb_intf(intfpriv);
if (!smd_intf) {
pr_err("smd_intf is NULL\n");
goto err_get_usb_intf;
}
if (smd_intf != intf) {
pr_err("smd_intf is not same intf\n");
goto err_mismatched_intf;
}
usb_driver_release_interface(get_usb_driver(intf), smd_intf);
if (!device)
usb_put_dev(device);
switch (devid) {
case FMT_DEV_ID:
pm_runtime_disable(&device->dev);
if (g_usbdev.hsic)
cancel_delayed_work(&g_usbdev.hsic->pm_runtime_work);
smdctl_request_connection_recover(true);
case RAW_DEV_ID:
case RFS_DEV_ID:
case CMD_DEV_ID:
case DOWN_DEV_ID:
if (emu_discon_func[devid])
emu_discon_func[devid](g_usbdev.smd_device[devid]);
else
kfree(intfpriv->data);
break;
default:
pr_warn("%s:Undefined Callback Function\n",
__func__);
}
/* Power on/off kernel-panic workaround,
* if USB suspend cmd was queued in power.work before disconnect,
* reset the runtime PM request value to PM_REQ_NONE
*/
device->dev.power.request = RPM_REQ_NONE;
kfree(intfpriv);
usb_set_intfdata(intf, NULL);
g_usbdev.usbdev = NULL;
g_usbdev.suspended = 0;
g_usbdev.hsic = NULL;
return;
err_mismatched_intf:
err_get_usb_intf:
if (device)
usb_put_dev(device);
err_get_intfdata:
pr_err("release(2) : %p\n", intf);
usb_driver_release_interface(get_usb_driver(intf), intf);
return;
}
/* USB::Device#descriptor_bLength */
static VALUE rusb_devdesc_bLength(VALUE v) { return INT2FIX(get_usb_device(v)->descriptor.bLength); }
/* USB::Device#num_children */
static VALUE rusb_device_num_children(VALUE v) { return INT2FIX(get_usb_device(v)->num_children); }
/* USB::Device#devnum */
static VALUE rusb_device_devnum(VALUE v) { return INT2FIX(get_usb_device(v)->devnum); }
/* USB::Device#bus */
static VALUE rusb_device_bus(VALUE v) { return rusb_bus_make(get_usb_device(v)->bus, Qnil); }
/* USB::Device#filename */
static VALUE rusb_device_filename(VALUE v) { return rb_str_new2(get_usb_device(v)->filename); }
static void smdhsic_disconnect(struct usb_interface *intf)
{
int devid;
struct usb_interface *smd_intf;
struct str_intf_priv *intfpriv;
struct usb_device *device = NULL;
pr_info("%s: Called\n", __func__);
intfpriv = usb_get_intfdata(intf);
if (!intfpriv) {
pr_err("%s: intfpriv is NULL\n", __func__);
goto err_get_intfdata;
}
device = get_usb_device(intfpriv);
devid = GET_DEVID(intfpriv->devid);
pr_debug("%s : devid : %d\n", __func__, devid);
smd_intf = get_usb_intf(intfpriv);
if (!smd_intf) {
pr_err("smd_intf is NULL\n");
goto err_get_usb_intf;
}
if (smd_intf != intf) {
pr_err("smd_intf is not same intf\n");
goto err_mismatched_intf;
}
usb_driver_release_interface(get_usb_driver(intf), smd_intf);
if (!device)
usb_put_dev(device);
pm_runtime_disable(&device->dev);
if (g_usbdev.hsic)
cancel_delayed_work(&g_usbdev.hsic->pm_runtime_work);
switch (devid) {
case FMT_DEV_ID:
flush_txurb(&g_usbdev.ipc_urbq);
flush_txurb(&g_usbdev.data_urbq);
smdctl_request_connection_recover(true);
case RAW_DEV_ID:
case RFS_DEV_ID:
case CMD_DEV_ID:
case DOWN_DEV_ID:
if (emu_discon_func[devid])
emu_discon_func[devid](g_usbdev.smd_device[devid]);
else
kfree(intfpriv->data);
break;
default:
pr_warn("%s:Undefined Callback Function\n",
__func__);
}
/* to prevent sleep at connection recover
* when, usb suspend and recover routine overlap
* it makes huge delay on modem reset
*/
wake_lock_timeout(&g_usbdev.txwake, 20*HZ);
kfree(intfpriv);
usb_set_intfdata(intf, NULL);
g_usbdev.usbdev = NULL;
g_usbdev.suspended = 0;
g_usbdev.hsic = NULL;
return;
err_mismatched_intf:
err_get_usb_intf:
if (!device)
usb_put_dev(device);
err_get_intfdata:
pr_err("release(2) : %p\n", intf);
usb_driver_release_interface(get_usb_driver(intf), intf);
return;
}
/* USB::Device#descriptor_bMaxPacketSize0 */
static VALUE rusb_devdesc_bMaxPacketSize0(VALUE v) { return INT2FIX(get_usb_device(v)->descriptor.bMaxPacketSize0); }
