自学教程：C++ usb_bulk_write函数代码示例

 /*  ** rfidtag_xchange(udp, *outp, out_len, *inp, in_len)  **      send a command to the reader and gets the answer  **      returns 0 if all goes well; -1 if not  **LOCKED IN  */intrfidtag_xchange (struct usb_dev_handle *udp, char *outp, int out_len, char *inp,	      int in_len){  int bytes_sent;  int bytes_recv;  count++;  if ((bytes_sent =       usb_bulk_write (udp, 0x02, (char *) outp, out_len, 10)) < 0)    {      if ((bytes_sent =	   usb_bulk_write (udp, 0x02, (char *) outp, out_len, 10)) < 0)	{	  perror ("usb_bulk_write");	}    }  if ((bytes_recv = usb_bulk_read (udp, 0x82, (char *) inp, in_len, 10)) < 0)    {      if ((bytes_recv =	   usb_bulk_read (udp, 0x82, (char *) inp, in_len, 100)) < 0)	{	  perror ("usb_bulk_read");	  return (-1);	}    }  return bytes_recv;}

qint32 LibUsb::write(QByteArray *buf, const quint32 bytes){    // check it isn't closed    if (!this->device) return -1;    QString cmd, s;        for (int i=0; i<buf->size(); i++) {            cmd.append(s.sprintf("%02X",(uchar)buf->at(i))+":");        }        cmd.remove(cmd.size()-1, 1); //remove last colon        qDebug() << "Sending" << buf->size() << "bytes:" << cmd;    // we use a non-interrupted write on Linux/Mac since the interrupt    // write block size is incorectly implemented in the version of    // libusb we build with. It is no less efficent.#if defined Q_OS_MAC || WIN32 || __linux__    qint32 rc = usb_bulk_write(this->device, this->writeEndpoint, buf->data(), bytes, USB_TIMEOUT_MSEC);#else // Workaround for OSX with the brew libusb package...    qint32 rc = usb_bulk_write(this->device, this->writeEndpoint, buf->constData(), bytes, USB_TIMEOUT_MSEC);#endif    if (rc < 0)    {        if (rc == -110)            qDebug() << "Timeout";        else if (rc == -2)            qCritical() << "EndPoint not found";        else            qCritical() << "usb_interrupt_write Error writing: "<< usb_strerror();    }    return rc;}

void write_configuration_block_USB500( usb_dev_handle *udev, configurationBlock *cblock ){  __u8 send_configuration[3] = {0x01, 0xff, 0xff}; // Send Configuration String  __u8 acknowledge = 0x0;                          // Acknowledge   unsigned int size = 0;  int ret;  /* Determine the size of the Configuration Block */  switch(cblock->type) {      case 0x1:                      // EL-USB-1 Temperature Logger Packet size 64 bytes      case 0x2:                      // EL-USB-1 Temperature Logger Packet size 64 bytes      send_configuration[1] = 0x40;  // Low Byte      send_configuration[2] = 0x00;  // High Byte      size = 64;      break;        case 0x3:                        // EL-USB-2 Temperature/Humidity Logger Packet size 128 bytes      send_configuration[1] = 0x80;  // Low Byte      send_configuration[2] = 0x00;  // High Byte      size = 128;      break;        case 0x4:                        // EL-USB-3 Voltage Logger 256 bytes    case 0x6:                        // EL-USB-3 Voltage Logger 256 bytes    case 0x5:                        // EL-USB-4 Current Logger 256 bytes    case 0x7:                        // EL-USB-4 Current Logger 256 bytes      send_configuration[1] = 0x00;  // Low Byte      send_configuration[2] = 0x01;  // High Byte      size = 256;      break;      default:    printf("Unknown type device = %d/n", cblock->type);    return;    break;  }  unlock_device_USB500(udev);  ret = usb_bulk_write(udev, USB_ENDPOINT_OUT | 2,  (char *) send_configuration, 3, USB500_WAIT_WRITE);  if (ret < 0) {    perror("Error in sending configuration acknowledgement (Bulk Write)");  }  ret = usb_bulk_write(udev, USB_ENDPOINT_OUT | 2,  (char *) cblock, size, USB500_WAIT_WRITE);  if (ret < 0) {    perror("Error in sending configuration block (Bulk Write)");  }  acknowledge = 0x0;  do {    ret = usb_bulk_read(udev, USB_ENDPOINT_IN|2, (char *) &acknowledge, 1, USB500_WAIT_READ);  } while (acknowledge != 0xff);  lock_device_USB500(udev);}

static int wrap_scsi(DPFContext * h, unsigned char *cmd, int cmdlen, char out,		     unsigned char *data, unsigned long block_len){    int len;    int ret;    static unsigned char ansbuf[13];	// Do not change size.    g_buf[14] = cmdlen;    memcpy(&g_buf[15], cmd, cmdlen);    g_buf[8] = block_len;    g_buf[9] = block_len >> 8;    g_buf[10] = block_len >> 16;    g_buf[11] = block_len >> 24;    ret = usb_bulk_write(h->udev, ENDPT_OUT, (const char *) g_buf, sizeof(g_buf), 1000);    if (ret < 0)	return ret;    if (out == DIR_OUT) {	if (data) {	    ret = usb_bulk_write(h->udev, ENDPT_OUT, (const char *) data, block_len, 3000);	    if (ret != (int) block_len) {		fprintf(stderr, "dpf_ax ERROR: bulk write./n");		return ret;	    }	}    } else if (data) {	ret = usb_bulk_read(h->udev, ENDPT_IN, (char *) data, block_len, 4000);	if (ret != (int) block_len) {	    fprintf(stderr, "dpf_ax ERROR: bulk read./n");	    return ret;	}    }    // get ACK:    len = sizeof(ansbuf);    int retry = 0;    int timeout = 0;    do {	timeout = 0;	ret = usb_bulk_read(h->udev, ENDPT_IN, (char *) ansbuf, len, 5000);	if (ret != len) {	    fprintf(stderr, "dpf_ax ERROR: bulk ACK read./n");	    timeout = 1;	}	retry++;    } while (timeout && retry < 5);    if (strncmp((char *) ansbuf, "USBS", 4)) {	fprintf(stderr, "dpf_ax ERROR: got invalid reply/n.");	return -1;    }    // pass back return code set by peer:    return ansbuf[12];}

int emulate_scsi(usb_dev_handle *dev, unsigned char *cmd, int cmdlen, char out,	unsigned char *data, unsigned long block_len){	int len;	int ret;	static unsigned char ansbuf[13]; // Do not change size.	g_buf[14] = cmdlen;	memcpy(&g_buf[15], cmd, cmdlen);	g_buf[8] = block_len;	g_buf[9] = block_len >> 8;	g_buf[10] = block_len >> 16;	g_buf[11] = block_len >> 24;	ret = usb_bulk_write(dev, ENDPT_OUT, g_buf, sizeof(g_buf), 1000);	if (ret < 0) return ret;	if (out == DIR_OUT) {		if (data) {			ret = usb_bulk_write(dev, ENDPT_OUT, (const char* )data,					block_len, 3000);			if (ret != block_len) {				perror("bulk write");				return ret;			}		}	} else if (data) {		ret = usb_bulk_read(dev, ENDPT_IN, (char *) data, block_len, 4000);		if (ret != block_len) {			perror("bulk data read");		}	}	// get ACK:	len = sizeof(ansbuf);	int retry = 0;	do {		ret = usb_bulk_read(dev, ENDPT_IN, (char *) ansbuf, len, 5000);		if (ret != len) {			perror("bulk ACK read");			ret = DEVERR_TIMEOUT;		}		retry++;	} while (ret == DEVERR_TIMEOUT && retry < 5);	if (strncmp((char *) ansbuf, "USBS", 4)) {		return handle_error("Got invalid reply/n");	}	// pass back return code set by peer:	return ansbuf[12];}

intpn53x_usb_bulk_write (struct pn53x_usb_data *data, uint8_t abtTx[], const size_t szTx, const int timeout){  LOG_HEX ("TX", abtTx, szTx);  int res = usb_bulk_write (data->pudh, data->uiEndPointOut, (char *) abtTx, szTx, timeout);  if (res > 0) {    // HACK This little hack is a well know problem of USB, see http://www.libusb.org/ticket/6 for more details    if ((res % data->uiMaxPacketSize) == 0) {      usb_bulk_write (data->pudh, data->uiEndPointOut, "/0", 0, timeout);    }  } else {    log_put (LOG_CATEGORY, NFC_PRIORITY_ERROR, "Unable to write to USB (%s)", _usb_strerror (res));  }  return res;}

int send_usb(const char *msg, struct my_usb_device *mydev, struct fpga_packet_header *phead, int len, int timeout){	char	*p = (char *)phead;	int	ret;	if(verbose >= LOG_DEBUG)		dump_packet(msg, p, len);	if(mydev->my_ep_out & USB_ENDPOINT_IN) {		ERR("send_usb called with an input endpoint 0x%x/n", mydev->my_ep_out);		return -EINVAL;	}	ret = usb_bulk_write(mydev->handle, mydev->my_ep_out, p, len, timeout);	if(ret < 0) {		/*		 * If the device was gone, it may be the		 * result of renumeration. Ignore it.		 */		if(ret != -ENODEV) {			ERR("bulk_write to endpoint 0x%x failed: %s/n", mydev->my_ep_out, usb_strerror());			dump_packet("send_usb[ERR]", p, len);		} else {			disconnected = 1;			my_usb_device_cleanup(mydev);		}		return ret;	} else if(ret != len) {		ERR("bulk_write to endpoint 0x%x short write: %s/n", mydev->my_ep_out, usb_strerror());		dump_packet("send_usb[ERR]", p, len);		return -EFAULT;	}	return ret;}

u8 usb_storage_read_capacity(u8 device){	/* send cwb "usbc" */	u8 tmp[8];	u8 i;	usb_storage_cbw  * cbw = (usb_storage_cbw*)malloc(sizeof(usb_storage_cbw));	usb_control_msg(massstorage[device], 0x02,1,0, 0x8100, 0,tmp, 0);	cbw->dCBWSignature= 0x43425355;	cbw->dCBWTag=0x826A6008;	cbw->dCBWDataTransferLength=0x00000008;	cbw->bCWDFlags=0x80;	cbw->bCBWLun=0x00;	cbw->bCBWCBLength=0x0A;	for(i=0;i<16;i++)		cbw->CBWCB[i]=0x00;	cbw->CBWCB[0]=0x25; // 0x12 = INQUIRY	usb_bulk_write(massstorage[device], 2, (u8*)cbw, 31, 0); 	usb_bulk_read(massstorage[device], 1, (u8*)cbw, 8, 0); 	usb_bulk_read(massstorage[device], 1, (u8*)cbw, 13, 0); 	free(cbw);	return 0;}

/* * ep1 commands are up to USB_EP1OUT_SIZE bytes in length. * This function takes care of zeroing the unused bytes before sending the packet. * Any reply packet is not handled by this function. */static int ep1_generic_commandl(usb_dev_handle *pHDev_param, size_t length, ...){	uint8_t usb_buffer[USB_EP1OUT_SIZE];	uint8_t *usb_buffer_p;	va_list ap;	int usb_ret;	if (length > sizeof(usb_buffer))		length = sizeof(usb_buffer);	usb_buffer_p = usb_buffer;	va_start(ap, length);	while (length > 0) {		*usb_buffer_p++ = va_arg(ap, int);		length--;	}	memset(		usb_buffer_p,		0,		sizeof(usb_buffer) - (usb_buffer_p - usb_buffer)		);	usb_ret = usb_bulk_write(			pHDev_param,			USB_EP1OUT_ADDR,			(char *)usb_buffer, sizeof(usb_buffer),			USB_TIMEOUT_MS			);	return usb_ret;}

int main(int argc, char *argv[]) {	if (2 != argc) {		usage();		return 1;	}	struct usb_dev_handle *hdev = open_port();	if (!hdev) {		return 1;	}	unsigned int len = 0;	unsigned char* write_buf = prepare_write_buf(argv[1], &len);	if (NULL == write_buf)		return 1;	unsigned int remain = len;	unsigned int towrite;	printf("Writing data .../n");	while (remain) {		towrite = remain > 512 ? 512 : remain;		if (towrite != usb_bulk_write(hdev, 0x03, write_buf + (len - remain),				towrite, 3000)) {			perror("usb_bulk_write failed");			break;		}		remain -= towrite;		printf("/r%d%/t %d bytes     ", (len - remain) * 100 / len, len				- remain);		fflush(stdout);	}	if (0 == remain)		printf("Done!/n");	return 0;}

int xusb_send(struct xusb *xusb, char *buf, int len, int timeout){	int		ret;	dump_packet(LOG_DEBUG, DBG_MASK, __FUNCTION__, buf, len);	if(EP_OUT(xusb) & USB_ENDPOINT_IN) {		ERR("%s called with an input endpoint 0x%x/n", __FUNCTION__, EP_OUT(xusb));		return -EINVAL;	}	ret = usb_bulk_write(xusb->handle, EP_OUT(xusb), buf, len, timeout);	if(ret < 0) {		/*		 * If the device was gone, it may be the		 * result of renumeration. Ignore it.		 */		if(ret != -ENODEV) {			ERR("bulk_write to endpoint 0x%x failed: (%d) %s/n",				EP_OUT(xusb), ret, usb_strerror());			dump_packet(LOG_ERR, DBG_MASK, "xbus_send[ERR]", buf, len);			//exit(2);		} else {			DBG("bulk_write to endpoint 0x%x got ENODEV/n", EP_OUT(xusb));			xusb_close(xusb);		}		return ret;	} else if(ret != len) {		ERR("bulk_write to endpoint 0x%x short write: (%d) %s/n",			EP_OUT(xusb), ret, usb_strerror());		dump_packet(LOG_ERR, DBG_MASK, "xbus_send[ERR]", buf, len);		return -EFAULT;	}	return ret;}

int musb_write(MUSB_INTERFACE *musb_interface, int endpoint, const void *buf, int count, int timeout){   int n_written;#if defined(HAVE_LIBUSB)   n_written = usb_bulk_write(musb_interface->dev, endpoint, (char*)buf, count, timeout);   if (n_written != count) {      fprintf(stderr, "musb_write: requested %d, wrote %d, errno %d (%s)/n", count, n_written, errno, strerror(errno));   }#elif defined(HAVE_LIBUSB10)   int status = libusb_bulk_transfer(musb_interface->dev, endpoint, (unsigned char*)buf, count, &n_written, timeout);   if (n_written != count) {      fprintf(stderr, "musb_write: requested %d, wrote %d, errno %d (%s)/n", count, n_written, status, strerror(status));   }#elif defined(OS_DARWIN)   IOReturn status;   IOUSBInterfaceInterface182 **interface = (IOUSBInterfaceInterface182 **)musb_interface->interface;   status = (*interface)->WritePipeTO(interface, endpoint, buf, count, 0, timeout);   if (status != 0) {      fprintf(stderr, "musb_write: WritePipe() status %d 0x%x/n", status, status);      return -1;   }   n_written = count;#elif defined(_MSC_VER)   WriteFile(musb_interface->whandle, buf, count, &n_written, NULL);#endif   //fprintf(stderr, "musb_write(ep %d, %d bytes) (%s) returns %d/n", endpoint, count, buf, n_written);    return n_written;}

int write_cmd(usb_dev_handle *udev, unsigned char *cmd, int read){	int ret=0, i=0;	unsigned char receive_data[1024];	unsigned char interrupt_data;	for (i=0; i<1024; i++)		receive_data[i] = 0x00;	printf("write_cmd/n");	ret = usb_bulk_write(udev, 0x02, cmd, sizeof(cmd), 10000);	if (ret != sizeof(cmd))		printf("Error!/n");	//if (read)	{		ret = usb_bulk_read(udev, 0x81, receive_data, sizeof(receive_data), 10000);		mcrw_debug(receive_data, ret);	}	//else	{		ret = usb_interrupt_read(udev, 0x83, &interrupt_data, 1, 10000);		mcrw_debug(&interrupt_data, ret);	}	return 0;}

int grecko_read(unsigned long addr, unsigned char *buf, int size){	unsigned char data[8];	unsigned long addr2 = addr+size;	unsigned char *ptr = (unsigned char*) &addr;	int i, ret;	addr = htonl(addr - (addr%4));	addr2 = htonl(addr2 - (addr2%4));	/* read command */	grecko_send_command(4);	/* memory offsets */	memcpy(data, addr, 4);	memcpy(data, addr2, 4);	usb_bulk_write(dev, ep, (unsigned char *)&data, 8, timeout);	/* data read */	ret = usb_bulk_read(dev, ep, (unsigned char *)buf, 4096, timeout);	if (ret < 0)		return -1;	for(i=0;i<ret;i++) {		printf("%02x ", readbuf[i]);	}	return ret;}

/* Optimised packet handling to reduce overhead during bulk file transfers. */int send_cancel(libusb_device_handle* fd){	trace(3, printf("send_cancel/n"));    return usb_bulk_write(fd, 0x01, cancel_packet, 8, default_timeout());}

int cable_usbblaster_out(uint8_t value){  int             rv;                  // to catch return values of functions  char out;  int err = APP_ERR_NONE;  // open the device, if necessary  if(h_device == NULL) {    rv = cable_usbblaster_open_cable();    if(rv != APP_ERR_NONE) return rv;  }  out = (USBBLASTER_CMD_OE | USBBLASTER_CMD_nCS);  // Set output enable (appears necessary) and nCS (necessary for byte-shift reads)  // Translate to USB blaster protocol  // USB-Blaster has no TRST pin  if(value & TCLK_BIT)    out |= USBBLASTER_CMD_TCK;  if(value & TDI_BIT)    out |= USBBLASTER_CMD_TDI;  if(value & TMS_BIT)    out |= USBBLASTER_CMD_TMS;  rv = usb_bulk_write(h_device, EP2, &out, 1, USB_TIMEOUT);  if (rv != 1){    fprintf(stderr, "/nFailed to write to the FIFO (rv = %d):/n%s", rv, usb_strerror());    err |= APP_ERR_USB;  }  return err;}

int lothar_usb_write(void *connection, uint8_t const  *data, size_t len){  int status = usb_bulk_write((usb_dev_handle *)connection, USB_ENDPOINT_OUT | 1, (char *)data, len, 0);  if(status < 0)    LOTHAR_RETURN_ERROR(LOTHAR_ERROR_NXT_WRITE_ERROR);  return status;}

int TCD2Usb::TCD2Usb_bulk_write_EP1OUT(const char *buf, size_t nbytes){   int retval = 0;    // EP1OUT only takes 64 bytes total  if( nbytes > 64 )    {      // printf("TCD2Usb::TCD2Usb_bulk_write_EP1OUT: > 64 bytes for EP1OUT write/n");      return -TCD2USB_WRITE_TOO_MANY_BYTES_ERR;    }    // Check if TCD USB device is open  if(!IsOpen())    {      // printf("TCD2Usb::TCD2Usb_bulk_write_EP1OUT: TCD2 USB device not open!/n");      return -TCD2USB_OPEN_ERR;    }    // Check if TCD USB device is claimed  if(!IsClaimed())    {      // printf("TCD2Usb::TCD2Usb_bulk_write_EP1IN: TCD2 USB device not claimed!/n");      return -TCD2USB_CLAIM_ERR;    }    // Write to EP1OUT  if( (retval = usb_bulk_write(usbhdl,1,(char*)buf,nbytes,10)) < 0 )// timeout is ms      {      // printf("TCD2Usb::TCD2Usb_bulk_write: Write attempt failed. Returned %d/n",retval);      // printf("usbhdl = %d/n",usbhdl);      return -TCD2USB_WRITE_ERR;    }  //printf("Was able to write/n");  return 0;}

int camera_bulk_write(usb_dev_handle *handle, char *buffer, int length){  if(verbose)    fprintf(stderr, "CAMERA BULK WRITE %x/n", length);  return usb_bulk_write(handle, CAMERA_BULK_WRITE_EP, buffer, length,			USB_TIMEOUT);}

void sendBuffer(char* buffer, size_t size) {	OpenIBootCmd cmd;	cmd.command = OPENIBOOTCMD_SENDCOMMAND;	cmd.dataLen = size;	usb_interrupt_write(device, 4, (char*) (&cmd), sizeof(OpenIBootCmd), 1000);	while(1) {		usb_interrupt_read(device, 3, (char*) (&cmd), sizeof(OpenIBootCmd), 1000);		if(cmd.command == OPENIBOOTCMD_SENDCOMMAND_GOAHEAD)			break;	}	int toSend = 0;	while(size > 0) {		if(size <= MAX_TO_SEND)			toSend = size;		else			toSend = MAX_TO_SEND;		usb_bulk_write(device, 2, buffer, toSend, 1000);		buffer += toSend;		size -= toSend;	}}

static vsf_err_t versaloon_libusb_comm_transact(uint8_t *buffer_out,        uint16_t out_len, uint8_t *buffer_in, uint16_t *in_len){    int ret;    ret = usb_bulk_write(versaloon_device_handle, usb_param_epout(),                         (char *)buffer_out, out_len, versaloon_to);    if (ret != out_len)    {        LOG_ERROR(ERRMSG_FAILURE_OPERATION_ERRSTRING, "send usb data",                  usb_strerror());        return ERRCODE_FAILURE_OPERATION;    }    if (in_len != NULL)    {        ret = usb_bulk_read(versaloon_device_handle, usb_param_epin(),                            (char *)buffer_in, *in_len, versaloon_to);        if (ret > 0)        {            *in_len = (uint16_t)ret;            return VSFERR_NONE;        }        else        {            LOG_ERROR(ERRMSG_FAILURE_OPERATION_ERRSTRING, "receive usb data",                      usb_strerror());            return VSFERR_FAIL;        }    }    else    {        return VSFERR_NONE;    }}

void SendCommand(UsbCommand *c){  int ret;#if 0  printf("Sending %d bytes/n", sizeof(UsbCommand));#endif  ret = usb_bulk_write(devh, 0x01, (char*)c, sizeof(UsbCommand), 1000);  if (ret<0) {    error_occured = 1;    if (return_on_error)      return;    fprintf(stderr, "write failed: %s!/nTrying to reopen device.../n",      usb_strerror());    if (devh) {      usb_close(devh);      devh = NULL;    }    while(!OpenProxmark(0)) { sleep(1); }    printf(PROXPROMPT);    fflush(NULL);    return;  }}

int LibUsb::write(char *buf, int bytes, int timeout){    // check it isn't closed    if (!device) return -1;    int rc;    if (OperatingSystem == WINDOWS) {        rc = usb_interrupt_write(device, writeEndpoint, buf, bytes, 1000);    } else {        // we use a non-interrupted write on Linux/Mac since the interrupt        // write block size is incorrectly implemented in the version of        // libusb we build with. It is no less efficient.        rc = usb_bulk_write(device, writeEndpoint, buf, bytes, timeout);    }    if (rc < 0)    {        // Report timeouts - previously we ignored -110 errors. This masked a serious        // problem with write on Linux/Mac, the USB stick needed a reset to avoid        // these error messages, so we DO report them now        qDebug()<<"usb_interrupt_write Error writing ["<<rc<<"]: "<< usb_strerror();    }    return rc;}

/***************************************************************************** * *					WriteUSB * ****************************************************************************/status_t WriteUSB(unsigned int reader_index, unsigned int length,	unsigned char *buffer){	int rv;	char debug_header[] = "-> 121234 ";	(void)snprintf(debug_header, sizeof(debug_header), "-> %06X ",		(int)reader_index);	DEBUG_XXD(debug_header, buffer, length);	rv = usb_bulk_write(usbDevice[reader_index].handle,		usbDevice[reader_index].bulk_out, (char *)buffer, length,		USB_WRITE_TIMEOUT);	if (rv < 0)	{		DEBUG_CRITICAL4("usb_bulk_write(%s/%s): %s",			usbDevice[reader_index].dirname, usbDevice[reader_index].filename,			strerror(errno));		if (ENODEV == errno)			return STATUS_NO_SUCH_DEVICE;		return STATUS_UNSUCCESSFUL;	}	return STATUS_SUCCESS;} /* WriteUSB */

unsigned char *mc2rw_read_page(usb_dev_handle *udev, int page){	int i=0, p=0, wret=0, rret=0;	int prev_size;	static unsigned char data_p[USB_FRAMESIZE*4], temp_data[USB_FRAMESIZE];	struct psx_usb_read_receive_buf receive_data;	mcrw_addr_debug(page);	mc2rw_read_set_sector(udev, page);	/* read data */	printf("Reading Data/n");	for (p=0; p<4; p++)	{			unsigned char send_data[148] = {0xaa, 0x42, 0x90, 0x00, 0x81, 0x43, 0x80, 0x00, 0x00};		//mcrw_debug(send_data, sizeof(send_data));		wret = usb_bulk_write(udev, 0x02, send_data, sizeof(send_data), 1000);		rret = usb_bulk_read(udev, 0x81, temp_data, sizeof(temp_data), 1000);				//printf("segment: &(data_p[%d]) = 0x%X/n", USB_FRAMESIZE*p, &(data_p[USB_FRAMESIZE*p]));		memcpy(&(data_p[USB_FRAMESIZE*p]), temp_data, rret);	}	mcrw_debug(data_p, sizeof(data_p));	mc2rw_read_ecc(udev);	mc2rw_read_commit(udev);	return data_p;}

grub_usb_err_tgrub_usb_bulk_write (grub_usb_device_t dev,		     int endpoint, grub_size_t size, char *data){  usb_dev_handle *devh;  struct usb_device *d = dev->data;  devh = usb_open (d);  if (usb_claim_interface (devh, 0) < 0)    goto fail;  if (usb_bulk_write (devh, endpoint, data, size, 20) < 0)    goto fail;  if (usb_release_interface (devh, 0) < 0)    goto fail;  usb_close (devh);  return GRUB_USB_ERR_NONE; fail:  usb_close (devh);  return GRUB_USB_ERR_STALL;}

u8 usb_storage_inquiry(u8 device){	/* send cwb "usbc" */		usb_storage_cbw *cbw = (usb_storage_cbw*)malloc(sizeof(usb_storage_cbw));	cbw->dCBWSignature= 0x43425355;	cbw->dCBWTag=0x826A6008;	cbw->dCBWDataTransferLength=0x00000024;	cbw->bCWDFlags=0x80;	cbw->bCBWLun=0x00;	cbw->bCBWCBLength=0x01;	u8 i;	for(i=0;i<16;i++)		cbw->CBWCB[i]=0x00;	cbw->CBWCB[0]=0x12; // 0x12 = INQUIRY	usb_bulk_write(massstorage[device], 2, (u8*)cbw, 31, 0); 	usb_bulk_read(massstorage[device], 1, (u8*)cbw, 36, 0); 	usb_bulk_read(massstorage[device], 1, (u8*)cbw, 13, 0); 	free(cbw);	return 0;}

 void test_bulk_transfer(usb_dev_handle *dev) {   int r,i;   char answer[reqBulkLen];   char question[reqBulkLen];   for (i=0;i<reqBulkLen; i++) question[i]=i;   r = usb_bulk_write(dev, endpoint_Bulk_out, question, reqBulkLen, timeout);   if( r < 0 )   {	  perror("USB bulk write"); bad("USB write failed");    }   r = usb_bulk_read(dev, endpoint_Bulk_in, answer, reqBulkLen, timeout);   if( r != reqBulkLen )   {	  perror("USB bulk read"); bad("USB read failed");    }//   for (i=0;i<reqBulkLen;i++) printf("%i, %i, /n",question[i],answer[i]);	for(i = 0;i < reqBulkLen; i++) {		if(i%8 == 0)			printf("/n");		printf("%02x, %02x; ",question[i],answer[i]);	}	printf("/n");//   usb_set_altinterface(dev, 0);   usb_release_interface(dev, 0); }

/***************************************************************************** * *					WriteUSB * ****************************************************************************/status_t WriteUSB(unsigned int reader_index, unsigned int length,	unsigned char *buffer){	int rv;	char debug_header[] = "-> 121234 ";	int pos;	int len;	int delayed = FALSE;	(void)snprintf(debug_header, sizeof(debug_header), "-> %06X ",		(int)reader_index);	DEBUG_XXD(debug_header, buffer, length);	// Fix APG8201 and ACR85 ICC cannot receive command properly	// Add delay for APG8201 and ACR85 ICC	if ((usbDevice[reader_index].ccid.readerID == ACS_APG8201) ||		(usbDevice[reader_index].ccid.readerID == ACS_ACR85_PINPAD_READER_ICC))	{		delayed = TRUE;	}	// Send command by dividing number of packets	pos = 0;	while (length > 0)	{		if (length > usbDevice[reader_index].bulkOutMaxPacketSize)			len = usbDevice[reader_index].bulkOutMaxPacketSize;		else			len = length;		rv = usb_bulk_write(usbDevice[reader_index].handle,			usbDevice[reader_index].bulk_out, (char *)buffer + pos, len,			USB_WRITE_TIMEOUT);		if (rv < 0)		{			DEBUG_CRITICAL4("usb_bulk_write(%s/%s): %s",				usbDevice[reader_index].dirname, usbDevice[reader_index].filename,				strerror(errno));			if (ENODEV == errno)				return STATUS_NO_SUCH_DEVICE;			return STATUS_UNSUCCESSFUL;		}		if (delayed)		{			// Delay 10 ms			if (length > usbDevice[reader_index].bulkOutMaxPacketSize)				usleep(10 * 1000);		}		pos += len;		length -= len;	}	return STATUS_SUCCESS;} /* WriteUSB */