static int usb_hub_reset(struct usb_hub *hub) { struct usb_device *dev = hub->dev; int i; DBG_HOST_HUB("### >>> Enter hub.c file --> usb_hub_reset function \n"); /* Disconnect any attached devices */ for (i = 0; i < hub->descriptor->bNbrPorts; i++) { if (dev->children[i]) usb_disconnect(&dev->children[i]); } /* Attempt to reset the hub */ if (hub->urb) usb_unlink_urb(hub->urb); else return -1; if (usb_reset_device(dev)) return -1; hub->urb->dev = dev; if (usb_submit_urb(hub->urb)) return -1; usb_hub_power_on(hub); return 0; }
static int vboxUSBMonSolarisResetDevice(char *pszDevicePath, bool fReattach) { int rc = VERR_GENERAL_FAILURE; LogFunc((DEVICE_NAME ": vboxUSBMonSolarisResetDevice: pszDevicePath=%s fReattach=%d\n", pszDevicePath, fReattach)); /* * Try grabbing the dev_info_t. */ dev_info_t *pDeviceInfo = e_ddi_hold_devi_by_path(pszDevicePath, 0); if (pDeviceInfo) { ddi_release_devi(pDeviceInfo); /* * Grab the root device node from the parent hub for resetting. */ dev_info_t *pTmpDeviceInfo = NULL; for (;;) { pTmpDeviceInfo = ddi_get_parent(pDeviceInfo); if (!pTmpDeviceInfo) { LogRel((DEVICE_NAME ":vboxUSBMonSolarisResetDevice: Failed to get parent device info for %s\n", pszDevicePath)); return VERR_GENERAL_FAILURE; } if (ddi_prop_exists(DDI_DEV_T_ANY, pTmpDeviceInfo, DDI_PROP_DONTPASS, "usb-port-count")) /* parent hub */ break; pDeviceInfo = pTmpDeviceInfo; } /* * Try re-enumerating the device. */ rc = usb_reset_device(pDeviceInfo, fReattach ? USB_RESET_LVL_REATTACH : USB_RESET_LVL_DEFAULT); Log((DEVICE_NAME ": vboxUSBMonSolarisResetDevice: usb_reset_device for %s level=%s rc=%d\n", pszDevicePath, fReattach ? "ReAttach" : "Default", rc)); switch (rc) { case USB_SUCCESS: rc = VINF_SUCCESS; break; case USB_INVALID_PERM: rc = VERR_PERMISSION_DENIED; break; case USB_INVALID_ARGS: rc = VERR_INVALID_PARAMETER; break; case USB_BUSY: rc = VERR_RESOURCE_BUSY; break; case USB_INVALID_CONTEXT: rc = VERR_INVALID_CONTEXT; break; case USB_FAILURE: rc = VERR_GENERAL_FAILURE; break; default: rc = VERR_UNRESOLVED_ERROR; break; } } else { rc = VERR_INVALID_HANDLE; LogRel((DEVICE_NAME ": vboxUSBMonSolarisResetDevice: Cannot obtain device info for %s\n", pszDevicePath)); } return rc; }
static void usb_dvobj_deinit(struct usb_interface *usb_intf) { struct dvobj_priv *dvobj = usb_get_intfdata(usb_intf); usb_set_intfdata(usb_intf, NULL); if (dvobj) { /* Modify condition for 92DU DMDP 2010.11.18, by Thomas */ if ((dvobj->NumInterfaces != 2 && dvobj->NumInterfaces != 3) || (dvobj->InterfaceNumber == 1)) { if (interface_to_usbdev(usb_intf)->state != USB_STATE_NOTATTACHED) { /* If we didn't unplug usb dongle and * remove/insert module, driver fails on * sitesurvey for the first time when * device is up . * Reset usb port for sitesurvey fail issue. */ DBG_8723A("usb attached..., try to reset usb device\n"); usb_reset_device(interface_to_usbdev(usb_intf)); } } rtw_deinit_intf_priv(dvobj); mutex_destroy(&dvobj->hw_init_mutex); mutex_destroy(&dvobj->h2c_fwcmd_mutex); mutex_destroy(&dvobj->setch_mutex); mutex_destroy(&dvobj->setbw_mutex); kfree(dvobj); } usb_put_dev(interface_to_usbdev(usb_intf)); }
/* Issue a USB port reset to the device. The caller must not hold * us->dev_mutex. */ int usb_stor_port_reset(struct us_data *us) { int result; /*for these devices we must use the class specific method */ if (us->pusb_dev->quirks & USB_QUIRK_RESET_MORPHS) return -EPERM; result = usb_lock_device_for_reset(us->pusb_dev, us->pusb_intf); if (result < 0) US_DEBUGP("unable to lock device for reset: %d\n", result); else { /* Were we disconnected while waiting for the lock? */ if (test_bit(US_FLIDX_DISCONNECTING, &us->dflags)) { result = -EIO; US_DEBUGP("No reset during disconnect\n"); } else { result = usb_reset_device(us->pusb_dev); US_DEBUGP("usb_reset_device returns %d\n", result); } usb_unlock_device(us->pusb_dev); } return result; }
int usb_stor_port_reset(struct us_data *us) { int result; if (us->pusb_dev->quirks & USB_QUIRK_RESET_MORPHS) return -EPERM; result = usb_lock_device_for_reset(us->pusb_dev, us->pusb_intf); if (result < 0) US_DEBUGP("unable to lock device for reset: %d\n", result); else { if (test_bit(US_FLIDX_DISCONNECTING, &us->dflags)) { result = -EIO; US_DEBUGP("No reset during disconnect\n"); } else { result = usb_reset_device(us->pusb_dev); US_DEBUGP("usb_reset_device returns %d\n", result); } usb_unlock_device(us->pusb_dev); } return result; }
static int if_usb_reset_device(struct if_usb_card *cardp) { struct cmd_ds_command *cmd = cardp->ep_out_buf + 4; int ret; lbs_deb_enter(LBS_DEB_USB); *(__le32 *)cardp->ep_out_buf = cpu_to_le32(CMD_TYPE_REQUEST); cmd->command = cpu_to_le16(CMD_802_11_RESET); cmd->size = cpu_to_le16(sizeof(struct cmd_ds_802_11_reset) + S_DS_GEN); cmd->result = cpu_to_le16(0); cmd->seqnum = cpu_to_le16(0x5a5a); cmd->params.reset.action = cpu_to_le16(CMD_ACT_HALT); usb_tx_block(cardp, cardp->ep_out_buf, 4 + S_DS_GEN + sizeof(struct cmd_ds_802_11_reset)); msleep(100); ret = usb_reset_device(cardp->udev); msleep(100); #ifdef CONFIG_OLPC if (ret && machine_is_olpc()) if_usb_reset_olpc_card(NULL); #endif lbs_deb_leave_args(LBS_DEB_USB, "ret %d", ret); return ret; }
static int hub_reset(struct usb_hub *hub) { struct usb_device *dev = interface_to_usbdev(hub->intf); int i; /* Disconnect any attached devices */ for (i = 0; i < hub->descriptor->bNbrPorts; i++) { if (dev->children[i]) usb_disconnect(&dev->children[i]); } /* Attempt to reset the hub */ if (hub->urb) usb_unlink_urb(hub->urb); else return -1; if (usb_reset_device(dev)) return -1; hub->urb->dev = dev; if (usb_submit_urb(hub->urb, GFP_KERNEL)) return -1; hub_power_on(hub); return 0; }
static int lme2510_probe(struct usb_interface *intf, const struct usb_device_id *id) { struct usb_device *udev = interface_to_usbdev(intf); int ret = 0; usb_reset_configuration(udev); usb_set_interface(udev, intf->cur_altsetting->desc.bInterfaceNumber, 1); if (udev->speed != USB_SPEED_HIGH) { ret = usb_reset_device(udev); info("DEV Failed to connect in HIGH SPEED mode"); return -ENODEV; } lme_firmware_switch(udev, 0); if (0 == dvb_usb_device_init(intf, &lme2510_properties, THIS_MODULE, NULL, adapter_nr)) { info("DEV registering device driver"); return 0; } if (0 == dvb_usb_device_init(intf, &lme2510c_properties, THIS_MODULE, NULL, adapter_nr)) { info("DEV registering device driver"); return 0; } info("DEV lme2510 Error"); return -ENODEV; }
static int tweak_reset_device_cmd(struct urb *urb) { struct usb_ctrlrequest *req; __u16 value; __u16 index; int ret; req = (struct usb_ctrlrequest *) urb->setup_packet; value = le16_to_cpu(req->wValue); index = le16_to_cpu(req->wIndex); uinfo("reset_device (port %d) to %s\n", index, urb->dev->dev.bus->name); /* all interfaces should be owned by usbip driver, so just reset it. */ ret = usb_lock_device_for_reset(urb->dev, NULL); if (ret < 0) { uerr("lock for reset\n"); return ret; } /* try to reset the device */ ret = usb_reset_device(urb->dev); if (ret < 0) uerr("device reset\n"); usb_unlock_device(urb->dev); return ret; }
static int if_usb_reset_device(struct if_usb_card *cardp) { struct cmd_ds_802_11_reset *cmd = cardp->ep_out_buf + 4; int ret; lbtf_deb_enter(LBTF_DEB_USB); *(__le32 *)cardp->ep_out_buf = cpu_to_le32(CMD_TYPE_REQUEST); cmd->hdr.command = cpu_to_le16(CMD_802_11_RESET); cmd->hdr.size = cpu_to_le16(sizeof(struct cmd_ds_802_11_reset)); cmd->hdr.result = cpu_to_le16(0); cmd->hdr.seqnum = cpu_to_le16(0x5a5a); cmd->action = cpu_to_le16(CMD_ACT_HALT); usb_tx_block(cardp, cardp->ep_out_buf, 4 + sizeof(struct cmd_ds_802_11_reset), 0); msleep(100); ret = usb_reset_device(cardp->udev); msleep(100); lbtf_deb_leave_args(LBTF_DEB_USB, "ret %d", ret); return ret; }
static void disconnect(struct usb_interface *intf) { struct net_device *netdev = zd_intf_to_netdev(intf); struct zd_mac *mac = zd_netdev_mac(netdev); struct zd_usb *usb = &mac->chip.usb; /* Either something really bad happened, or we're just dealing with * a DEVICE_INSTALLER. */ if (netdev == NULL) return; dev_dbg_f(zd_usb_dev(usb), "\n"); zd_netdev_disconnect(netdev); /* Just in case something has gone wrong! */ zd_usb_disable_rx(usb); zd_usb_disable_int(usb); /* If the disconnect has been caused by a removal of the * driver module, the reset allows reloading of the driver. If the * reset will not be executed here, the upload of the firmware in the * probe function caused by the reloading of the driver will fail. */ usb_reset_device(interface_to_usbdev(intf)); zd_netdev_free(netdev); dev_dbg(&intf->dev, "disconnected\n"); }
/* Issue a USB port reset to the device. But don't do anything if * there's more than one interface in the device, so that other users * are not affected. */ int usb_stor_port_reset(struct us_data *us) { int result, rc; if (test_bit(US_FLIDX_DISCONNECTING, &us->flags)) { result = -EIO; US_DEBUGP("No reset during disconnect\n"); } else if (us->pusb_dev->actconfig->desc.bNumInterfaces != 1) { result = -EBUSY; US_DEBUGP("Refusing to reset a multi-interface device\n"); } else { result = rc = usb_lock_device_for_reset(us->pusb_dev, us->pusb_intf); if (result < 0) { US_DEBUGP("unable to lock device for reset: %d\n", result); } else { result = usb_reset_device(us->pusb_dev); if (rc) usb_unlock_device(us->pusb_dev); US_DEBUGP("usb_reset_device returns %d\n", result); } } return result; }
static int usb_hub_reset(struct usb_hub *hub) { struct usb_device *dev = hub->dev; int i; /* Disconnect any attached devices */ for (i = 0; i < hub->nports; i++) { if (dev->children[i]) usb_disconnect(&dev->children[i]); } /* Attempt to reset the hub */ if (hub->urb) usb_unlink_urb(hub->urb); else return -1; if (usb_reset_device(dev)) return -1; if (usb_submit_urb(hub->urb)) return -1; usb_hub_power_on(hub); return 0; }
/** * @brief Free resource and cleanup * * @param intf Pointer to usb_interface * * @return N/A */ static void woal_usb_disconnect(struct usb_interface *intf) { struct usb_card_rec *cardp = usb_get_intfdata(intf); moal_handle *phandle = NULL; ENTER(); if (!cardp || !cardp->phandle) { PRINTM(MERROR, "Card or phandle is not valid\n"); LEAVE(); return; } phandle = (moal_handle *) cardp->phandle; /* * Update Surprise removed to TRUE * Free all the URB's allocated */ phandle->surprise_removed = MTRUE; /* Unlink and free urb */ woal_usb_free(cardp); /* Card is removed and we can call wlan_remove_card */ PRINTM(MINFO, "Call remove card\n"); woal_remove_card(cardp); /* Reset device */ usb_reset_device(cardp->udev); usb_set_intfdata(intf, NULL); usb_put_dev(interface_to_usbdev(intf)); kfree(cardp); LEAVE(); return; }
static int i2400mu_bus_reset(struct i2400m *i2400m, enum i2400m_reset_type rt) { int result; struct i2400mu *i2400mu = container_of(i2400m, struct i2400mu, i2400m); struct device *dev = i2400m_dev(i2400m); static const __le32 i2400m_WARM_BOOT_BARKER[4] = { cpu_to_le32(I2400M_WARM_RESET_BARKER), cpu_to_le32(I2400M_WARM_RESET_BARKER), cpu_to_le32(I2400M_WARM_RESET_BARKER), cpu_to_le32(I2400M_WARM_RESET_BARKER), }; static const __le32 i2400m_COLD_BOOT_BARKER[4] = { cpu_to_le32(I2400M_COLD_RESET_BARKER), cpu_to_le32(I2400M_COLD_RESET_BARKER), cpu_to_le32(I2400M_COLD_RESET_BARKER), cpu_to_le32(I2400M_COLD_RESET_BARKER), }; d_fnstart(3, dev, "(i2400m %p rt %u)\n", i2400m, rt); if (rt == I2400M_RT_WARM) result = __i2400mu_send_barker( i2400mu, i2400m_WARM_BOOT_BARKER, sizeof(i2400m_WARM_BOOT_BARKER), i2400mu->endpoint_cfg.bulk_out); else if (rt == I2400M_RT_COLD) result = __i2400mu_send_barker( i2400mu, i2400m_COLD_BOOT_BARKER, sizeof(i2400m_COLD_BOOT_BARKER), i2400mu->endpoint_cfg.reset_cold); else if (rt == I2400M_RT_BUS) { result = usb_reset_device(i2400mu->usb_dev); switch (result) { case 0: case -EINVAL: case -ENODEV: case -ENOENT: case -ESHUTDOWN: result = 0; break; default: dev_err(dev, "USB reset failed (%d), giving up!\n", result); } } else { result = -EINVAL; BUG(); } if (result < 0 && result != -EINVAL && rt != I2400M_RT_BUS) { dev_err(dev, "%s reset failed (%d); trying USB reset\n", rt == I2400M_RT_WARM ? "warm" : "cold", result); usb_queue_reset_device(i2400mu->usb_iface); result = -ENODEV; } d_fnend(3, dev, "(i2400m %p rt %u) = %d\n", i2400m, rt, result); return result; }
static int mt76x2u_probe(struct usb_interface *intf, const struct usb_device_id *id) { struct usb_device *udev = interface_to_usbdev(intf); struct mt76x02_dev *dev; int err; dev = mt76x2u_alloc_device(&intf->dev); if (!dev) return -ENOMEM; udev = usb_get_dev(udev); usb_reset_device(udev); mt76x02u_init_mcu(&dev->mt76); err = mt76u_init(&dev->mt76, intf); if (err < 0) goto err; dev->mt76.rev = mt76_rr(dev, MT_ASIC_VERSION); dev_info(dev->mt76.dev, "ASIC revision: %08x\n", dev->mt76.rev); err = mt76x2u_register_device(dev); if (err < 0) goto err; return 0; err: ieee80211_free_hw(mt76_hw(dev)); usb_set_intfdata(intf, NULL); usb_put_dev(udev); return err; }
static void prism2_usb_cor_sreset(local_info_t *local) { struct hostap_usb_priv *hw_priv = local->hw_priv; printk(KERN_INFO "%s: resetting device %p\n", dev_info, hw_priv->usb); usb_reset_device(hw_priv->usb); }
/* * Reset a device at different levels (warm, cold or bus) * * @i2400m: device descriptor * @reset_type: soft, warm or bus reset (I2400M_RT_WARM/SOFT/BUS) * * Warm and cold resets get a USB reset if they fail. * * Warm reset: * * The device will be fully reset internally, but won't be * disconnected from the USB bus (so no reenumeration will * happen). Firmware upload will be neccessary. * * The device will send a reboot barker in the notification endpoint * that will trigger the driver to reinitialize the state * automatically from notif.c:i2400m_notification_grok() into * i2400m_dev_bootstrap_delayed(). * * Cold and bus (USB) reset: * * The device will be fully reset internally, disconnected from the * USB bus an a reenumeration will happen. Firmware upload will be * neccessary. Thus, we don't do any locking or struct * reinitialization, as we are going to be fully disconnected and * reenumerated. * * Note we need to return -ENODEV if a warm reset was requested and we * had to resort to a bus reset. See i2400m_op_reset(), wimax_reset() * and wimax_dev->op_reset. * * WARNING: no driver state saved/fixed */ static int i2400mu_bus_reset(struct i2400m *i2400m, enum i2400m_reset_type rt) { int result; struct i2400mu *i2400mu = container_of(i2400m, struct i2400mu, i2400m); struct device *dev = i2400m_dev(i2400m); static const __le32 i2400m_WARM_BOOT_BARKER[4] = { cpu_to_le32(I2400M_WARM_RESET_BARKER), cpu_to_le32(I2400M_WARM_RESET_BARKER), cpu_to_le32(I2400M_WARM_RESET_BARKER), cpu_to_le32(I2400M_WARM_RESET_BARKER), }; static const __le32 i2400m_COLD_BOOT_BARKER[4] = { cpu_to_le32(I2400M_COLD_RESET_BARKER), cpu_to_le32(I2400M_COLD_RESET_BARKER), cpu_to_le32(I2400M_COLD_RESET_BARKER), cpu_to_le32(I2400M_COLD_RESET_BARKER), }; d_fnstart(3, dev, "(i2400m %p rt %u)\n", i2400m, rt); if (rt == I2400M_RT_WARM) result = __i2400mu_send_barker(i2400mu, i2400m_WARM_BOOT_BARKER, sizeof(i2400m_WARM_BOOT_BARKER), I2400MU_EP_BULK_OUT); else if (rt == I2400M_RT_COLD) result = __i2400mu_send_barker(i2400mu, i2400m_COLD_BOOT_BARKER, sizeof(i2400m_COLD_BOOT_BARKER), I2400MU_EP_RESET_COLD); else if (rt == I2400M_RT_BUS) { do_bus_reset: result = usb_reset_device(i2400mu->usb_dev); switch (result) { case 0: case -EINVAL: /* device is gone */ case -ENODEV: case -ENOENT: case -ESHUTDOWN: result = rt == I2400M_RT_WARM ? -ENODEV : 0; break; /* We assume the device is disconnected */ default: dev_err(dev, "USB reset failed (%d), giving up!\n", result); } } else { result = -EINVAL; /* shut gcc up in certain arches */ BUG(); } if (result < 0 && result != -EINVAL /* device is gone */ && rt != I2400M_RT_BUS) { dev_err(dev, "%s reset failed (%d); trying USB reset\n", rt == I2400M_RT_WARM ? "warm" : "cold", result); rt = I2400M_RT_BUS; goto do_bus_reset; } d_fnend(3, dev, "(i2400m %p rt %u) = %d\n", i2400m, rt, result); return result; }
static void usb_device_reset(struct vnt_private *pDevice) { int status; status = usb_reset_device(pDevice->usb); if (status) printk("usb_device_reset fail status=%d\n",status); return ; }
static void usb_device_reset(struct vnt_private *priv) { int status; status = usb_reset_device(priv->usb); if (status) dev_warn(&priv->usb->dev, "usb_device_reset fail status=%d\n", status); }
static int carl9170_usb_probe(struct usb_interface *intf, const struct usb_device_id *id) { struct ar9170 *ar; struct usb_device *udev; int err; err = usb_reset_device(interface_to_usbdev(intf)); if (err) return err; ar = carl9170_alloc(sizeof(*ar)); if (IS_ERR(ar)) return PTR_ERR(ar); udev = interface_to_usbdev(intf); usb_get_dev(udev); ar->udev = udev; ar->intf = intf; ar->features = id->driver_info; usb_set_intfdata(intf, ar); SET_IEEE80211_DEV(ar->hw, &intf->dev); init_usb_anchor(&ar->rx_anch); init_usb_anchor(&ar->rx_pool); init_usb_anchor(&ar->rx_work); init_usb_anchor(&ar->tx_wait); init_usb_anchor(&ar->tx_anch); init_usb_anchor(&ar->tx_cmd); init_usb_anchor(&ar->tx_err); init_completion(&ar->cmd_wait); init_completion(&ar->fw_boot_wait); init_completion(&ar->fw_load_wait); tasklet_init(&ar->usb_tasklet, carl9170_usb_tasklet, (unsigned long)ar); atomic_set(&ar->tx_cmd_urbs, 0); atomic_set(&ar->tx_anch_urbs, 0); atomic_set(&ar->rx_work_urbs, 0); atomic_set(&ar->rx_anch_urbs, 0); atomic_set(&ar->rx_pool_urbs, 0); usb_get_dev(ar->udev); carl9170_set_state(ar, CARL9170_STOPPED); err = request_firmware_nowait(THIS_MODULE, 1, CARL9170FW_NAME, &ar->udev->dev, GFP_KERNEL, ar, carl9170_usb_firmware_step2); if (err) { usb_put_dev(udev); usb_put_dev(udev); carl9170_free(ar); } return err; }
static int mts_scsi_host_reset (Scsi_Cmnd *srb) { struct mts_desc* desc = (struct mts_desc*)(srb->host->hostdata[0]); MTS_DEBUG_GOT_HERE(); mts_debug_dump(desc); usb_reset_device(desc->usb_dev); /*FIXME: untested on new reset code */ return 0; /* RANT why here 0 and not SUCCESS */ }
static int mt7601u_probe(struct usb_interface *usb_intf, const struct usb_device_id *id) { struct usb_device *usb_dev = interface_to_usbdev(usb_intf); struct mt7601u_dev *dev; u32 asic_rev, mac_rev; int ret; dev = mt7601u_alloc_device(&usb_intf->dev); if (!dev) return -ENOMEM; usb_dev = usb_get_dev(usb_dev); usb_reset_device(usb_dev); usb_set_intfdata(usb_intf, dev); ret = mt7601u_assign_pipes(usb_intf, dev); if (ret) goto err; ret = mt7601u_wait_asic_ready(dev); if (ret) goto err; asic_rev = mt7601u_rr(dev, MT_ASIC_VERSION); mac_rev = mt7601u_rr(dev, MT_MAC_CSR0); dev_info(dev->dev, "ASIC revision: %08x MAC revision: %08x\n", asic_rev, mac_rev); /* Note: vendor driver skips this check for MT7601U */ if (!(mt7601u_rr(dev, MT_EFUSE_CTRL) & MT_EFUSE_CTRL_SEL)) dev_warn(dev->dev, "Warning: eFUSE not present\n"); ret = mt7601u_init_hardware(dev); if (ret) goto err; ret = mt7601u_register_device(dev); if (ret) goto err_hw; set_bit(MT7601U_STATE_INITIALIZED, &dev->state); return 0; err_hw: mt7601u_cleanup(dev); err: usb_set_intfdata(usb_intf, NULL); usb_put_dev(interface_to_usbdev(usb_intf)); destroy_workqueue(dev->stat_wq); ieee80211_free_hw(dev->hw); return ret; }
static void m5632_recover(struct usbnet *dev) { struct usb_device *udev = dev->udev; struct usb_interface *intf = dev->intf; int r; r = usb_lock_device_for_reset(udev, intf); if (r < 0) return; usb_reset_device(udev); usb_unlock_device(udev); }
static int mts_scsi_host_reset(struct scsi_cmnd *srb) { struct mts_desc* desc = (struct mts_desc*)(srb->device->host->hostdata[0]); int result; MTS_DEBUG_GOT_HERE(); mts_debug_dump(desc); result = usb_lock_device_for_reset(desc->usb_dev, desc->usb_intf); if (result == 0) { result = usb_reset_device(desc->usb_dev); usb_unlock_device(desc->usb_dev); } return result ? FAILED : SUCCESS; }
static void pcan_usb_plugout(struct usb_interface *interface) { struct pcan_usb_interface *usb_if = usb_get_intfdata(interface); if (usb_if) { int c; struct pcandev *dev; for (dev=&usb_if->dev[c=0]; c < usb_if->dev_ctrl_count; c++, dev++) { DPRINTK(KERN_DEBUG "%s: %s(%d)\n", DEVICE_NAME, __FUNCTION__, dev->nMinor); #ifdef NETDEV_SUPPORT pcan_usb_plugout_netdev(dev); #endif // mark this device as plugged out dev->ucPhysicallyInstalled = 0; // do not remove resources if the device is still in use if (!dev->nOpenPaths) pcan_usb_cleanup(dev); pcan_kill_sync_urb(&dev->port.usb.write_data); interface->minor = dev->nMinor; usb_deregister_dev(interface, &pcan_class); } pcan_kill_sync_urb(&usb_if->urb_cmd_sync); pcan_kill_sync_urb(&usb_if->urb_cmd_async); pcan_kill_sync_urb(&usb_if->read_data); kfree(usb_if->read_buffer_addr[0]); if (usb_if->device_free) usb_if->device_free(usb_if); usb_reset_device(usb_if->usb_dev); kfree(usb_if); usb_set_intfdata(interface, NULL); } }
static int libertas_do_reset(wlan_private *priv) { int ret; struct usb_card_rec *cardp = priv->card; lbs_deb_enter(LBS_DEB_USB); ret = usb_reset_device(cardp->udev); if (!ret) { msleep(10); if_usb_reset_device(priv); msleep(10); } lbs_deb_leave_args(LBS_DEB_USB, "ret %d", ret); return ret; }
static int process_resetdev_request(struct usb_serial_port *port) { unsigned long flags; int status; struct garmin_data *garmin_data_p = usb_get_serial_port_data(port); spin_lock_irqsave(&garmin_data_p->lock, flags); garmin_data_p->flags &= ~(CLEAR_HALT_REQUIRED); garmin_data_p->state = STATE_RESET; garmin_data_p->serial_num = 0; spin_unlock_irqrestore(&garmin_data_p->lock, flags); usb_kill_urb(port->interrupt_in_urb); dev_dbg(&port->dev, "%s - usb_reset_device\n", __func__); status = usb_reset_device(port->serial->dev); if (status) dev_dbg(&port->dev, "%s - usb_reset_device failed: %d\n", __func__, status); return status; }
/* Workqueue routine to reset the device or clear a halt */ static void hid_reset(struct work_struct *work) { struct usbhid_device *usbhid = container_of(work, struct usbhid_device, reset_work); struct hid_device *hid = usbhid->hid; int rc = 0; if (test_bit(HID_CLEAR_HALT, &usbhid->iofl)) { dev_dbg(&usbhid->intf->dev, "clear halt\n"); rc = usb_clear_halt(hid_to_usb_dev(hid), usbhid->urbin->pipe); clear_bit(HID_CLEAR_HALT, &usbhid->iofl); hid_start_in(hid); } else if (test_bit(HID_RESET_PENDING, &usbhid->iofl)) { dev_dbg(&usbhid->intf->dev, "resetting device\n"); rc = usb_lock_device_for_reset(hid_to_usb_dev(hid), usbhid->intf); if (rc == 0) { rc = usb_reset_device(hid_to_usb_dev(hid)); usb_unlock_device(hid_to_usb_dev(hid)); } clear_bit(HID_RESET_PENDING, &usbhid->iofl); } switch (rc) { case 0: if (!test_bit(HID_IN_RUNNING, &usbhid->iofl)) hid_io_error(hid); break; default: hid_err(hid, "can't reset device, %s-%s/input%d, status %d\n", hid_to_usb_dev(hid)->bus->bus_name, hid_to_usb_dev(hid)->devpath, usbhid->ifnum, rc); /* FALLTHROUGH */ case -EHOSTUNREACH: case -ENODEV: case -EINTR: break; } }
//----- usb_stor_port_reset() --------------------- int usb_stor_port_reset(struct us_data *us) { int result; //printk("transport --- usb_stor_port_reset\n"); result = usb_lock_device_for_reset(us->pusb_dev, us->pusb_intf); if (result < 0) printk("unable to lock device for reset: %d\n", result); else { /* Were we disconnected while waiting for the lock? */ if (test_bit(US_FLIDX_DISCONNECTING, &us->dflags)) { result = -EIO; //printk("No reset during disconnect\n"); } else { result = usb_reset_device(us->pusb_dev); //printk("usb_reset_composite_device returns %d\n", result); } usb_unlock_device(us->pusb_dev); } return result; }