විධාන රේඛාවෙන් ඔබ USB උපාංගයක් නැවත සකසන්නේ කෙසේද?

පරිගණකයෙන් භෞතිකව විසන්ධි නොවී / සම්බන්ධ නොවී, USB උපාංගයක සම්බන්ධතාවය නැවත සැකසිය හැකිද?

විශේෂයෙන්, මගේ උපාංගය ඩිජිටල් කැමරාවකි. මම භාවිතා කරමි gphoto2, නමුත් මෑතකදී මට "උපාංග කියවීමේ දෝෂ" ලැබුණි, එබැවින් සම්බන්ධතාවයේ මෘදුකාංග යළි පිහිටුවීම කිරීමට මම කැමතියි.

මට කිව හැකි දෙයින්, කැමරාව සඳහා කර්නල් මොඩියුල පටවා නොමැත. සම්බන්ධ බව පෙනෙන එකම එකකි usbhid.

පහත සඳහන් පරිදි සුරකින්න 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;
}

පර්යන්තයේ පහත දැක්වෙන විධානයන් ධාවනය කරන්න:

1. වැඩසටහන සම්පාදනය කරන්න:

   $ cc usbreset.c -o usbreset
   

2. ඔබට නැවත සැකසීමට අවශ්‍ය USB උපාංගයේ බස් සහ උපාංග හැඳුනුම්පත ලබා ගන්න:

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

3. අපගේ සම්පාදිත වැඩසටහන ක්‍රියාත්මක කළ හැකි කරන්න:

   $ chmod +x usbreset
   

4. සුඩෝ වරප්‍රසාද සහිතව වැඩසටහන ක්‍රියාත්මක කරන්න; විධානය ක්‍රියාත්මක කිරීමෙන් සොයාගත් පරිදි අවශ්‍ය ආදේශක <Bus>සහ <Device>අයි.ඩී.lsusb

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

ඉහත වැඩසටහනේ ප්‍රභවය: http://marc.info/?l=linux-usb&m=121459435621262&w=2

මම මීට පෙර ඔබගේ විශේෂිත තත්වයන් තුළ මා සොයාගෙන නැත, එබැවින් එය ප්‍රමාණවත් වේ දැයි මට විශ්වාස නැත, නමුත් USB උපාංගයක් නැවත සැකසීමට මා සොයාගත් සරලම ක්‍රමය මෙම විධානයයි: (බාහිර යෙදුම් අවශ්‍ය නොවේ)

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"

ලිබ්ෆ්‍රීනෙක්ට් නැවත නින්දට දැමීම සඳහා ඒපීඅයි නොමැති බව පෙනෙන බැවින් මගේ කිනෙක්ට් නැවත සැකසීමට මම භාවිතා කරන්නේ එයයි. එය මගේ ජෙන්ටූ පෙට්ටියේ ඇත, නමුත් කර්නලය sysfs සඳහා එකම මාර්ග ව්‍යුහයක් භාවිතා කිරීමට තරම් නව විය යුතුය.

ඔබ සතුව එසේ නොවන 1-4.6නමුත් ඔබේ කර්නල් ලොග් ( dmesg) වෙතින් ඔබට එම උපාංග මාර්ගය ඇද ගත හැකිය, නැතහොත් ඔබට lsusbවිකුණුම්කරු සහ නිෂ්පාදන හැඳුනුම්පත් ලබා ගැනීමට වැනි දෙයක් භාවිතා කළ හැකි අතර පසුව විවිධ වෙළෙන්දන් සමඟ මාර්ග සම්බන්ධ වන ආකාරය ලැයිස්තුගත කිරීමට මෙවැනි ඉක්මන් විධානයක් භාවිතා කරන්න. / නිෂ්පාදන හැඳුනුම් යුගල:

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

මෙය සියලුම 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

මෙය ඔබේ ගැටලුව විසඳනු ඇතැයි මම විශ්වාස කරමි. සියලුම USB අන්ත ලක්ෂ්‍යයන් නැවත සැකසීමට ඔබට අවශ්‍ය නැතිනම්, ඔබට සුදුසු උපාංග හැඳුනුම්පතක් භාවිතා කළ හැකිය/sys/bus/pci/drivers/ehci_hcd

සටහන්: [1]: *hci_hcdකර්නල් ධාවක සාමාන්‍යයෙන් USB පෝට් පාලනය කරයි. ohci_hcdහා uhci_hcdUSB1.1 වරාය සඳහා වන අතර, ehci_hcdUSB2 වරාය සඳහා වන අතර, xhci_hcdUSB3 වරාය සඳහා වේ. ( https://en.wikipedia.org/wiki/Host_controller_interface_(USB,_Firewire බලන්න ) )

මට මෙය පයිතන් පිටපතකින් ස්වයංක්‍රීය කිරීමට අවශ්‍ය විය, එබැවින් මම පහත සඳහන් දේ සඳහා ලිලෝගේ අතිශයින්ම ප්‍රයෝජනවත් පිළිතුර අනුගත කළෙමි:

#!/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

මගේ නඩුවේ එය cp210x ධාවකයයි (මට එයින් පැවසිය හැකිය lsmod | grep usbserial), එබැවින් ඔබට ඉහත ස්නිපටය reset_usb.py ලෙස සුරැකිය හැකි අතර පසුව මෙය කරන්න:

sudo python reset_usb.py cp210x

ඔබේ පද්ධතියේ දැනටමත් සම්පාදක සැකසුම් නොමැති නම් මෙය ප්‍රයෝජනවත් වනු ඇත, නමුත් ඔබට පයිතන් තිබේ.

මම පිළිතුරු මත පදනම්ව සමස්ත ක්‍රියාවලියම සරල කරන පයිතන් පිටපතක් නිර්මාණය කර ඇත්තෙමි.

පහත පිටපත reset_usb.py ලෙස සුරකින්න හෝ මෙම repo ක්ලෝන කරන්න .

භාවිතය:

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

පිටපත:

#!/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)

නැවත සැකසීමට ඉක්මන්ම ක්‍රමය වනුයේ USB පාලකයම නැවත සැකසීමයි. එසේ කිරීමෙන් උපාංගය විසන්ධි කිරීමේදී ලියාපදිංචි නොකිරීමට udev බල කෙරෙනු ඇති අතර ඔබ එය සක්‍රිය කළ පසු ලේඛනය නැවත පැමිණේ.

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

මෙය බොහෝ පළාත් සභා පරිසරය සඳහා ක්‍රියා කළ යුතුය. කෙසේ වෙතත්, ඔබ යම් අභිරුචි දෘඩාංගයක් භාවිතා කරන්නේ නම් ඔබට උපාංග නාම හරහා නැවත කියවිය හැකිය. මෙම ක්‍රමය මඟින් ඔබට lsusb මඟින් උපාංගයේ නම සොයා ගැනීමට අවශ්‍ය නොවේ. ඔබට ස්වයංක්‍රීය පිටපතකටද ඇතුළත් කළ හැකිය.

මොඩියුල නැවත පූරණය කිරීමෙන් මම යම් ආකාරයක ස්ලෙජ්හැම්මර් භාවිතා කරමි. මෙය මගේ 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

මෙය මගේ systemd සේවා ගොනුව /usr/lib/systemd/system/usbreset.service වන අතර එය මගේ ඩිප්ලේ කළමනාකරු ආරම්භ කිරීමෙන් පසු usb_reset.sh ධාවනය කරයි:

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

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

ප්‍රශ්නයේ විශේෂ අවස්ථාව වන්නේ USB හි කැමරාවක් සහිත gphoto2 හි සන්නිවේදන ගැටළුවක් බැවින්, එහි USB සම්බන්ධතාවය නැවත සැකසීමට gphoto2 හි විකල්පයක් ඇත:

gphoto2 --reset

සමහර විට මෙම විකල්පය 2010 දී ප්‍රශ්නය ඇසූ විට නොතිබුණි.

මම පයිතන් ස්ක්‍රිප්ට් එකක් සාදන අතර එය උපාංග අංකය මත පදනම්ව විශේෂිත USB උපාංගයක් නැවත සකසනු ඇත. Lsusb විධානයෙන් ඔබට උපාංග අංකය සොයාගත හැකිය.

උදාහරණයක් වශයෙන්:

$ lsusb

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

මෙම නූලෙහි 004 උපාංග අංකය වේ

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()

ගැලපෙන නිෂ්පාදනයක් / විකුණුම්කරුගේ හැඳුනුම්පතක් පමණක් නැවත සැකසෙන ස්ක්‍රිප්ට් මෙන්න.

#!/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

කවුරුහරි ස්ලෙජ්හැම්මරයක් ඇණවුම් කළාද? මෙය වෙනත් විවිධ පිළිතුරු වලින් එකට එකතු කර ඇත.

#!/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

VID (විකුණුම්කරුගේ හැඳුනුම්පත) සහ PID (නිෂ්පාදන හැඳුනුම්පත) විසින් හඳුනාගෙන ඇති පරිදි සමහර විට මට මෙම උපකරණය විශේෂිත උපාංගයක් මත සිදු කිරීමට අවශ්‍යය. මෙය මම මේ සඳහා ප්‍රයෝජනවත් යැයි සිතූ ස්ක්‍රිප්ට් එකක් වන අතර එය නිෆ්ටි ලිබුස් පුස්තකාලය භාවිතා කරයි.

පළමු ධාවනය:

sudo apt-get install libusb-dev

ඉන්පසුව, මෙම c ++ ගොනුවේ resetDeviceConnection විසින් vid සහ 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;
}

(මගේ පුද්ගලික TIL නාමාවලියෙන් සොරකම් කරන ලදි: https://github.com/Marviel/TIL/blob/master/unix_tools/Reset_specific_USB_Device.md )

විශේෂිත 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

මෙය උත්සාහ කරන්න, එය මෘදුකාංග විසන්ධි කිරීමකි (ඉවත් කරන්න).

සමහර විට සමහර උපාංග සඳහා බන්ධන රහිතව ක්‍රියා නොකරයි.

උදාහරණයක්:

මගේ "ජීනියස් නෙට්ස්ක්‍රෝල් 120" ඉවත් කිරීමට හෝ ඉවත් කිරීමට මට අවශ්‍යය.

ඉන්පසු මම මුලින්ම මගේ අමුණා ඇති 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**

හරි, මම මගේ මූසිකය සොයා ගත්තා, එහි බස් 002, උපාංග 009, idVendor 0458 සහ idProduct 003a ඇත, එබැවින් මෙය මූසිකය පිළිබඳ විමර්ශන උපාංග තොරතුරු වේ.

මෙය වැදගත් ය, බස් අංකය උපාංගයේ ආරම්භක නම මාර්ගය වන අතර මම ඉවත් කිරීමට නිවැරදි උපාංගය සහතික කිරීම සඳහා නිෂ්පාදන හැඳුනුම්පත සහ විකුණුම්කරු පරීක්ෂා කරමි.

$ 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/

ෆෝල්ඩර කෙරෙහි අවධානය යොමු කරන්න, අංක 2 ෆෝල්ඩරය සමඟ ආරම්භය පරීක්ෂා කරන්න, මගේ බස් රථය 002 වන බැවින් මම මෙය පරීක්ෂා කරමි, මගේ මූසික තොරතුරු පිළිබඳ නිවැරදි idVendor සහ idProduct අඩංගු සෑම ෆෝල්ඩරයක්ම එකින් එක පරීක්ෂා කර බැලුවෙමි.

මෙම අවස්ථාවේදී, මම මෙම විධානය සමඟ තොරතුරු ලබා ගන්නෙමි:

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

හරි, මාර්ගය /sys/bus/usb/drivers/usb/2-1.3/ මගේ තොරතුරු මූසිකය සමඟ ගැලපේ! XDDD.

උපාංගය ඉවත් කිරීමට කාලයයි!

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

නැවත usb උපාංගය සම්බන්ධ කර එය නැවත ක්‍රියාත්මක වේ!

ඔබගේ උපාංගයේ නම ඔබ දන්නේ නම්, මෙම පයිතන් ස්ක්‍රිප්ට් ක්‍රියා කරයි:

#!/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()

සමහර විට මෙය කැමරාවක් සඳහාද ක්‍රියා කරයි:

පහත දැක්වෙන්නේ මගේ පැත්තේ (kernel.org) ලිනක්ස් හි සාගින්නෙන් පෙළෙන USB 3.0HDD ය 3.4.42. dmesg360 න් පසු එය විධාන කල් ඉකුත්වී ඇති බව (සමාවෙන්න, මට මෙහි සයිස්ලොග් පිටපත් කළ නොහැක, සම්බන්ධිත ජාල නොවේ) සහ ධාවකය සම්පූර්ණයෙන්ම එල්ලී තිබේ. උපාංගයට ප්‍රවේශ වන ක්‍රියාවලීන් කර්නලය තුළ අවහිර කර ඇත. NFSඑල්ලා, ZFSඑල්ලා, ddඑල්ලා.

මෙය කිරීමෙන් පසු සියල්ල නැවත ක්‍රියාත්මක විය. සොයාගත් උපාංගය dmesgගැන එක පේළියක් පමණක් පැවසුවා USB.

පහත දැක්වෙන දේ විස්තරාත්මකව කරන්නේ කුමක් දැයි මට අදහසක් නැත. නමුත් එය ක්‍රියාත්මක විය.

පහත උදාහරණ නිමැවුම 2.6.32-5-686කර්නලය සමඟ ඩෙබියන් මිරිකීමෙන් වන අතර , එබැවින් එය 2.6 සහ ඊට ඉහළින් ක්‍රියා කරයි:

$ 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

මෙය ක්‍රියාත්මක නොවන්නේ නම්, උපාංගයකට සැබෑ යළි පිහිටුවීම එවන්නේ කෙසේදැයි වෙනත් කෙනෙකුට දැනගත හැකිය.