/* Evaluate and act on the response to a capture status request.
*/
static void handle_status_response(const struct sr_dev_inst *sdi)
{
struct dev_context *devc;
struct acquisition_state *acq;
unsigned int old_status;
devc = sdi->priv;
acq = devc->acquisition;
old_status = acq->status;
if ((*devc->model->handle_response)(sdi) != SR_OK) {
devc->transfer_error = TRUE;
return;
}
devc->state = STATE_STATUS_WAIT;
sr_spew("Captured %u words, %" PRIu64 " ms, status 0x%02X.",
acq->mem_addr_fill, acq->duration_now, acq->status);
if ((~old_status & acq->status & STATUS_TRIGGERED) != 0)
sr_info("Capture triggered.");
if (acq->duration_now >= acq->duration_max) {
sr_dbg("Time limit reached, stopping capture.");
submit_request(sdi, STATE_STOP_CAPTURE);
} else if ((acq->status & STATUS_TRIGGERED) == 0) {
sr_spew("Waiting for trigger.");
} else if ((acq->status & STATUS_MEM_AVAIL) == 0) {
sr_dbg("Capture memory filled.");
submit_request(sdi, STATE_LENGTH_REQUEST);
} else if ((acq->status & STATUS_CAPTURING) != 0) {
sr_spew("Sampling in progress.");
}
}
/* Evaluate and act on the response to a capture length request.
*/
static void handle_length_response(const struct sr_dev_inst *sdi)
{
struct dev_context *devc;
struct acquisition_state *acq;
devc = sdi->priv;
acq = devc->acquisition;
if ((*devc->model->handle_response)(sdi) != SR_OK) {
devc->transfer_error = TRUE;
return;
}
acq->rle = RLE_STATE_DATA;
acq->sample = 0;
acq->run_len = 0;
acq->samples_done = 0;
acq->mem_addr_done = acq->mem_addr_next;
acq->out_index = 0;
if (acq->mem_addr_next >= acq->mem_addr_stop) {
submit_request(sdi, STATE_READ_FINISH);
return;
}
sr_dbg("%u words in capture buffer.",
acq->mem_addr_stop - acq->mem_addr_next);
submit_request(sdi, STATE_READ_PREPARE);
}
/* USB input transfer completion callback.
*/
static void LIBUSB_CALL transfer_in_completed(struct libusb_transfer *transfer)
{
const struct sr_dev_inst *sdi;
struct dev_context *devc;
struct acquisition_state *acq;
sdi = transfer->user_data;
devc = sdi->priv;
acq = devc->acquisition;
if (transfer->status != LIBUSB_TRANSFER_COMPLETED) {
sr_err("Transfer from device failed (state %d): %s.",
devc->state, libusb_error_name(transfer->status));
devc->transfer_error = TRUE;
return;
}
if ((devc->state & STATE_EXPECT_RESPONSE) == 0) {
sr_err("Unexpected completion of input transfer (state %d).",
devc->state);
devc->transfer_error = TRUE;
return;
}
if (acq->reg_seq_pos < acq->reg_seq_len && !devc->cancel_requested) {
/* Complete register read sequence. */
if (read_reg_response(acq) != SR_OK) {
devc->transfer_error = TRUE;
return;
}
/* Repeat until all queued registers have been read. */
if (++acq->reg_seq_pos < acq->reg_seq_len) {
next_reg_read(acq);
submit_transfer(devc, acq->xfer_out);
return;
}
}
switch (devc->state) {
case STATE_STATUS_REQUEST:
if (devc->cancel_requested)
submit_request(sdi, STATE_STOP_CAPTURE);
else
handle_status_response(sdi);
break;
case STATE_LENGTH_REQUEST:
if (devc->cancel_requested)
submit_request(sdi, STATE_READ_FINISH);
else
handle_length_response(sdi);
break;
case STATE_READ_REQUEST:
handle_read_response(sdi);
break;
default:
sr_err("Unexpected device state %d.", devc->state);
devc->transfer_error = TRUE;
break;
}
}
/* Evaluate and act on the response to a capture memory read request.
*/
static void handle_read_response(const struct sr_dev_inst *sdi)
{
struct dev_context *devc;
struct acquisition_state *acq;
struct sr_datafeed_packet packet;
struct sr_datafeed_logic logic;
unsigned int end_addr;
devc = sdi->priv;
acq = devc->acquisition;
/* Prepare session packet. */
packet.type = SR_DF_LOGIC;
packet.payload = &logic;
logic.unitsize = (devc->model->num_channels + 7) / 8;
logic.data = acq->out_packet;
end_addr = MIN(acq->mem_addr_next, acq->mem_addr_stop);
acq->in_index = 0;
/*
* Repeatedly call the model-specific read response handler until
* all data received in the transfer has been accounted for.
*/
while (!devc->cancel_requested
&& (acq->run_len > 0 || acq->mem_addr_done < end_addr)
&& acq->samples_done < acq->samples_max) {
if ((*devc->model->handle_response)(sdi) != SR_OK) {
devc->transfer_error = TRUE;
return;
}
if (acq->out_index * logic.unitsize >= PACKET_SIZE) {
/* Send off full logic packet. */
logic.length = acq->out_index * logic.unitsize;
sr_session_send(sdi, &packet);
acq->out_index = 0;
}
}
if (!devc->cancel_requested
&& acq->samples_done < acq->samples_max
&& acq->mem_addr_next < acq->mem_addr_stop) {
/* Request the next block. */
submit_request(sdi, STATE_READ_REQUEST);
return;
}
/* Send partially filled packet as it is the last one. */
if (!devc->cancel_requested && acq->out_index > 0) {
logic.length = acq->out_index * logic.unitsize;
sr_session_send(sdi, &packet);
acq->out_index = 0;
}
submit_request(sdi, STATE_READ_FINISH);
}
/* USB I/O source callback.
*/
static int transfer_event(int fd, int revents, void *cb_data)
{
const struct sr_dev_inst *sdi;
struct dev_context *devc;
struct drv_context *drvc;
struct timeval tv;
int ret;
(void)fd;
sdi = cb_data;
devc = sdi->priv;
drvc = sdi->driver->context;
if (!devc || !drvc)
return G_SOURCE_REMOVE;
/* Handle pending USB events without blocking. */
tv.tv_sec = 0;
tv.tv_usec = 0;
ret = libusb_handle_events_timeout_completed(drvc->sr_ctx->libusb_ctx,
&tv, NULL);
if (ret != 0) {
sr_err("Event handling failed: %s.", libusb_error_name(ret));
devc->transfer_error = TRUE;
}
if (!devc->transfer_error && devc->state == STATE_STATUS_WAIT) {
if (devc->cancel_requested)
submit_request(sdi, STATE_STOP_CAPTURE);
else if (revents == 0) /* status poll timeout */
submit_request(sdi, STATE_STATUS_REQUEST);
}
/* Stop processing events if an error occurred on a transfer. */
if (devc->transfer_error)
devc->state = STATE_IDLE;
if (devc->state != STATE_IDLE)
return G_SOURCE_CONTINUE;
sr_info("Acquisition stopped.");
/* We are done, clean up and send end packet to session bus. */
clear_acquisition_state(sdi);
std_session_send_df_end(sdi, LOG_PREFIX);
return G_SOURCE_REMOVE;
}
/**
* Callback invoked from the VPN service once a redirection is
* available. Provides the IP address that can now be used to
* reach the requested destination. We substitute the active
* record and then continue with 'submit_request' to look at
* the other records.
*
* @param cls our 'struct ReplyContext'
* @param af address family, AF_INET or AF_INET6; AF_UNSPEC on error;
* will match 'result_af' from the request
* @param address IP address (struct in_addr or struct in_addr6, depending on 'af')
* that the VPN allocated for the redirection;
* traffic to this IP will now be redirected to the
* specified target peer; NULL on error
*/
static void
vpn_allocation_callback (void *cls,
int af,
const void *address)
{
struct ReplyContext *rc = cls;
rc->rr = NULL;
if (af == AF_UNSPEC)
{
GNUNET_DNS_request_drop (rc->rh);
GNUNET_DNSPARSER_free_packet (rc->dns);
GNUNET_free (rc);
return;
}
GNUNET_STATISTICS_update (stats,
gettext_noop ("# DNS records modified"),
1, GNUNET_NO);
switch (rc->rec->type)
{
case GNUNET_DNSPARSER_TYPE_A:
GNUNET_assert (AF_INET == af);
memcpy (rc->rec->data.raw.data, address, sizeof (struct in_addr));
break;
case GNUNET_DNSPARSER_TYPE_AAAA:
GNUNET_assert (AF_INET6 == af);
memcpy (rc->rec->data.raw.data, address, sizeof (struct in6_addr));
break;
default:
GNUNET_assert (0);
return;
}
rc->rec = NULL;
submit_request (rc);
}
/* eventcb for bufferevent. For the purpose of simplicity and
readability of the example program, we omitted the certificate and
peer verification. After SSL/TLS handshake is over, initialize
nghttp2 library session, and send client connection header. Then
send HTTP request. */
static void eventcb(struct bufferevent *bev, short events, void *ptr)
{
http2_session_data *session_data = (http2_session_data*)ptr;
if(events & BEV_EVENT_CONNECTED) {
int fd = bufferevent_getfd(bev);
int val = 1;
fprintf(stderr, "Connected\n");
setsockopt(fd, IPPROTO_TCP, TCP_NODELAY, (char *)&val, sizeof(val));
initialize_nghttp2_session(session_data);
send_client_connection_header(session_data);
submit_request(session_data);
if(session_send(session_data) != 0) {
delete_http2_session_data(session_data);
}
return;
}
if(events & BEV_EVENT_EOF) {
warnx("Disconnected from the remote host");
} else if(events & BEV_EVENT_ERROR) {
warnx("Network error");
} else if(events & BEV_EVENT_TIMEOUT) {
warnx("Timeout");
}
delete_http2_session_data(session_data);
}
static void submit_next_request(struct usba_ep *ep)
{
struct usba_request *req;
if (list_empty(&ep->queue)) {
usba_ep_writel(ep, CTL_DIS, USBA_TX_PK_RDY | USBA_RX_BK_RDY);
return;
}
req = list_entry(ep->queue.next, struct usba_request, queue);
if (!req->submitted)
submit_request(ep, req);
}
/* eventcb for bufferevent. For the purpose of simplicity and
readability of the example program, we omitted the certificate and
peer verification. After SSL/TLS handshake is over, initialize
nghttp2 library session, and send client connection header. Then
send HTTP request. */
static void eventcb(struct bufferevent *bev, short events, void *ptr) {
http2_session_data *session_data = (http2_session_data *)ptr;
if (events & BEV_EVENT_CONNECTED) {
int fd = bufferevent_getfd(bev);
int val = 1;
const unsigned char *alpn = NULL;
unsigned int alpnlen = 0;
SSL *ssl;
fprintf(stderr, "Connected\n");
ssl = bufferevent_openssl_get_ssl(session_data->bev);
#ifndef OPENSSL_NO_NEXTPROTONEG
SSL_get0_next_proto_negotiated(ssl, &alpn, &alpnlen);
#endif /* !OPENSSL_NO_NEXTPROTONEG */
#if OPENSSL_VERSION_NUMBER >= 0x10002000L
if (alpn == NULL) {
SSL_get0_alpn_selected(ssl, &alpn, &alpnlen);
}
#endif /* OPENSSL_VERSION_NUMBER >= 0x10002000L */
if (alpn == NULL || alpnlen != 2 || memcmp("h2", alpn, 2) != 0) {
fprintf(stderr, "h2 is not negotiated\n");
delete_http2_session_data(session_data);
return;
}
setsockopt(fd, IPPROTO_TCP, TCP_NODELAY, (char *)&val, sizeof(val));
initialize_nghttp2_session(session_data);
send_client_connection_header(session_data);
submit_request(session_data);
if (session_send(session_data) != 0) {
delete_http2_session_data(session_data);
}
return;
}
if (events & BEV_EVENT_EOF) {
warnx("Disconnected from the remote host");
} else if (events & BEV_EVENT_ERROR) {
warnx("Network error");
} else if (events & BEV_EVENT_TIMEOUT) {
warnx("Timeout");
}
delete_http2_session_data(session_data);
}
SR_PRIV int lwla_start_acquisition(const struct sr_dev_inst *sdi)
{
struct drv_context *drvc;
struct dev_context *devc;
int ret;
const int poll_interval_ms = 100;
drvc = sdi->driver->context;
devc = sdi->priv;
if (devc->state != STATE_IDLE) {
sr_err("Not in idle state, cannot start acquisition.");
return SR_ERR;
}
devc->cancel_requested = FALSE;
devc->transfer_error = FALSE;
ret = init_acquisition_state(sdi);
if (ret != SR_OK)
return ret;
ret = (*devc->model->setup_acquisition)(sdi);
if (ret != SR_OK) {
sr_err("Failed to set up device for acquisition.");
clear_acquisition_state(sdi);
return ret;
}
/* Register event source for asynchronous USB I/O. */
ret = usb_source_add(sdi->session, drvc->sr_ctx, poll_interval_ms,
&transfer_event, (struct sr_dev_inst *)sdi);
if (ret != SR_OK) {
clear_acquisition_state(sdi);
return ret;
}
ret = submit_request(sdi, STATE_START_CAPTURE);
if (ret == SR_OK)
ret = std_session_send_df_header(sdi, LOG_PREFIX);
if (ret != SR_OK) {
usb_source_remove(sdi->session, drvc->sr_ctx);
clear_acquisition_state(sdi);
}
return ret;
}
static void restart_request(struct request_ctx *req, struct bufferevent *bev)
{
int err;
bufferevent_disable(bev, EV_READ|EV_WRITE);
err = conn_stash_reconnect(req->conn_stash, &bev);
if (err == 0) {
/* This is rather fragile when someone decides
* to add bits into struct request_ctx. We'll need
* to know what to clear. So it could use a bit of
* restructuring
*/
clear_buffer(bufferevent_get_output(bev));
clear_buffer(bufferevent_get_input(bev));
reset_read_state(req);
bufferevent_setcb(bev, cb_read, cb_write, cb_event, req);
submit_request(bev, req);
} else {
store_request_error(req, "%s(): %s", __func__, strerror(err));
request_done(req, bev);
}
}
/**
* This function is called AFTER we got an IP address for a
* DNS request. Now, the PT daemon has the chance to substitute
* the IP address with one from the VPN range to tunnel requests
* destined for this IP address via VPN and MESH.
*
* @param cls closure
* @param rh request handle to user for reply
* @param request_length number of bytes in request
* @param request udp payload of the DNS request
*/
static void
dns_post_request_handler (void *cls,
struct GNUNET_DNS_RequestHandle *rh,
size_t request_length,
const char *request)
{
struct GNUNET_DNSPARSER_Packet *dns;
struct ReplyContext *rc;
int work;
GNUNET_STATISTICS_update (stats,
gettext_noop ("# DNS replies intercepted"),
1, GNUNET_NO);
dns = GNUNET_DNSPARSER_parse (request, request_length);
if (NULL == dns)
{
GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
_("Failed to parse DNS request. Dropping.\n"));
GNUNET_DNS_request_drop (rh);
return;
}
work = GNUNET_NO;
work |= work_test (dns->answers, dns->num_answers);
work |= work_test (dns->authority_records, dns->num_authority_records);
work |= work_test (dns->additional_records, dns->num_additional_records);
if (! work)
{
GNUNET_DNS_request_forward (rh);
GNUNET_DNSPARSER_free_packet (dns);
return;
}
rc = GNUNET_malloc (sizeof (struct ReplyContext));
rc->rh = rh;
rc->dns = dns;
rc->offset = 0;
rc->group = ANSWERS;
submit_request (rc);
}
void https_request(struct https_engine *https,
const char *host, int port,
const char *method, const char *path,
const char *access_token,
struct evbuffer *body,
struct https_cb_ops *cb_ops,
void *cb_arg)
{
struct request_ctx *request;
struct bufferevent *bev;
if ((request = malloc(sizeof(*request))) == NULL) {
cb_ops->done("Out of memory", cb_arg);
return;
}
memset(request, 0, sizeof(*request));
request->method = method;
request->host = host;
request->port = port;
request->path = path;
request->access_token = access_token;
setup_request_body(request, body);
request->cb_ops = cb_ops;
request->cb_arg = cb_arg;
request->conn_stash = https->conn_stash;
bev = conn_stash_get_bev(https->conn_stash, host, port);
if (bev == NULL) {
cb_ops->done("Failed to set up connection", cb_arg);
free(request);
return;
}
bufferevent_setcb(bev, cb_read, cb_write, cb_event, request);
submit_request(bev, request);
}
/*
* Fetches the resource denoted by |uri|.
*/
static void fetch_uri(const struct URI *uri)
{
spdylay_session_callbacks callbacks;
int fd;
SSL_CTX *ssl_ctx;
SSL *ssl;
struct Request req;
struct Connection connection;
int rv;
nfds_t npollfds = 1;
struct pollfd pollfds[1];
uint16_t spdy_proto_version;
request_init(&req, uri);
setup_spdylay_callbacks(&callbacks);
/* Establish connection and setup SSL */
fd = connect_to(req.host, req.port);
ssl_ctx = SSL_CTX_new(SSLv23_client_method());
if(ssl_ctx == NULL) {
dief("SSL_CTX_new", ERR_error_string(ERR_get_error(), NULL));
}
init_ssl_ctx(ssl_ctx, &spdy_proto_version);
ssl = SSL_new(ssl_ctx);
if(ssl == NULL) {
dief("SSL_new", ERR_error_string(ERR_get_error(), NULL));
}
/* To simplify the program, we perform SSL/TLS handshake in blocking
I/O. */
ssl_handshake(ssl, fd);
connection.ssl = ssl;
connection.want_io = IO_NONE;
/* Here make file descriptor non-block */
make_non_block(fd);
set_tcp_nodelay(fd);
printf("[INFO] SPDY protocol version = %d\n", spdy_proto_version);
rv = spdylay_session_client_new(&connection.session, spdy_proto_version,
&callbacks, &connection);
if(rv != 0) {
diec("spdylay_session_client_new", rv);
}
/* Submit the HTTP request to the outbound queue. */
submit_request(&connection, &req);
pollfds[0].fd = fd;
ctl_poll(pollfds, &connection);
/* Event loop */
while(spdylay_session_want_read(connection.session) ||
spdylay_session_want_write(connection.session)) {
int nfds = poll(pollfds, npollfds, -1);
if(nfds == -1) {
dief("poll", strerror(errno));
}
if(pollfds[0].revents & (POLLIN | POLLOUT)) {
exec_io(&connection);
}
if((pollfds[0].revents & POLLHUP) || (pollfds[0].revents & POLLERR)) {
die("Connection error");
}
ctl_poll(pollfds, &connection);
}
/* Resource cleanup */
spdylay_session_del(connection.session);
SSL_shutdown(ssl);
SSL_free(ssl);
SSL_CTX_free(ssl_ctx);
shutdown(fd, SHUT_WR);
close(fd);
request_free(&req);
}
/* USB output transfer completion callback.
*/
static void LIBUSB_CALL transfer_out_completed(struct libusb_transfer *transfer)
{
const struct sr_dev_inst *sdi;
struct dev_context *devc;
struct acquisition_state *acq;
sdi = transfer->user_data;
devc = sdi->priv;
acq = devc->acquisition;
if (transfer->status != LIBUSB_TRANSFER_COMPLETED) {
sr_err("Transfer to device failed (state %d): %s.",
devc->state, libusb_error_name(transfer->status));
devc->transfer_error = TRUE;
return;
}
/* If this was a read request, wait for the response. */
if ((devc->state & STATE_EXPECT_RESPONSE) != 0) {
submit_transfer(devc, acq->xfer_in);
return;
}
if (acq->reg_seq_pos < acq->reg_seq_len)
acq->reg_seq_pos++; /* register write completed */
/* Repeat until all queued registers have been written. */
if (acq->reg_seq_pos < acq->reg_seq_len && !devc->cancel_requested) {
next_reg_write(acq);
submit_transfer(devc, acq->xfer_out);
return;
}
switch (devc->state) {
case STATE_START_CAPTURE:
sr_info("Acquisition started.");
if (!devc->cancel_requested)
devc->state = STATE_STATUS_WAIT;
else
submit_request(sdi, STATE_STOP_CAPTURE);
break;
case STATE_STOP_CAPTURE:
if (!devc->cancel_requested)
submit_request(sdi, STATE_LENGTH_REQUEST);
else
devc->state = STATE_IDLE;
break;
case STATE_READ_PREPARE:
if (acq->mem_addr_next < acq->mem_addr_stop && !devc->cancel_requested)
submit_request(sdi, STATE_READ_REQUEST);
else
submit_request(sdi, STATE_READ_FINISH);
break;
case STATE_READ_FINISH:
devc->state = STATE_IDLE;
break;
default:
sr_err("Unexpected device state %d.", devc->state);
devc->transfer_error = TRUE;
break;
}
}
int nghttp2client_connect(httpclient *pclient, char *url, int port, http2_ssl_custom_conf_t *ssl_config, const struct URI *uri)
{
struct Connection connection;
nghttp2_session_callbacks *callbacks;
int rv;
int ret = 0;
struct Request req;
request_init(&req, uri);
if (0 == (ret = nghttp2s_client_conn(pclient, url, port, ssl_config))) {
pclient->remote_port = HTTPS_PORT;
nghttp2_socket.fd = pclient->fd.fd;
} else {
printf("https_client_conn failed %d\r\n", ret);
/* Resource cleanup */
mbedtls_ssl_close_notify( &(pclient->ssl) );
mbedtls_net_free( &pclient->fd );
mbedtls_x509_crt_free( &(ssl_config->verify_source.cacertl) );
mbedtls_ssl_free( &(pclient->ssl) );
mbedtls_ssl_config_free( &(ssl_config->conf) );
mbedtls_ctr_drbg_free(&ctr_drbg);
mbedtls_entropy_free(&entropy);
request_free(&req);
return ret;
}
//set_tcp_nodelay(nghttp2_socket.fd);
connection.ssl = &(pclient->ssl);
rv = nghttp2_session_callbacks_new(&callbacks);
if (rv != 0) {
printf("nghttp2_session_callbacks_new1 %d", rv);
}
setup_nghttp2_callbacks(callbacks);
rv = nghttp2_session_client_new(&connection.session, callbacks, &connection);
nghttp2_session_callbacks_del(callbacks);
if (rv != 0) {
printf("nghttp2_session_client_new2 %d", rv);
}
nghttp2_submit_settings(connection.session, NGHTTP2_FLAG_NONE, NULL, 0);
/* Submit the HTTP request to the outbound queue. */
submit_request(&connection, &req);
/* Event loop */
while (1) {
int read_flag = 0;
int write_flag = 0;
write_flag = nghttp2_session_want_write(connection.session);
if (write_flag) {
int rv = nghttp2_session_send(connection.session);
printf("nghttp2_session_send %d\r\n", rv);
if (rv < 0) {
write_flag = 0;
//break;
}
}
read_flag = nghttp2_session_want_read(connection.session);
if (read_flag) {
int rv = nghttp2_session_recv(connection.session);
printf("nghttp2_session_recv %d\r\n", rv);
if (rv < 0) {
read_flag = 0;
//break;
}
}
printf("write_flag = %d, read_flag = %d\r\n", write_flag, read_flag);
if ((read_flag == 0) && (write_flag == 0)) {
printf("No active stream!\r\n");
break;
}
}
/* Resource cleanup */
nghttp2_session_del(connection.session);
mbedtls_ssl_close_notify( &(pclient->ssl) );
mbedtls_net_free( &pclient->fd );
mbedtls_x509_crt_free( &(ssl_config->verify_source.cacertl) );
mbedtls_ssl_free( &(pclient->ssl) );
mbedtls_ssl_config_free( &(ssl_config->conf) );
mbedtls_ctr_drbg_free(&ctr_drbg);
mbedtls_entropy_free(&entropy);
request_free(&req);
return 0;
}
ssize_t hsadc_read(struct file *filp, char __user *buf, size_t count, loff_t *ppos)
{
struct mxs_hsadc_data *pdx = (struct mxs_hsadc_data*)filp->private_data;
int ret = 0;
DECLARE_WAITQUEUE(wait, current);
#if HSADC_DEBUG
printk(KERN_INFO "%s> %s start.\n", HSADC_DEVICE_NAME, __FUNCTION__);
#endif
/* someone has request zero byte data! */
if(!count)
return ret;
/* push the request into the wait queue, it will be wakeup by the ISR */
add_wait_queue(&pdx->r_wait, &wait);
if(filp->f_flags & O_NONBLOCK)
{
ret = -EAGAIN;
#if HSADC_DEBUG
printk(KERN_INFO "%s> file open with O_NONBLOCK.\n", HSADC_DEVICE_NAME);
#endif
goto acc_out;
}
pdx->cur = buf;
pdx->total_len =
pdx->remaint_len =
adc_sample_percision == 8 ? count : count &(~0x01);// in 10-bit & 12-bit mode the sample data word size is two bytes
if(pdx->total_len <= DMA_BUF_SIZE)
pdx->seq_len = count;
else
pdx->seq_len = DMA_BUF_SIZE;
// init a read and wait for interrupt
if(submit_request(pdx, pdx->seq_len))
{
goto acc_abort;
}
while(pdx->remaint_len)
{
/* set current process state into sleep */
__set_current_state(TASK_INTERRUPTIBLE);
#if HSADC_DEBUG
printk(KERN_INFO "%s> suspend.\n", HSADC_DEVICE_NAME);
#endif
/* schedule other process to run */
schedule();
#if HSADC_DEBUG
printk(KERN_INFO "%s> wakeup.\n", HSADC_DEVICE_NAME);
#endif
/* wakeup point */
if(signal_pending(current))
{
/* no data, we are wakeuped by the signal, do nothing */
ret = -ERESTARTSYS;
goto acc_abort;
}
if(copy_to_user(pdx->cur, pdx->buf, pdx->seq_len))
{
ret = pdx->total_len - pdx->remaint_len;
goto acc_abort;
}
else
{
// update position
pdx->cur += pdx->seq_len;
pdx->remaint_len -= pdx->seq_len;
if(pdx->remaint_len > DMA_BUF_SIZE)
{
pdx->seq_len = DMA_BUF_SIZE;
}
else
{
// this is the last piease of data to read
pdx->seq_len = pdx->remaint_len;
}
if(pdx->seq_len)
submit_request(pdx, pdx->seq_len);
}
#if HSADC_DEBUG
printk(KERN_INFO "%s> remaint = 0x%lx\n",
HSADC_DEVICE_NAME, pdx->remaint_len);
#endif
}
ret = pdx->total_len - pdx->remaint_len;
acc_abort:
acc_out:
remove_wait_queue(&pdx->r_wait, &wait);
__set_current_state(TASK_RUNNING);
#if HSADC_DEBUG
printk(KERN_INFO "%s> %s end.\n", HSADC_DEVICE_NAME, __FUNCTION__);
#endif
return ret;
}
/*
* Fetches the resource denoted by |uri|.
*/
static void fetch_uri(const struct URI *uri)
{
spdylay_session_callbacks callbacks;
int fd;
struct Request req;
struct Connection connection;
int rv;
nfds_t npollfds = 1;
struct pollfd pollfds[1];
uint16_t spdy_proto_version = 3;
request_init(&req, uri);
setup_spdylay_callbacks(&callbacks);
/* Establish connection and setup SSL */
fd = connect_to(req.host, req.port);
if (-1 == fd)
abort ();
connection.fd = fd;
connection.want_io = IO_NONE;
/* Here make file descriptor non-block */
make_non_block(fd);
set_tcp_nodelay(fd);
printf("[INFO] SPDY protocol version = %d\n", spdy_proto_version);
rv = spdylay_session_client_new(&connection.session, spdy_proto_version,
&callbacks, &connection);
if(rv != 0) {
diec("spdylay_session_client_new", rv);
}
/* Submit the HTTP request to the outbound queue. */
submit_request(&connection, &req);
pollfds[0].fd = fd;
ctl_poll(pollfds, &connection);
/* Event loop */
while(spdylay_session_want_read(connection.session) ||
spdylay_session_want_write(connection.session)) {
int nfds = poll(pollfds, npollfds, -1);
if(nfds == -1) {
dief("poll", strerror(errno));
}
if(pollfds[0].revents & (POLLIN | POLLOUT)) {
exec_io(&connection);
}
if((pollfds[0].revents & POLLHUP) || (pollfds[0].revents & POLLERR)) {
die("Connection error");
}
ctl_poll(pollfds, &connection);
}
/* Resource cleanup */
spdylay_session_del(connection.session);
shutdown(fd, SHUT_WR);
MHD_socket_close_(fd);
request_free(&req);
}
