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

// Call usb_read using a buffer having a multiple of usb_get_max_packet_size() bytes// to avoid overflow. See http://libusb.sourceforge.net/api-1.0/packetoverflow.html.static int UsbReadPayload(usb_handle* h, apacket* p) {    D("UsbReadPayload(%d)", p->msg.data_length);    if (p->msg.data_length > MAX_PAYLOAD) {        return -1;    }#if CHECK_PACKET_OVERFLOW    size_t usb_packet_size = usb_get_max_packet_size(h);    // Round the data length up to the nearest packet size boundary.    // The device won't send a zero packet for packet size aligned payloads,    // so don't read any more packets than needed.    size_t len = p->msg.data_length;    size_t rem_size = len % usb_packet_size;    if (rem_size) {        len += usb_packet_size - rem_size;    }    p->payload.resize(len);    int rc = usb_read(h, &p->payload[0], p->payload.size());    if (rc != static_cast<int>(p->msg.data_length)) {        return -1;    }    p->payload.resize(rc);    return rc;#else    p->payload.resize(p->msg.data_length);    return usb_read(h, &p->payload[0], p->payload.size());#endif}

void usbd_on_out_readed(EP_CLASS ep, void* param){	USBD* usbd = (USBD*)param;#if (USB_DEBUG_FLOW)	printf("USB EP0 OUT RX/n/r");#endif	switch (usbd->setup_state)	{	case USB_SETUP_STATE_DATA_OUT:		usbd->setup_state = USB_SETUP_STATE_STATUS_IN;		usb_write(usbd->idx, EP_IN0, NULL, 0);		break;	case USB_SETUP_STATE_STATUS_OUT:		usbd->setup_state = USB_SETUP_STATE_REQUEST;		usb_read(USB_1, EP_OUT0, usbd->control.buf, usbd->ep0_size);		usbd_request_completed(usbd);		break;	default:		usbd->setup_state = USB_SETUP_STATE_REQUEST;		usb_read(USB_1, EP_OUT0, usbd->control.buf, usbd->ep0_size);#if (USB_DEBUG_ERRORS)		dbg_invalid_state(USB_SETUP_STATE_DATA_OUT, usbd->setup_state);#endif		break;	}}

/** Read to request from FIFO (max read == bytes in fifo) *  Return:  0 = still running, 1 = completed, negative = errno *  NOTE: INDEX register must be set for EP */static int read_fifo(struct lh7a40x_ep *ep, struct lh7a40x_request *req){	u32 csr;	u8 *buf;	unsigned bufferspace, count, is_short;	volatile u32 *fifo = (volatile u32 *)ep->fifo;	/* make sure there's a packet in the FIFO. */	csr = usb_read(ep->csr1);	if (!(csr & USB_OUT_CSR1_OUT_PKT_RDY)) {		DEBUG("%s: Packet NOT ready!/n", __func__);		return -EINVAL;	}	buf = req->req.buf + req->req.actual;	prefetchw(buf);	bufferspace = req->req.length - req->req.actual;	/* read all bytes from this packet */	count = usb_read(USB_OUT_FIFO_WC1);	req->req.actual += min(count, bufferspace);	is_short = (count < ep->ep.maxpacket);	DEBUG("read %s %02x, %d bytes%s req %p %d/%d/n",	      ep->ep.name, csr, count,	      is_short ? "/S" : "", req, req->req.actual, req->req.length);	while (likely(count-- != 0)) {		u8 byte = (u8) (*fifo & 0xff);		if (unlikely(bufferspace == 0)) {			/* this happens when the driver's buffer			 * is smaller than what the host sent.			 * discard the extra data.			 */			if (req->req.status != -EOVERFLOW)				printk(KERN_WARNING "%s overflow %d/n",				       ep->ep.name, count);			req->req.status = -EOVERFLOW;		} else {			*buf++ = byte;			bufferspace--;		}	}	usb_clear(USB_OUT_CSR1_OUT_PKT_RDY, ep->csr1);	/* completion */	if (is_short || req->req.actual == req->req.length) {		done(ep, req, 0);		usb_set(USB_OUT_CSR1_FIFO_FLUSH, ep->csr1);		if (list_empty(&ep->queue))			pio_irq_disable(ep_index(ep));		return 1;	}	/* finished that packet.  the next one may be waiting... */	return 0;}

static int remote_read(apacket *p, atransport *t){    if(usb_read(t->usb, &p->msg, sizeof(amessage))){        D("remote usb: read terminated (message)/n");        return -1;    }    fix_endians(p);    if(check_header(p)) {        D("remote usb: check_header failed/n");        return -1;    }    if(p->msg.data_length) {        if(usb_read(t->usb, p->data, p->msg.data_length)){            D("remote usb: terminated (data)/n");            return -1;        }    }    if(check_data(p)) {        D("remote usb: check_data failed/n");        return -1;    }    return 0;}

static u8 read_epcs(struct rt_ep_struct *rt_ep){	int idx = EP_NO(rt_ep);	int dir = EP_DIR(rt_ep);	if(idx == 0)		return usb_read(EP0CS);	return (dir == EP_IN ? usb_read(0x7 + idx*8) : usb_read(0x3 + idx*8) );}

/** Read to request from FIFO (max read == bytes in fifo) *  Return:  0 = still running, 1 = completed, negative = errno */static int read_fifo(struct elfin_ep *ep, struct elfin_request *req){	u32 csr;	u8 *buf;	unsigned bufferspace, count, is_short;	void* fifo = ep->fifo;	/* make sure there's a packet in the FIFO. */	csr = usb_read(ep->csr1, ep_index(ep));	if (!(csr & S3C2410_UDC_OCSR1_PKTRDY)) {		DPRINTK("%s: Packet NOT ready!/n", __FUNCTION__);		return -EINVAL;	}	buf = req->req.buf + req->req.actual;	prefetchw(buf);	bufferspace = req->req.length - req->req.actual;	/* read all bytes from this packet */	count = (( (usb_read(S3C2410_UDC_OUT_FIFO_CNT2_REG, ep_index(ep)) & 0xff ) << 8) | (usb_read(S3C2410_UDC_OUT_FIFO_CNT1_REG, ep_index(ep)) & 0xff));	req->req.actual += min(count, bufferspace);	is_short = (count < ep->ep.maxpacket);	DPRINTK("read %s %02x, %d bytes%s req %p %d/%d/n",	      ep->ep.name, csr, count,	      is_short ? "/S" : "", req, req->req.actual, req->req.length);	while (likely(count-- != 0)) {		u8 byte = (u8) __raw_readl(fifo);		if (unlikely(bufferspace == 0)) {			/* this happens when the driver's buffer			 * is smaller than what the host sent.			 * discard the extra data.			 */			if (req->req.status != -EOVERFLOW)				printk("%s overflow %d/n", ep->ep.name, count);			req->req.status = -EOVERFLOW;		} else {			*buf++ = byte;			bufferspace--;		}	}	usb_clear(S3C2410_UDC_OCSR1_PKTRDY, ep->csr1, ep_index(ep));	/* completion */	if (is_short || req->req.actual == req->req.length) {		done(ep, req, 0);		return 1;	}	/* finished that packet.  the next one may be waiting... */	return 0;}

static u16 read_outbc(int epnum){	u16 low, high = 0;	if(epnum == 0){ /* EP0 */		low = usb_read(OUT0BC);	}else{		low = usb_read(epnum * 8);		high = usb_read((epnum * 8)+1);	}	return (low | (high << 8));}

static int usb_boot(usb_handle *usb, int fastboot_mode,	     void *data, unsigned sz,	     void *data2, unsigned sz2){	uint32_t msg_boot = 0xF0030002;	uint32_t msg_size = sz;	uint32_t param = 0;	fprintf(stderr, "sending 2ndstage to target.../n");	usb_write(usb, &msg_boot, sizeof(msg_boot));	usb_write(usb, &msg_size, sizeof(msg_size));	usb_write(usb, data, sz);	if ((data2) || (fastboot_mode > 0)) {		fprintf(stderr,"waiting for 2ndstage response.../n");		usb_read(usb, &msg_size, sizeof(msg_size));		if (msg_size != 0xaabbccdd) {			fprintf(stderr, "unexpected 2ndstage response/n");			return -1;		}		if (fastboot_mode > 2) {			param = fastboot_mode;			usb_write(usb, &param, sizeof(param));		}		/* In fastboot mode, we stay in SRAM so don't		download data2 to the target. Return back from here */		if (fastboot_mode == 1) {			fprintf(stderr, "received 2ndstage response.../n");			return 0;		}		msg_size = sz2;		usb_write(usb, &msg_size, sizeof(msg_size));		usb_read(usb, &param, sizeof(param));		if (param != 0xaabbccdd) {			fprintf(stderr, "unexpected 2ndstage response/n");			return -1;		}		fprintf(stderr, "sending image to target...size "				"(%d-B/%d-KB/%d-MB)/n", msg_size,				msg_size/1024, msg_size/(1024 * 1024));		usb_write(usb, data2, sz2);	}		return 0;}

/* ******************************************************************************* * Data tansfer over USB functions ******************************************************************************* */static int read_ep0_fifo(struct rt_ep_struct *rt_ep, struct rt_request *req){	u8	*buf;	int	byte_count, req_bufferspace, count, i;DBG;	if(!in_irq())		FATAL_ERROR("not irq context.");	byte_count = read_outbc(EP_NO(rt_ep));	req_bufferspace = req->req.length - req->req.actual;	buf = req->req.buf + req->req.actual;	if(!req_bufferspace)		FATAL_ERROR("zlp");	if(byte_count > req_bufferspace)		FATAL_ERROR("buffer overflow, byte_count=%d, req->req.length=%d, req->req.actual=%d/n", byte_count, req->req.length ,req->req.actual);	count = min(byte_count, req_bufferspace);	for (i = 0; i < count; i++){		*buf = usb_read(EP0OUTDAT+i);		buf++;	}	req->req.actual += count;	return count;}

u16 cdc_rx(u8 *buf, u16 size){  // The first byte is a control byte.  if(cdc_rx_size() <= size){    cdc_rx_need_skip = 1;  }  return usb_read(buf, size, CDC_DATA_EP_OUT);}

/** * lh7a40x_in_epn - handle IN interrupt */static void lh7a40x_in_epn(struct lh7a40x_udc *dev, u32 ep_idx, u32 intr){	u32 csr;	struct lh7a40x_ep *ep = &dev->ep[ep_idx];	struct lh7a40x_request *req;	usb_set_index(ep_idx);	csr = usb_read(ep->csr1);	DEBUG("%s: %d, csr %x/n", __FUNCTION__, ep_idx, csr);	if (csr & USB_IN_CSR1_SENT_STALL) {		DEBUG("USB_IN_CSR1_SENT_STALL/n");		usb_set(USB_IN_CSR1_SENT_STALL /*|USB_IN_CSR1_SEND_STALL */ ,			ep->csr1);		return;	}	if (!ep->desc) {		DEBUG("%s: NO EP DESC/n", __FUNCTION__);		return;	}	if (list_empty(&ep->queue))		req = 0;	else		req = list_entry(ep->queue.next, struct lh7a40x_request, queue);	DEBUG("req: %p/n", req);	if (!req)		return;	write_fifo(ep, req);}

/** * elfin_in_epn - handle IN interrupt */static void elfin_in_epn(struct elfin_udc *dev, u32 ep_idx){	u32 csr;	struct elfin_ep *ep = &dev->ep[ep_idx];	struct elfin_request *req;	csr = usb_read(ep->csr1, ep_index(ep));	DPRINTK("%s: %d, csr %x/n", __FUNCTION__, ep_idx, csr);	if (csr & S3C2410_UDC_ICSR1_SENTSTL) {		printk("S3C2410_UDC_ICSR1_SENTSTL/n");		usb_set(S3C2410_UDC_ICSR1_SENTSTL /*| S3C2410_UDC_ICSR1_SENDSTL */ ,			ep->csr1, ep_index(ep));		return;	}	if (!ep->desc) {		DPRINTK("%s: NO EP DESC/n", __FUNCTION__);		return;	}	if (list_empty(&ep->queue))		req = 0;	else		req = list_entry(ep->queue.next, struct elfin_request, queue);	DPRINTK("req: %p/n", req);	if (!req)		return;	write_fifo(ep, req);}

int getUSBPacket(int id, struct mechanism *mech){    int result, type;    unsigned char buffer[MAX_IN_LENGTH];    //Read USB Packet    result = usb_read(id,buffer,IN_LENGTH);    // -- Check for read errors --    if (result < 0){      return result;    }    // No data or something. Boo.    else if ((result == 0) || (result != IN_LENGTH))      return -EIO;    // -- Good packet so process it --    type = buffer[0];    //Load in the data from the USB packet    switch (type)      {        //Handle and Encoder USB packet      case ENC:        processEncoderPacket(mech, buffer);        break;      }    return 0;}

void on_msc_sent(EP_CLASS ep, void *param){	USB_MSC* msc = (USB_MSC*)param;	unsigned int block_size;	switch (msc->state)	{	case MSC_STATE_DATA:		queue_release_buffer(msc->queue, msc->current_buf);		msc->current_buf = NULL;		if (msc->scsi_transferred < msc->scsi_requested)		{			ASSERT(!queue_is_empty(msc->queue));			msc->current_buf = queue_pull_ms(msc->queue, INFINITE);			block_size = msc->scsi_requested - msc->scsi_transferred;			if (block_size > msc->block_size)				block_size = msc->block_size;			msc->scsi_transferred += block_size;			usb_write(usbd_get_usb(msc->usbd), EP_IN(msc->ep_num), msc->current_buf, block_size);		}		else			event_set(msc->event);		break;	case MSC_STATE_CSW:		msc->state = MSC_STATE_CSW_SENT;		msc_send_csw(msc);		break;	case MSC_STATE_CSW_SENT:		msc->state = MSC_STATE_CBW;		//same buffer will be used for next cbw		usb_read(usbd_get_usb(msc->usbd), EP_OUT(msc->ep_num), msc->current_buf, CBW_SIZE);		break;	default:		break;	}}

static void rt_ep_irq_disable(struct rt_ep_struct *rt_ep){	u8 reg;	u8 idx = EP_NO(rt_ep);	u8 dir = EP_DIR(rt_ep);	if(idx == 0 /* ep0 */){		usb_write(IN07IEN, (usb_read(IN07IEN) & ~(0x1)) );		usb_write(OUT07IEN, (usb_read(OUT07IEN) & ~(0x1)) );	}else{		reg = usb_read(dir ? IN07IEN : OUT07IEN);		reg = reg & ~(0x1 << idx);		usb_write(dir == EP_IN ? IN07IEN : OUT07IEN, reg);		reg = usb_read(dir ? IN07IEN : OUT07IEN);	}}

static bool hfa_get_header(struct cgpu_info *hashfast, struct hf_header *h, uint8_t *computed_crc){    int amount, ret, orig_len, len, ofs = 0;    cgtimer_t ts_start;    char buf[512];    char *header;    orig_len = len = sizeof(*h);    /* Read for up to 200ms till we find the first occurrence of HF_PREAMBLE     * though it should be the first byte unless we get woefully out of     * sync. */    cgtimer_time(&ts_start);    do {        cgtimer_t ts_now, ts_diff;        cgtimer_time(&ts_now);        cgtimer_sub(&ts_now, &ts_start, &ts_diff);        if (cgtimer_to_ms(&ts_diff) > 200)            return false;        ret = usb_read(hashfast, buf + ofs, len, &amount, C_HF_GETHEADER);        if (unlikely(ret && ret != LIBUSB_ERROR_TIMEOUT))            return false;        ofs += amount;        header = memchr(buf, HF_PREAMBLE, ofs);        if (header)            len -= ofs - (header - buf);    } while (len);    memcpy(h, header, orig_len);    *computed_crc = hfa_crc8((uint8_t *)h);    return true;}

/* *	done - retire a request; caller blocked irqs *  INDEX register is preserved to keep same */static void done(struct lh7a40x_ep *ep, struct lh7a40x_request *req, int status){	unsigned int stopped = ep->stopped;	u32 index;	DEBUG("%s, %p/n", __FUNCTION__, ep);	list_del_init(&req->queue);	if (likely(req->req.status == -EINPROGRESS))		req->req.status = status;	else		status = req->req.status;	if (status && status != -ESHUTDOWN)		DEBUG("complete %s req %p stat %d len %u/%u/n",		      ep->ep.name, &req->req, status,		      req->req.actual, req->req.length);	/* don't modify queue heads during completion callback */	ep->stopped = 1;	/* Read current index (completion may modify it) */	index = usb_read(USB_INDEX);	spin_unlock(&ep->dev->lock);	req->req.complete(&ep->ep, &req->req);	spin_lock(&ep->dev->lock);	/* Restore index */	usb_set_index(index);	ep->stopped = stopped;}

int main(int argc, char **argv){    //Pass Interrupt Signal to our handler	signal(SIGINT, sighandler);	libusb_init(&ctx);	libusb_set_debug(ctx, 3);    //Open Device with VendorID and ProductID	handle = libusb_open_device_with_vid_pid(ctx,				USB_VENDOR_ID, USB_PRODUCT_ID);	if (!handle) {		perror("device not found");		return 1;	}	int r = 1;	//Claim Interface 0 from the device    r = libusb_claim_interface(handle, 0);	if (r < 0) {		fprintf(stderr, "usb_claim_interface error %d/n", r);		return 2;	}	printf("Interface claimed/n");	while (1){		usb_read();//		usb_write();    }    //never reached	libusb_close(handle);	libusb_exit(NULL);	return 0;}

static void lh7a40x_out_epn(struct lh7a40x_udc *dev, u32 ep_idx, u32 intr){	struct lh7a40x_ep *ep = &dev->ep[ep_idx];	struct lh7a40x_request *req;	DEBUG("%s: %d/n", __func__, ep_idx);	usb_set_index(ep_idx);	if (ep->desc) {		u32 csr;		csr = usb_read(ep->csr1);		while ((csr =			usb_read(ep->				 csr1)) & (USB_OUT_CSR1_OUT_PKT_RDY |					   USB_OUT_CSR1_SENT_STALL)) {			DEBUG("%s: %x/n", __func__, csr);			if (csr & USB_OUT_CSR1_SENT_STALL) {				DEBUG("%s: stall sent, flush fifo/n",				      __func__);				/* usb_set(USB_OUT_CSR1_FIFO_FLUSH, ep->csr1); */				flush(ep);			} else if (csr & USB_OUT_CSR1_OUT_PKT_RDY) {				if (list_empty(&ep->queue))					req = 0;				else					req =					    list_entry(ep->queue.next,						       struct lh7a40x_request,						       queue);				if (!req) {					printk(KERN_WARNING					       "%s: NULL REQ %d/n",					       __func__, ep_idx);					flush(ep);					break;				} else {					read_fifo(ep, req);				}			}		}	} else {

static int check_response(usb_handle *usb, unsigned int size, char *response){    unsigned char status[65];    int r;    for(;;) {        r = usb_read(usb, status, 64);        if(r < 0) {            sprintf(ERROR, "status read failed (%s)", strerror(errno));            usb_close(usb);            return -1;        }        status[r] = 0;        if(r < 4) {            sprintf(ERROR, "status malformed (%d bytes)", r);            usb_close(usb);            return -1;        }        if(!memcmp(status, "INFO", 4)) {            fprintf(stderr,"(bootloader) %s/n", status + 4);            continue;        }        if(!memcmp(status, "OKAY", 4)) {            if(response) {                strcpy(response, (char*) status + 4);            }            return 0;        }        if(!memcmp(status, "FAIL", 4)) {            if(r > 4) {                sprintf(ERROR, "remote: %s", status + 4);            } else {                strcpy(ERROR, "remote failure");            }            return -1;        }        if(!memcmp(status, "DATA", 4) && size > 0){            unsigned dsize = strtoul((char*) status + 4, 0, 16);            if(dsize > size) {                strcpy(ERROR, "data size too large");                usb_close(usb);                return -1;            }            return dsize;        }        strcpy(ERROR,"unknown status code");        usb_close(usb);        break;    }    return -1;}

static inline int hashratio_gets(struct cgpu_info *hashratio, uint8_t *buf){	int i;	int read_amount = HRTO_READ_SIZE;	uint8_t buf_tmp[HRTO_READ_SIZE];	uint8_t buf_copy[2 * HRTO_READ_SIZE];	uint8_t *buf_back = buf;	int ret = 0;	while (true) {		int err;		do {			memset(buf, 0, read_amount);			err = usb_read(hashratio, (char *)buf, read_amount, &ret, C_HRO_READ);			if (unlikely(err < 0 || ret != read_amount)) {				applog(LOG_ERR, "hashratio: Error on read in hashratio_gets got %d", ret);				return HRTO_GETS_ERROR;			}			if (likely(ret >= read_amount)) {				for (i = 1; i < read_amount; i++) {					if (buf_back[i - 1] == HRTO_H1 && buf_back[i] == HRTO_H2)						break;				}				i -= 1;				if (i) {					err = usb_read(hashratio, (char *)buf, read_amount, &ret, C_HRO_READ);					if (unlikely(err < 0 || ret != read_amount)) {						applog(LOG_ERR, "hashratio: Error on 2nd read in hashratio_gets got %d", ret);						return HRTO_GETS_ERROR;					}					memcpy(buf_copy, buf_back + i, HRTO_READ_SIZE - i);					memcpy(buf_copy + HRTO_READ_SIZE - i, buf_tmp, i);					memcpy(buf_back, buf_copy, HRTO_READ_SIZE);				}				return HRTO_GETS_OK;			}			buf += ret;			read_amount -= ret;			continue;		} while (ret > 0);		return HRTO_GETS_TIMEOUT;	}}

static void hfa_clear_readbuf(struct cgpu_info *hashfast){    int amount, ret;    char buf[512];    do {        ret = usb_read(hashfast, buf, 512, &amount, C_HF_CLEAR_READ);    } while (!ret || amount);}

void rt_ep_stall(struct rt_ep_struct *rt_ep){	u8 tmp;	u32 addr;	int idx = EP_NO(rt_ep);	int dir = EP_DIR(rt_ep);	if(idx == 0){		tmp = usb_read(EP0CS);		tmp |= 0x1;		usb_write(EP0CS, tmp);	}else{		addr = (dir == EP_IN ? 0x006 : 0x002) + idx * 8;		tmp = usb_read(addr);		tmp |= 0x40;		usb_write(addr, tmp);	}	return;}

int usb_boot(	struct usb_handle *usb, void *data, unsigned sz, const char *rootfs){	const uint32_t msg_boot  = 0xF0030002;	uint32_t msg_size = sz;	int i;	pthread_t thread;	struct thread_vars vars;	struct termios tn;	struct file_data fd_vector[MAX_OPEN_FILES];	if (read_asic_id(usb))		return -1;	printf("sending xload to target.../n");	usleep(1000);	usb_write(usb, &msg_boot, sizeof(msg_boot));	usleep(1000);	usb_write(usb, &msg_size, sizeof(msg_size));	usleep(1000);	usb_write(usb, data, sz);	usleep(100000);	munmap(data, msg_size);	for (i = 0; i < MAX_OPEN_FILES; i++)		fd_vector[i].data = NULL;	vars.usb = usb;	pthread_mutex_init(&vars.usb_mutex, NULL);	tcgetattr(STDIN_FILENO, &vars.t_restore);	tn = vars.t_restore;	tn.c_lflag &= ~(ICANON | ECHO);	printf(TFORMAT, TARGET_FORMAT);	tcsetattr(STDIN_FILENO, TCSANOW, &tn);	if (pthread_create(&thread, NULL, listenerTask, &vars))		host_print("listenerTask failed/n");	for (;;) {		usleep(100);		if (usb_read(usb, &i, 4) != 4)			break;		if (i == USBBOOT_FS_MAGIC) {			usleep(100);			pthread_mutex_lock(&vars.usb_mutex);			process_file(usb, rootfs, fd_vector, &vars.t_restore);			pthread_mutex_unlock(&vars.usb_mutex);			continue;		}		printf("%c", i);		fflush(stdout);	}	usb_close(usb);	pthread_mutex_destroy(&vars.usb_mutex);	tcsetattr(STDIN_FILENO, TCSANOW, &vars.t_restore);	printf(HFORMAT, HOST_FORMAT);	return 0;}

// Call usb_read using a buffer having a multiple of usb_get_max_packet_size() bytes// to avoid overflow. See http://libusb.sourceforge.net/api-1.0/packetoverflow.html.static int UsbReadMessage(usb_handle* h, amessage* msg) {    D("UsbReadMessage");#if CHECK_PACKET_OVERFLOW    size_t usb_packet_size = usb_get_max_packet_size(h);    CHECK_GE(usb_packet_size, sizeof(*msg));    CHECK_LT(usb_packet_size, 4096ULL);    char buffer[4096];    int n = usb_read(h, buffer, usb_packet_size);    if (n != sizeof(*msg)) {        D("usb_read returned unexpected length %d (expected %zu)", n, sizeof(*msg));        return -1;    }    memcpy(msg, buffer, sizeof(*msg));    return n;#else    return usb_read(h, msg, sizeof(*msg));#endif}

static u32 rt_fifo_bcount(struct rt_ep_struct *rt_ep){	u8 low, high;	u32 rc;	int idx = EP_NO(rt_ep);	int dir = EP_DIR(rt_ep);	if(idx == 0)		return 0;	if(dir /* IN */){		low = usb_read(0x004 + idx*8);		high = usb_read( (0x004 + idx*8)+1 );	}else{  /* OUT */		low = usb_read(0x000 + idx*8);		high = usb_read( (0x000 + idx*8)+1 );	}	rc = high | low;	return rc;}

// On Android devices, we rely on the kernel to provide buffered read.// So we can recover automatically from EOVERFLOW.static int remote_read(apacket* p, usb_handle* usb) {    if (usb_read(usb, &p->msg, sizeof(amessage)) != sizeof(amessage)) {        PLOG(ERROR) << "remote usb: read terminated (message)";        return -1;    }    if (p->msg.data_length) {        if (p->msg.data_length > MAX_PAYLOAD) {            PLOG(ERROR) << "remote usb: read overflow (data length = " << p->msg.data_length << ")";            return -1;        }        p->payload.resize(p->msg.data_length);        if (usb_read(usb, &p->payload[0], p->payload.size())                != static_cast<int>(p->payload.size())) {            PLOG(ERROR) << "remote usb: terminated (data)";            return -1;        }    }    return 0;}

static bool hfa_get_data(struct cgpu_info *hashfast, char *buf, int len4){    int amount, ret, len = len4 * 4;    ret = usb_read(hashfast, buf, len, &amount, C_HF_GETDATA);    if (ret)        return false;    if (amount != len) {        applog(LOG_WARNING, "HFA %d: get_data: Strange amount returned %d vs. expected %d",               hashfast->device_id, amount, len);        return false;    }    return true;}

bool cmd_receive(UsbCommand* cmd) {   // Check if there is a usb packet available  if (!usb_poll()) return false;    // Try to retrieve the available command frame  size_t rxlen = usb_read((byte_t*)cmd,sizeof(UsbCommand));  // Check if the transfer was complete  if (rxlen != sizeof(UsbCommand)) return false;    // Received command successfully  return true;}