def get_sense(handle, endpoint_in, endpoint_out): # Request Sense print("Request Sense:") sense = (ct.c_uint8 * 18)() cdb = (ct.c_uint8 * 16)() # SCSI Command Descriptor Block cdb[0] = 0x03 # Request Sense cdb[4] = REQUEST_SENSE_LENGTH expected_tag = ct.c_uint32() send_mass_storage_command(handle, endpoint_out, 0, cdb, usb.LIBUSB_ENDPOINT_IN, REQUEST_SENSE_LENGTH, ct.pointer(expected_tag)) size = ct.c_int() rc = usb.bulk_transfer(handle, endpoint_in, ct.cast(ct.pointer(sense), ct.POINTER(ct.c_ubyte)), REQUEST_SENSE_LENGTH, ct.byref(size), 1000) if rc < 0: print("usb.bulk_transfer failed: {}".format(usb.error_name(rc))) return size = size.value print(" received {} bytes".format(size)) if sense[0] != 0x70 and sense[0] != 0x71: perr(" ERROR No sense data\n") else: perr(" ERROR Sense: {:02X} {:02X} {:02X}\n", sense[2] & 0x0F, sense[12], sense[13]) # Strictly speaking, the get_mass_storage_status() call should come # before these perr() lines. If the status is nonzero then we must # assume there's no data in the buffer. For xusb it doesn't matter. get_mass_storage_status(handle, endpoint_in, expected_tag)
def ezusb_cpucs(device, addr, do_run): global verbose data = ct.c_uint8(0x00 if do_run else 0x01) if verbose: logerror("{}\n", "stop CPU" if data else "reset CPU") status = usb.control_transfer(device, usb.LIBUSB_ENDPOINT_OUT | usb.LIBUSB_REQUEST_TYPE_VENDOR | usb.LIBUSB_RECIPIENT_DEVICE, RW_INTERNAL, addr & 0xFFFF, addr >> 16, ct.byref(data), 1, 1000); if (status != 1 and # We may get an I/O error from libusb as the device disappears (not do_run or status != usb.LIBUSB_ERROR_IO)): mesg = "can't modify CPUCS" if status < 0: logerror("{}: {}\n", mesg, usb.error_name(status)) else: logerror("{}\n", mesg) return False else: return True
def main(argv=sys.argv): global handle, done hp = [usb.hotplug_callback_handle() for i in range(2)] vendor_id = int(argv[1]) if len(argv) > 1 else 0x045a product_id = int(argv[2]) if len(argv) > 2 else 0x5005 class_id = int(argv[3]) if len(argv) > 3 else usb.LIBUSB_HOTPLUG_MATCH_ANY rc = usb.init(None) if rc < 0: print("failed to initialise libusb: {}".format(usb.error_name(rc))) return 1 try: if not usb.has_capability(usb.LIBUSB_CAP_HAS_HOTPLUG): print("Hotplug capabilites are not supported on this platform") return 1 rc = usb.hotplug_register_callback( None, usb.LIBUSB_HOTPLUG_EVENT_DEVICE_ARRIVED, 0, vendor_id, product_id, class_id, hotplug_callback, None, ct.byref(hp[0])) if rc != usb.LIBUSB_SUCCESS: print("Error registering callback 0", file=sys.stderr) return 1 rc = usb.hotplug_register_callback( None, usb.LIBUSB_HOTPLUG_EVENT_DEVICE_LEFT, 0, vendor_id, product_id, class_id, hotplug_callback_detach, None, ct.byref(hp[1])) if rc != usb.LIBUSB_SUCCESS: print("Error registering callback 1", file=sys.stderr) return 1 while done < 2: rc = usb.handle_events(None) if rc < 0: print("libusb.handle_events() failed: {}".format( usb.error_name(rc))) finally: if handle: usb.close(handle) usb.exit(None) return 0
def main(): global devh global VID, PID global do_exit #sigact = struct_sigaction() #sigact.sa_handler = sig_hdlr #sigemptyset(ct.byref(sigact.sa_mask)) #sigact.sa_flags = 0 signal.signal(signal.SIGINT, sig_hdlr) rc = usb.init(None) if rc < 0: print("Error initializing libusb: {}".format(usb.error_name(rc)), file=sys.stderr) sys.exit(1) try: devh = usb.open_device_with_vid_pid(None, VID, PID) if not devh: print("Error finding USB device", file=sys.stderr) return rc rc = usb.claim_interface(devh, 2) if rc < 0: print("Error claiming interface: {}".format(usb.error_name(rc)), file=sys.stderr) return rc benchmark_in(EP_ISO_IN) while not do_exit: rc = usb.handle_events(None) if rc != usb.LIBUSB_SUCCESS: break # Measurement has already been done by the signal handler. usb.release_interface(devh, 0) finally: if devh: usb.close(devh) usb.exit(None) return rc
def ezusb_read(device, label, opcode, addr, data, size): global verbose if verbose > 1: logerror("{}, addr {:#010x} len %4u ({:#06x})\n", label, addr, size, size) status = usb.control_transfer( device, usb.LIBUSB_ENDPOINT_IN | usb.LIBUSB_REQUEST_TYPE_VENDOR | usb.LIBUSB_RECIPIENT_DEVICE, opcode, addr & 0xFFFF, addr >> 16, ct.cast(data, ct.POINTER(ct.c_ubyte)), ct.c_uint16(size), 1000) if status != ct.c_int(size).value: if status < 0: logerror("{}: {}\n", label, usb.error_name(status)) else: logerror("{} ==> {}\n", label, status) return 0 if status >= 0 else -errno.EIO
def ezusb_fx3_jump(device, addr): global verbose if verbose: logerror("transfer execution to Program Entry at {:#010x}\n", addr) status = usb.control_transfer( device, usb.LIBUSB_ENDPOINT_OUT | usb.LIBUSB_REQUEST_TYPE_VENDOR | usb.LIBUSB_RECIPIENT_DEVICE, RW_INTERNAL, addr & 0xFFFF, addr >> 16, NULL, 0, 1000) # We may get an I/O error from libusb as the device disappears if status != 0 and status != usb.LIBUSB_ERROR_IO: mesg = "failed to send jump command" if status < 0: logerror("{}: {}\n", mesg, usb.error_name(status)) else: logerror("{}\n", mesg) return False else: return True
def main(argv=sys.argv): global verbose FIRMWARE = 0 LOADER = 1 known_devices = FX_KNOWN_DEVICES paths = [None, None] # [const char*] device_id = None # const char* device_path = os.environ.get("DEVICE", None) target_type = None # const char* fx_names = FX_TYPE_NAMES img_names = IMG_TYPE_NAMES fx_type = FX_TYPE_UNDEFINED # int img_types = [0] * len(paths) # [int] #opt; # int #status; # int #ext; # const char* #i, j; # unsigned int vid = 0 # unsigned pid = 0 # unsigned busnum = 0 # unsigned devaddr = 0 # unsigned #_busnum; # unsigned #_devaddr; # unsigned dev = ct.POINTER(usb.device)() devs = ct.POINTER(ct.POINTER(usb.device))() device = ct.POINTER(usb.device_handle)() desc = usb.device_descriptor() try: opts, args = getopt.getopt(argv[1:], "qvV?hd:p:i:I:s:S:t:") except getopt.GetoptError: return print_usage(-1) for opt, optarg in opts: if opt == "-d": device_id = optarg if sscanf(device_id, "%x:%x", ct.byref(vid), ct.byref(pid)) != 2: print( "please specify VID & PID as \"vid:pid\" in hexadecimal format", file=sys.stderr) return -1 elif opt == "-p": device_path = optarg if sscanf(device_path, "%u,%u", ct.byref(busnum), ct.byref(devaddr)) != 2: print( "please specify bus number & device number as \"bus,dev\" in decimal format", file=sys.stderr) return -1 elif opt in ("-i", "-I"): paths[FIRMWARE] = optarg elif opt in ("-s", "-S"): paths[LOADER] = optarg elif opt == "-V": print(FXLOAD_VERSION) return 0 elif opt == "-t": target_type = optarg elif opt == "-v": verbose += 1 elif opt == "-q": verbose -= 1 elif opt in ("-?", "-h"): return print_usage(-1) else: return print_usage(-1) if paths[FIRMWARE] is None: logerror("no firmware specified!\n") return print_usage(-1) if device_id is not None and device_path is not None: logerror("only one of -d or -p can be specified\n") return print_usage(-1) # determine the target type if target_type is not None: for i in range(FX_TYPE_MAX): if fx_names[i] == target_type: fx_type = i break else: logerror("illegal microcontroller type: {}\n", target_type) return print_usage(-1) # open the device using libusb status = usb.init(None) if status < 0: logerror("usb.init() failed: {}\n", usb.error_name(status)) return -1 try: usb.set_option(None, usb.LIBUSB_OPTION_LOG_LEVEL, verbose) # try to pick up missing parameters from known devices if target_type is None or device_id is None or device_path is not None: if usb.get_device_list(None, ct.byref(devs)) < 0: logerror("libusb.get_device_list() failed: {}\n", usb.error_name(status)) return -1 i = 0 while True: dev = devs[i] if not dev: usb.free_device_list(devs, 1) logerror( "could not find a known device - please specify type and/or vid:pid and/or bus,dev\n" ) return print_usage(-1) _busnum = usb.get_bus_number(dev) _devaddr = usb.get_device_address(dev) if target_type is not None and device_path is not None: # if both a type and bus,addr were specified, we just need to find our match if (usb.get_bus_number(dev) == busnum and usb.get_device_address(dev) == devaddr): break else: status = usb.get_device_descriptor(dev, ct.byref(desc)) if status >= 0: if verbose >= 3: logerror("examining {:04x}:{:04x} ({},{})\n", desc.idVendor, desc.idProduct, _busnum, _devaddr) if_break = False for known_device in known_devices: if (desc.idVendor == known_device.vid and desc.idProduct == known_device.pid): if ( # nothing was specified (target_type is None and device_id is None and device_path is None) or # vid:pid was specified and we have a match (target_type is None and device_id is not None and vid == desc.idVendor and pid == desc.idProduct) or # bus,addr was specified and we have a match (target_type is None and device_path is not None and busnum == _busnum and devaddr == _devaddr) or # type was specified and we have a match (target_type is not None and device_id is None and device_path is None and fx_type == known_device.type)): fx_type = known_device.type vid = desc.idVendor pid = desc.idProduct busnum = _busnum devaddr = _devaddr if_break = True break if if_break: if verbose: logerror( "found device '{}' [{:04x}:{:04x}] ({},{})\n", known_device.designation, vid, pid, busnum, devaddr) break i += 1 status = usb.open(dev, ct.byref(device)) usb.free_device_list(devs, 1) if status < 0: logerror("usb.open() failed: {}\n", usb.error_name(status)) return -1 elif device_id is not None: device = usb.open_device_with_vid_pid(None, ct.c_uint16(vid), ct.c_uint16(pid)) if not device: logerror("usb.open() failed\n") return -1 # We need to claim the first interface usb.set_auto_detach_kernel_driver(device, 1) status = usb.claim_interface(device, 0) if status != usb.LIBUSB_SUCCESS: usb.close(device) logerror("libusb.claim_interface failed: {}\n", usb.error_name(status)) return -1 if verbose: logerror("microcontroller type: {}\n", fx_names[fx_type]) for i, path in enumerate(paths): if path is not None: ext = path[-4:] if ext.lower() == ".hex" or ext == ".ihx": img_types[i] = IMG_TYPE_HEX elif ext.lower() == ".iic": img_types[i] = IMG_TYPE_IIC elif ext.lower() == ".bix": img_types[i] = IMG_TYPE_BIX elif ext.lower() == ".img": img_types[i] = IMG_TYPE_IMG else: logerror("{} is not a recognized image type\n", path) return -1 if verbose and path is not None: logerror("{}: type {}\n", path, img_names[img_types[i]]) if paths[LOADER] is None: # single stage, put into internal memory if verbose > 1: logerror("single stage: load on-chip memory\n") status = ezusb_load_ram(device, paths[FIRMWARE], fx_type, img_types[FIRMWARE], 0) else: # two-stage, put loader into internal memory if verbose > 1: logerror("1st stage: load 2nd stage loader\n") status = ezusb_load_ram(device, paths[LOADER], fx_type, img_types[LOADER], 0) if status == 0: # two-stage, put firmware into internal memory if verbose > 1: logerror("2nd state: load on-chip memory\n") status = ezusb_load_ram(device, paths[FIRMWARE], fx_type, img_types[FIRMWARE], 1) usb.release_interface(device, 0) usb.close(device) finally: usb.exit(None) return status