// Queue a read request. Call readDataWait to wait for result
int MtpDataPacket::readDataAsync(struct usb_request *req) {
if (usb_request_queue(req)) {
printf("usb_endpoint_queue failed");
return -1;
}
return 0;
}
static zx_status_t usb_midi_sink_write(void* ctx, const void* data, size_t length,
zx_off_t offset, size_t* actual) {
usb_midi_sink_t* sink = ctx;
if (sink->dead) {
return ZX_ERR_IO_NOT_PRESENT;
}
zx_status_t status = ZX_OK;
size_t out_actual = length;
const uint8_t* src = (uint8_t *)data;
while (length > 0) {
sync_completion_wait(&sink->free_write_completion, ZX_TIME_INFINITE);
if (sink->dead) {
return ZX_ERR_IO_NOT_PRESENT;
}
mtx_lock(&sink->mutex);
list_node_t* node = list_remove_head(&sink->free_write_reqs);
if (list_is_empty(&sink->free_write_reqs)) {
sync_completion_reset(&sink->free_write_completion);
}
mtx_unlock(&sink->mutex);
if (!node) {
// shouldn't happen!
status = ZX_ERR_INTERNAL;
goto out;
}
usb_req_internal_t* req_int = containerof(node, usb_req_internal_t, node);
usb_request_t* req = REQ_INTERNAL_TO_USB_REQ(req_int, sink->parent_req_size);
size_t message_length = get_midi_message_length(*src);
if (message_length < 1 || message_length > length) return ZX_ERR_INVALID_ARGS;
uint8_t buffer[4];
buffer[0] = (src[0] & 0xF0) >> 4;
buffer[1] = src[0];
buffer[2] = (message_length > 1 ? src[1] : 0);
buffer[3] = (message_length > 2 ? src[2] : 0);
usb_request_copy_to(req, buffer, 4, 0);
req->header.length = 4;
usb_request_complete_t complete = {
.callback = usb_midi_sink_write_complete,
.ctx = sink,
};
usb_request_queue(&sink->usb, req, &complete);
src += message_length;
length -= message_length;
}
out:
update_signals(sink);
if (status == ZX_OK) {
*actual = out_actual;
}
return status;
}
// Queue a read request. Call readDataWait to wait for result
int MtpDataPacket::readDataAsync(struct usb_request *req) {
if (usb_request_queue(req)) {
MTPE("usb_endpoint_queue failed, errno: %d", errno);
return -1;
}
return 0;
}
