Jak zresetować urządzenie USB z wiersza poleceń?

Czy można zresetować połączenie urządzenia USB bez fizycznego odłączania / podłączania od komputera?

W szczególności moje urządzenie to aparat cyfrowy. Używam gphoto2, ale ostatnio dostaję „błędy odczytu urządzenia”, więc chciałbym spróbować zresetować oprogramowanie połączenia.

Z tego, co mogę powiedzieć, nie ma modułów jądra ładowanych do kamery. Jedyny, który wygląda na spokrewniony, to usbhid.

Zapisz następujące jako usbreset.c

/* usbreset -- send a USB port reset to a USB device */

#include <stdio.h>
#include <unistd.h>
#include <fcntl.h>
#include <errno.h>
#include <sys/ioctl.h>

#include <linux/usbdevice_fs.h>


int main(int argc, char **argv)
{
    const char *filename;
    int fd;
    int rc;

    if (argc != 2) {
        fprintf(stderr, "Usage: usbreset device-filename\n");
        return 1;
    }
    filename = argv[1];

    fd = open(filename, O_WRONLY);
    if (fd < 0) {
        perror("Error opening output file");
        return 1;
    }

    printf("Resetting USB device %s\n", filename);
    rc = ioctl(fd, USBDEVFS_RESET, 0);
    if (rc < 0) {
        perror("Error in ioctl");
        return 1;
    }
    printf("Reset successful\n");

    close(fd);
    return 0;
}

Uruchom następujące polecenia w terminalu:

1. Skompiluj program:

   $ cc usbreset.c -o usbreset
   

2. Uzyskaj identyfikator magistrali i urządzenia urządzenia USB, które chcesz zresetować:

   $ lsusb  
   Bus 002 Device 003: ID 0fe9:9010 DVICO  
   

3. Spraw, aby nasz skompilowany program był wykonywalny:

   $ chmod +x usbreset
   

4. Uruchom program z uprawnieniami sudo; dokonaj niezbędnych podstawień <Bus>i <Device>identyfikatorów zgodnie z lsusbpoleceniem:

   $ sudo ./usbreset /dev/bus/usb/002/003  
   

Źródło powyższego programu: http://marc.info/?l=linux-usb&m=121459435621262&w=2

Nie znalazłem się wcześniej w konkretnych okolicznościach, więc nie jestem pewien, czy to wystarczy, ale najprostszym sposobem na zresetowanie urządzenia USB jest to polecenie: (Nie są wymagane żadne aplikacje zewnętrzne)

sudo sh -c "echo 0 > /sys/bus/usb/devices/1-4.6/authorized"
sudo sh -c "echo 1 > /sys/bus/usb/devices/1-4.6/authorized"

Właśnie tego używam do resetowania Kinect, ponieważ libfreenect wydaje się nie mieć API do przywracania go do stanu uśpienia. Jest na moim pudełku Gentoo, ale jądro powinno być wystarczająco nowe, aby używać tej samej struktury ścieżki dla sysfs.

Oczywiście, że nie, 1-4.6ale możesz albo pobrać tę ścieżkę urządzenia z dziennika jądra ( dmesg), albo użyć czegoś takiego, lsusbaby uzyskać identyfikatory dostawcy i produktu, a następnie użyć szybkiego polecenia, aby wyświetlić relacje między ścieżkami do różnych dostawców / pary identyfikatora produktu:

for X in /sys/bus/usb/devices/*; do 
    echo "$X"
    cat "$X/idVendor" 2>/dev/null 
    cat "$X/idProduct" 2>/dev/null
    echo
done

Spowoduje to zresetowanie wszystkich podłączonych portów USB1 / 2/3 [1]:

for i in /sys/bus/pci/drivers/[uoex]hci_hcd/*:*; do
  [ -e "$i" ] || continue
  echo "${i##*/}" > "${i%/*}/unbind"
  echo "${i##*/}" > "${i%/*}/bind"
done

Wierzę, że to rozwiąże twój problem. Jeśli nie chcesz resetować wszystkich punktów końcowych USB, możesz użyć odpowiedniego identyfikatora urządzenia z/sys/bus/pci/drivers/ehci_hcd

Uwagi: [1]: *hci_hcdsterowniki jądra zwykle kontrolują porty USB. ohci_hcdi uhci_hcdsą dla portów USB 1.1, ehci_hcdsą dla portów USB2 i xhci_hcddla portów USB3. (patrz https://en.wikipedia.org/wiki/Host_controller_interface_(USB,_Firewire) )

Musiałem zautomatyzować to w skrypcie python, więc dostosowałem niezwykle pomocną odpowiedź LiLo na następujące:

#!/usr/bin/env python
import os
import sys
from subprocess import Popen, PIPE
import fcntl
driver = sys.argv[-1]
print "resetting driver:", driver
USBDEVFS_RESET= 21780

try:
    lsusb_out = Popen("lsusb | grep -i %s"%driver, shell=True, bufsize=64, stdin=PIPE, stdout=PIPE, close_fds=True).stdout.read().strip().split()
    bus = lsusb_out[1]
    device = lsusb_out[3][:-1]
    f = open("/dev/bus/usb/%s/%s"%(bus, device), 'w', os.O_WRONLY)
    fcntl.ioctl(f, USBDEVFS_RESET, 0)
except Exception, msg:
    print "failed to reset device:", msg

W moim przypadku był to sterownik cp210x (o którym mogłem powiedzieć lsmod | grep usbserial), więc możesz zapisać powyższy fragment jako reset_usb.py, a następnie zrobić to:

sudo python reset_usb.py cp210x

Może to być również pomocne, jeśli nie masz jeszcze konfiguracji kompilatora ac w swoim systemie, ale masz python.

Stworzyłem skrypt w języku Python, który upraszcza cały proces na podstawie odpowiedzi tutaj.

Zapisz poniższy skrypt jako reset_usb.py lub sklonuj to repozytorium .

Stosowanie:

python reset_usb.py help  # Show this help
sudo python reset_usb.py list  # List all USB devices
sudo python reset_usb.py path /dev/bus/usb/XXX/YYY  # Reset USB device using path /dev/bus/usb/XXX/YYY
sudo python reset_usb.py search "search terms"  # Search for USB device using the search terms within the search string returned by list and reset matching device
sudo python reset_usb.py listpci  # List all PCI USB devices
sudo python reset_usb.py pathpci /sys/bus/pci/drivers/.../XXXX:XX:XX.X  # Reset PCI USB device using path /sys/bus/pci/drivers/.../XXXX:XX:XX.X
sudo python reset_usb.py searchpci "search terms"  # Search for PCI USB device using the search terms within the search string returned by listpci and reset matching device

Scenariusz:

#!/usr/bin/env python
import os
import sys
from subprocess import Popen, PIPE
import fcntl

instructions = '''
Usage: python reset_usb.py help : Show this help
       sudo python reset_usb.py list : List all USB devices
       sudo python reset_usb.py path /dev/bus/usb/XXX/YYY : Reset USB device using path /dev/bus/usb/XXX/YYY
       sudo python reset_usb.py search "search terms" : Search for USB device using the search terms within the search string returned by list and reset matching device
       sudo python reset_usb.py listpci : List all PCI USB devices
       sudo python reset_usb.py pathpci /sys/bus/pci/drivers/.../XXXX:XX:XX.X : Reset PCI USB device using path
       sudo python reset_usb.py searchpci "search terms" : Search for PCI USB device using the search terms within the search string returned by listpci and reset matching device       
       '''


if len(sys.argv) < 2:
    print(instructions)
    sys.exit(0)

option = sys.argv[1].lower()
if 'help' in option:
    print(instructions)
    sys.exit(0)


def create_pci_list():
    pci_usb_list = list()
    try:
        lspci_out = Popen('lspci -Dvmm', shell=True, bufsize=64, stdin=PIPE, stdout=PIPE, close_fds=True).stdout.read().strip().decode('utf-8')
        pci_devices = lspci_out.split('%s%s' % (os.linesep, os.linesep))
        for pci_device in pci_devices:
            device_dict = dict()
            categories = pci_device.split(os.linesep)
            for category in categories:
                key, value = category.split('\t')
                device_dict[key[:-1]] = value.strip()
            if 'USB' not in device_dict['Class']:
                continue
            for root, dirs, files in os.walk('/sys/bus/pci/drivers/'):
                slot = device_dict['Slot']
                if slot in dirs:
                    device_dict['path'] = os.path.join(root, slot)
                    break
            pci_usb_list.append(device_dict)
    except Exception as ex:
        print('Failed to list pci devices! Error: %s' % ex)
        sys.exit(-1)
    return pci_usb_list


def create_usb_list():
    device_list = list()
    try:
        lsusb_out = Popen('lsusb -v', shell=True, bufsize=64, stdin=PIPE, stdout=PIPE, close_fds=True).stdout.read().strip().decode('utf-8')
        usb_devices = lsusb_out.split('%s%s' % (os.linesep, os.linesep))
        for device_categories in usb_devices:
            if not device_categories:
                continue
            categories = device_categories.split(os.linesep)
            device_stuff = categories[0].strip().split()
            bus = device_stuff[1]
            device = device_stuff[3][:-1]
            device_dict = {'bus': bus, 'device': device}
            device_info = ' '.join(device_stuff[6:])
            device_dict['description'] = device_info
            for category in categories:
                if not category:
                    continue
                categoryinfo = category.strip().split()
                if categoryinfo[0] == 'iManufacturer':
                    manufacturer_info = ' '.join(categoryinfo[2:])
                    device_dict['manufacturer'] = manufacturer_info
                if categoryinfo[0] == 'iProduct':
                    device_info = ' '.join(categoryinfo[2:])
                    device_dict['device'] = device_info
            path = '/dev/bus/usb/%s/%s' % (bus, device)
            device_dict['path'] = path

            device_list.append(device_dict)
    except Exception as ex:
        print('Failed to list usb devices! Error: %s' % ex)
        sys.exit(-1)
    return device_list


if 'listpci' in option:
    pci_usb_list = create_pci_list()
    for device in pci_usb_list:
        print('path=%s' % device['path'])
        print('    manufacturer=%s' % device['SVendor'])
        print('    device=%s' % device['SDevice'])
        print('    search string=%s %s' % (device['SVendor'], device['SDevice']))
    sys.exit(0)

if 'list' in option:
    usb_list = create_usb_list()
    for device in usb_list:
        print('path=%s' % device['path'])
        print('    description=%s' % device['description'])
        print('    manufacturer=%s' % device['manufacturer'])
        print('    device=%s' % device['device'])
        print('    search string=%s %s %s' % (device['description'], device['manufacturer'], device['device']))
    sys.exit(0)

if len(sys.argv) < 3:
    print(instructions)
    sys.exit(0)

option2 = sys.argv[2]

print('Resetting device: %s' % option2)


# echo -n "0000:39:00.0" | tee /sys/bus/pci/drivers/xhci_hcd/unbind;echo -n "0000:39:00.0" | tee /sys/bus/pci/drivers/xhci_hcd/bind
def reset_pci_usb_device(dev_path):
    folder, slot = os.path.split(dev_path)
    try:
        fp = open(os.path.join(folder, 'unbind'), 'wt')
        fp.write(slot)
        fp.close()
        fp = open(os.path.join(folder, 'bind'), 'wt')
        fp.write(slot)
        fp.close()
        print('Successfully reset %s' % dev_path)
        sys.exit(0)
    except Exception as ex:
        print('Failed to reset device! Error: %s' % ex)
        sys.exit(-1)


if 'pathpci' in option:
    reset_pci_usb_device(option2)


if 'searchpci' in option:
    pci_usb_list = create_pci_list()
    for device in pci_usb_list:
        text = '%s %s' % (device['SVendor'], device['SDevice'])
        if option2 in text:
            reset_pci_usb_device(device['path'])
    print('Failed to find device!')
    sys.exit(-1)


def reset_usb_device(dev_path):
    USBDEVFS_RESET = 21780
    try:
        f = open(dev_path, 'w', os.O_WRONLY)
        fcntl.ioctl(f, USBDEVFS_RESET, 0)
        print('Successfully reset %s' % dev_path)
        sys.exit(0)
    except Exception as ex:
        print('Failed to reset device! Error: %s' % ex)
        sys.exit(-1)


if 'path' in option:
    reset_usb_device(option2)


if 'search' in option:
    usb_list = create_usb_list()
    for device in usb_list:
        text = '%s %s %s' % (device['description'], device['manufacturer'], device['device'])
        if option2 in text:
            reset_usb_device(device['path'])
    print('Failed to find device!')
    sys.exit(-1)

Ponieważ szczególnym przypadkiem tego pytania jest problem z komunikacją gphoto2 z aparatem na USB, w gphoto2 istnieje możliwość zresetowania połączenia USB:

gphoto2 --reset

Być może ta opcja nie istniała w 2010 r., Kiedy zadano pytanie.

Najszybszym sposobem na zresetowanie będzie zresetowanie samego kontrolera USB. Spowoduje to wymuszenie udev do wyrejestrowania urządzenia po rozłączeniu, a rejestracja powróci po włączeniu.

echo -n "0000:00:1a.0" | tee /sys/bus/pci/drivers/ehci_hcd/unbind
echo -n "0000:00:1d.0" | tee /sys/bus/pci/drivers/ehci_hcd/unbind
echo -n "0000:00:1a.0" | tee /sys/bus/pci/drivers/ehci_hcd/bind
echo -n "0000:00:1d.0" | tee /sys/bus/pci/drivers/ehci_hcd/bind

Powinno to działać w większości środowisk komputerowych. Jeśli jednak używasz niestandardowego sprzętu, możesz po prostu iterować nazwy urządzeń. Dzięki tej metodzie nie musisz szukać nazwy urządzenia przez lsusb. Możesz również włączyć do skryptu automatycznego.

Używam swego rodzaju młota, ponownie ładując moduły. To jest mój skrypt usb_reset.sh:

#!/bin/bash

# USB drivers
rmmod xhci_pci
rmmod ehci_pci

# uncomment if you have firewire
#rmmod ohci_pci

modprobe xhci_pci
modprobe ehci_pci

# uncomment if you have firewire
#modprobe ohci_pci

A to jest mój plik usługi systemd /usr/lib/systemd/system/usbreset.service, który uruchamia usb_reset.sh po uruchomieniu mojego menedżera diplay:

[Unit]
Description=usbreset Service
After=gdm.service
Wants=gdm.service

[Service]
Type=oneshot
ExecStart=/path/to/usb_reset.sh

Stworzyłem skrypt Pythona, który zresetuje określone urządzenie USB na podstawie numeru urządzenia. Możesz znaleźć numer urządzenia z polecenia lsusb.

na przykład:

$ lsusb

Bus 002 Device 004: ID 046d:c312 Logitech, Inc. DeLuxe 250 Keyboard

W tym ciągu 004 jest numerem urządzenia

import os
import argparse
import subprocess

path='/sys/bus/usb/devices/'

def runbash(cmd):
    p = subprocess.Popen(cmd, shell=True, stdout=subprocess.PIPE)
    out = p.stdout.read().strip()
    return out

def reset_device(dev_num):
    sub_dirs = []
    for root, dirs, files in os.walk(path):
            for name in dirs:
                    sub_dirs.append(os.path.join(root, name))

    dev_found = 0
    for sub_dir in sub_dirs:
            if True == os.path.isfile(sub_dir+'/devnum'):
                    fd = open(sub_dir+'/devnum','r')
                    line = fd.readline()
                    if int(dev_num) == int(line):
                            print ('Your device is at: '+sub_dir)
                            dev_found = 1
                            break

                    fd.close()

    if dev_found == 1:
            reset_file = sub_dir+'/authorized'
            runbash('echo 0 > '+reset_file) 
            runbash('echo 1 > '+reset_file) 
            print ('Device reset successful')

    else:
            print ("No such device")

def main():
    parser = argparse.ArgumentParser()
    parser.add_argument('-d', '--devnum', dest='devnum')
    args = parser.parse_args()

    if args.devnum is None:
            print('Usage:usb_reset.py -d <device_number> \nThe device    number can be obtained from lsusb command result')
            return

    reset_device(args.devnum)

if __name__=='__main__':
    main()

Oto skrypt, który resetuje tylko pasujący identyfikator produktu / dostawcy.

#!/bin/bash

set -euo pipefail
IFS=$'\n\t'

VENDOR="045e"
PRODUCT="0719"

for DIR in $(find /sys/bus/usb/devices/ -maxdepth 1 -type l); do
  if [[ -f $DIR/idVendor && -f $DIR/idProduct &&
        $(cat $DIR/idVendor) == $VENDOR && $(cat $DIR/idProduct) == $PRODUCT ]]; then
    echo 0 > $DIR/authorized
    sleep 0.5
    echo 1 > $DIR/authorized
  fi
done

Czy ktoś zamówił młot? Jest to zestawione z różnych innych odpowiedzi tutaj.

#!/bin/bash

# Root required
if (( UID )); then
        exec sudo "$0" "$@"
fi

cd /sys/bus/pci/drivers

function reinit {(
        local d="$1"
        test -e "$d" || return

        rmmod "$d"

        cd "$d"

        for i in $(ls | grep :); do
                echo "$i" > unbind
        done

        sleep 1

        for i in $(ls | grep :); do
                echo "$i" > bind
        done

        modprobe "$d"

)}

for d in ?hci_???; do
        echo " - $d"
        reinit "$d"
done

Czasami chcę wykonać tę operację na określonym urządzeniu, określonym przez VID (identyfikator dostawcy) i PID (identyfikator produktu). Jest to skrypt, który uznałem za przydatny w tym celu, który wykorzystuje zręczną bibliotekę libusb.

Pierwszy bieg:

sudo apt-get install libusb-dev

Następnie resetDeviceConnection tego pliku c ++ powinien wykonać to zadanie polegające na zresetowaniu połączenia urządzenia określonego przez vid i pid.

#include <libusb-1.0/libusb.h>

int resetDeviceConnection(UINT_16 vid, UINT_16 pid){
    /*Open libusb*/
    int resetStatus = 0;
    libusb_context * context;
    libusb_init(&context);

    libusb_device_handle * dev_handle = libusb_open_device_with_vid_pid(context,vid,pid);
    if (dev_handle == NULL){
      printf("usb resetting unsuccessful! No matching device found, or error encountered!\n");
      resetStatus = 1;
    }
    else{
      /*reset the device, if one was found*/
      resetStatus = libusb_reset_device(dev_handle);
    }
    /*exit libusb*/
    libusb_exit(context);
    return resetStatus;
}

(skradziony z mojego osobistego katalogu TIL: https://github.com/Marviel/TIL/blob/master/unix_tools/Reset_specific_USB_Device.md )

Zrobiłem prosty skrypt bash do zresetowania konkretnego urządzenia USB.

#!/bin/bash
#type lsusb to find "vendor" and "product" ID in terminal
set -euo pipefail
IFS=$'\n\t'

#edit the below two lines of vendor and product values using lsusb result
dev=$(lsusb -t | grep usbdevicename | grep 'If 1' | cut -d' ' -f13|cut -d"," -f1)
#VENDOR=05a3
#PRODUCT=9230
VENDOR=$(lsusb -s $dev | cut -d' ' -f6 | cut -d: -f1)
PRODUCT=$(lsusb -s $dev | cut -d' ' -f6 | cut -d: -f2)

for DIR in $(find /sys/bus/usb/devices/ -maxdepth 1 -type l); do
  if [[ -f $DIR/idVendor && -f $DIR/idProduct &&
        $(cat $DIR/idVendor) == $VENDOR && $(cat $DIR/idProduct) == $PRODUCT ]]; then
    echo 0 > $DIR/authorized
    sleep 0.5
    echo 1 > $DIR/authorized
  fi
done

Być może działa to również w przypadku aparatu:

Po przywróceniu głodującego USB 3.0dysku twardego na 3.4.42Linux (kernel.org) po mojej stronie. dmesgpowiedział, że upłynął limit czasu poleceń po 360s (przepraszam, nie mogę skopiować syslog tutaj, nie podłączonych sieci) i dysk został całkowicie zawieszony. Procesy uzyskiwania dostępu do urządzenia zostały zablokowane w jądrze, niemożliwe do zabicia. NFSzawieszony, ZFSzawieszony, ddzawieszony.

Po wykonaniu tej czynności wszystko znów działało. dmesgpowiedział tylko jeden wiersz o USBznalezionym urządzeniu.

Naprawdę nie mam pojęcia, co szczegółowo robi poniższe. Ale zadziałało.

Poniższy przykładowy wynik pochodzi z Debian Squeeze z 2.6.32-5-686jądrem, więc myślę, że działa dla wersji 2.6 i nowszych:

$ ls -al /dev/sdb
brw-rw---T 1 root floppy 8, 16 Jun  3 20:24 /dev/sdb

$ ls -al /sys/dev/block/8:16/device/rescan
--w------- 1 root root 4096 Jun  6 01:46 /sys/dev/block/8:16/device/rescan

$ echo 1 > /sys/dev/block/8:16/device/rescan

Jeśli to nie zadziała, być może ktoś inny może wymyślić, jak wysłać prawdziwy reset do urządzenia.

Wypróbuj to, to oprogramowanie odłączyć (Eject).

Czasami nie działa po prostu odznacz urządzenie dla niektórych urządzeń.

Przykład:

Chcę usunąć lub wysunąć mój „Genius NetScroll 120”.

Następnie najpierw sprawdź podłączone urządzenie USB

$ lsusb
Bus 001 Device 001: ID 1d6b:0002 Linux Foundation 2.0 root hub
Bus 002 Device 001: ID 1d6b:0002 Linux Foundation 2.0 root hub
Bus 001 Device 002: ID 8087:0020 Intel Corp. Integrated Rate Matching Hub
Bus 002 Device 002: ID 8087:0020 Intel Corp. Integrated Rate Matching Hub
Bus 001 Device 003: ID 03f0:231d Hewlett-Packard 
Bus 001 Device 004: ID 138a:0007 Validity Sensors, Inc. VFS451 Fingerprint Reader
Bus 001 Device 005: ID 04f2:b163 Chicony Electronics Co., Ltd 
Bus 002 Device 009: ID 0458:003a KYE Systems Corp. (Mouse Systems) NetScroll+ Mini Traveler / Genius NetScroll 120  **<----This my Mouse! XDDD**

Ok, znalazłem moją mysz, ma ona magistralę 002, urządzenie 009, idVendor 0458 i idProduct 003a, więc jest to informacja o urządzeniu referencyjnym na temat myszy.

Jest to ważne, ponieważ numer magistrali jest początkową ścieżką nazwy urządzenia i sprawdzę identyfikator produktu i dostawcę, aby upewnić się, że urządzenie ma zostać usunięte.

$ ls /sys/bus/usb/drivers/usb/
1-1/    1-1.1/  1-1.3/  1-1.5/  2-1/    2-1.3/  bind    uevent  unbind  usb1/   usb2/

Zwróć uwagę na foldery, sprawdź początek z folderem nr 2, sprawdzę ten, ponieważ moja magistrala to 002, i jeden po drugim sprawdzam każdy folder zawierający poprawny idVendor i idProduct na temat moich informacji o myszy.

W takim przypadku odzyskam informacje za pomocą tego polecenia:

cat /sys/bus/usb/drivers/usb/2-1.3/idVendor
0458
cat /sys/bus/usb/drivers/usb/2-1.3/idProduct
003a

Ok, ścieżka /sys/bus/usb/drivers/usb/2-1.3/ pasuje do mojej myszy informacyjnej! XDDD.

Czas usunąć urządzenie!

su -c "echo 1 > /sys/bus/usb/drivers/usb/2-1.3/remove"

Podłącz ponownie urządzenie USB i znów działa!

Jeśli znasz nazwę swojego urządzenia, ten skrypt w języku Python będzie działał:

#!/usr/bin/python
"""
USB Reset

Call as "usbreset.py <device_file_path>"

With device_file_path like "/dev/bus/usb/bus_number/device_number"
"""
import fcntl, sys, os

USBDEVFS_RESET = ord('U') << (4*2) | 20

def main():
    fd = os.open(sys.argv[1], os.O_WRONLY)
    if fd < 0: sys.exit(1)
    fcntl.ioctl(fd, USBDEVFS_RESET, 0)
    os.close(fd)
    sys.exit(0)
# end main

if __name__ == '__main__':
    main()