2 * This file is part of the libsigrok project.
4 * Copyright (C) 2014 Daniel Elstner <daniel.kitta@gmail.com>
6 * This program is free software: you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation, either version 3 of the License, or
9 * (at your option) any later version.
11 * This program is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU General Public License for more details.
16 * You should have received a copy of the GNU General Public License
17 * along with this program. If not, see <http://www.gnu.org/licenses/>.
25 /* Submit an already filled-in USB transfer.
27 static int submit_transfer(struct dev_context *devc,
28 struct libusb_transfer *xfer)
32 ret = libusb_submit_transfer(xfer);
35 sr_err("Submit transfer failed: %s.", libusb_error_name(ret));
36 devc->transfer_error = TRUE;
43 /* Set up transfer for the next register in a write sequence.
45 static void next_reg_write(struct acquisition_state *acq)
47 struct regval *regval;
49 regval = &acq->reg_sequence[acq->reg_seq_pos];
51 acq->xfer_buf_out[0] = LWLA_WORD(CMD_WRITE_REG);
52 acq->xfer_buf_out[1] = LWLA_WORD(regval->reg);
53 acq->xfer_buf_out[2] = LWLA_WORD_0(regval->val);
54 acq->xfer_buf_out[3] = LWLA_WORD_1(regval->val);
56 acq->xfer_out->length = 4 * sizeof(acq->xfer_buf_out[0]);
59 /* Set up transfer for the next register in a read sequence.
61 static void next_reg_read(struct acquisition_state *acq)
65 addr = acq->reg_sequence[acq->reg_seq_pos].reg;
67 acq->xfer_buf_out[0] = LWLA_WORD(CMD_READ_REG);
68 acq->xfer_buf_out[1] = LWLA_WORD(addr);
70 acq->xfer_out->length = 2 * sizeof(acq->xfer_buf_out[0]);
73 /* Decode the response to a register read request.
75 static int read_reg_response(struct acquisition_state *acq)
79 if (acq->xfer_in->actual_length != 4) {
80 sr_err("Received size %d doesn't match expected size 4.",
81 acq->xfer_in->actual_length);
84 value = LWLA_TO_UINT32(acq->xfer_buf_in[0]);
85 acq->reg_sequence[acq->reg_seq_pos].val = value;
90 /* Enter a new state and submit the corresponding request to the device.
92 static int submit_request(const struct sr_dev_inst *sdi,
93 enum protocol_state state)
95 struct dev_context *devc;
96 struct acquisition_state *acq;
100 acq = devc->acquisition;
104 acq->xfer_out->length = 0;
105 acq->reg_seq_pos = 0;
106 acq->reg_seq_len = 0;
108 /* Perform the model-specific action for the new state. */
109 ret = (*devc->model->prepare_request)(sdi);
112 devc->transfer_error = TRUE;
116 if (acq->reg_seq_pos < acq->reg_seq_len) {
117 if ((state & STATE_EXPECT_RESPONSE) != 0)
123 return submit_transfer(devc, acq->xfer_out);
126 /* Evaluate and act on the response to a capture status request.
128 static void handle_status_response(const struct sr_dev_inst *sdi)
130 struct dev_context *devc;
131 struct acquisition_state *acq;
132 unsigned int old_status;
135 acq = devc->acquisition;
136 old_status = acq->status;
138 if ((*devc->model->handle_response)(sdi) != SR_OK) {
139 devc->transfer_error = TRUE;
142 devc->state = STATE_STATUS_WAIT;
144 sr_spew("Captured %u words, %" PRIu64 " ms, status 0x%02X.",
145 acq->mem_addr_fill, acq->duration_now, acq->status);
147 if ((~old_status & acq->status & STATUS_TRIGGERED) != 0)
148 sr_info("Capture triggered.");
150 if (acq->duration_now >= acq->duration_max) {
151 sr_dbg("Time limit reached, stopping capture.");
152 submit_request(sdi, STATE_STOP_CAPTURE);
153 } else if ((acq->status & STATUS_TRIGGERED) == 0) {
154 sr_spew("Waiting for trigger.");
155 } else if ((acq->status & STATUS_MEM_AVAIL) == 0) {
156 sr_dbg("Capture memory filled.");
157 submit_request(sdi, STATE_LENGTH_REQUEST);
158 } else if ((acq->status & STATUS_CAPTURING) != 0) {
159 sr_spew("Sampling in progress.");
163 /* Evaluate and act on the response to a capture length request.
165 static void handle_length_response(const struct sr_dev_inst *sdi)
167 struct dev_context *devc;
168 struct acquisition_state *acq;
171 acq = devc->acquisition;
173 if ((*devc->model->handle_response)(sdi) != SR_OK) {
174 devc->transfer_error = TRUE;
177 acq->rle = RLE_STATE_DATA;
180 acq->samples_done = 0;
181 acq->mem_addr_done = acq->mem_addr_next;
184 if (acq->mem_addr_next >= acq->mem_addr_stop) {
185 submit_request(sdi, STATE_READ_FINISH);
188 sr_dbg("%u words in capture buffer.",
189 acq->mem_addr_stop - acq->mem_addr_next);
191 submit_request(sdi, STATE_READ_PREPARE);
194 /* Evaluate and act on the response to a capture memory read request.
196 static void handle_read_response(const struct sr_dev_inst *sdi)
198 struct dev_context *devc;
199 struct acquisition_state *acq;
200 struct sr_datafeed_packet packet;
201 struct sr_datafeed_logic logic;
202 unsigned int end_addr;
205 acq = devc->acquisition;
207 /* Prepare session packet. */
208 packet.type = SR_DF_LOGIC;
209 packet.payload = &logic;
210 logic.unitsize = (devc->model->num_channels + 7) / 8;
211 logic.data = acq->out_packet;
213 end_addr = MIN(acq->mem_addr_next, acq->mem_addr_stop);
216 * Repeatedly call the model-specific read response handler until
217 * all data received in the transfer has been accounted for.
219 while (!devc->cancel_requested
220 && (acq->run_len > 0 || acq->mem_addr_done < end_addr)
221 && acq->samples_done < acq->samples_max) {
223 if ((*devc->model->handle_response)(sdi) != SR_OK) {
224 devc->transfer_error = TRUE;
227 if (acq->out_index * logic.unitsize >= PACKET_SIZE) {
228 /* Send off full logic packet. */
229 logic.length = acq->out_index * logic.unitsize;
230 sr_session_send(sdi, &packet);
235 if (!devc->cancel_requested
236 && acq->samples_done < acq->samples_max
237 && acq->mem_addr_next < acq->mem_addr_stop) {
238 /* Request the next block. */
239 submit_request(sdi, STATE_READ_REQUEST);
243 /* Send partially filled packet as it is the last one. */
244 if (!devc->cancel_requested && acq->out_index > 0) {
245 logic.length = acq->out_index * logic.unitsize;
246 sr_session_send(sdi, &packet);
249 submit_request(sdi, STATE_READ_FINISH);
252 /* Destroy and unset the acquisition state record.
254 static void clear_acquisition_state(const struct sr_dev_inst *sdi)
256 struct dev_context *devc;
257 struct acquisition_state *acq;
260 acq = devc->acquisition;
262 devc->acquisition = NULL;
265 libusb_free_transfer(acq->xfer_out);
266 libusb_free_transfer(acq->xfer_in);
271 /* USB I/O source callback.
273 static int transfer_event(int fd, int revents, void *cb_data)
275 const struct sr_dev_inst *sdi;
276 struct dev_context *devc;
277 struct drv_context *drvc;
279 struct sr_datafeed_packet packet;
286 drvc = sdi->driver->context;
289 return G_SOURCE_REMOVE;
291 /* Handle pending USB events without blocking. */
294 ret = libusb_handle_events_timeout_completed(drvc->sr_ctx->libusb_ctx,
297 sr_err("Event handling failed: %s.", libusb_error_name(ret));
298 devc->transfer_error = TRUE;
301 if (!devc->transfer_error && devc->state == STATE_STATUS_WAIT) {
302 if (devc->cancel_requested)
303 submit_request(sdi, STATE_STOP_CAPTURE);
304 else if (revents == 0) /* status poll timeout */
305 submit_request(sdi, STATE_STATUS_REQUEST);
308 /* Stop processing events if an error occurred on a transfer. */
309 if (devc->transfer_error)
310 devc->state = STATE_IDLE;
312 if (devc->state != STATE_IDLE)
313 return G_SOURCE_CONTINUE;
315 sr_info("Acquisition stopped.");
317 /* We are done, clean up and send end packet to session bus. */
318 clear_acquisition_state(sdi);
320 packet.type = SR_DF_END;
321 packet.payload = NULL;
322 sr_session_send(sdi, &packet);
324 return G_SOURCE_REMOVE;
327 /* USB output transfer completion callback.
329 static void LIBUSB_CALL transfer_out_completed(struct libusb_transfer *transfer)
331 const struct sr_dev_inst *sdi;
332 struct dev_context *devc;
333 struct acquisition_state *acq;
335 sdi = transfer->user_data;
337 acq = devc->acquisition;
339 if (transfer->status != LIBUSB_TRANSFER_COMPLETED) {
340 sr_err("Transfer to device failed (state %d): %s.",
341 devc->state, libusb_error_name(transfer->status));
342 devc->transfer_error = TRUE;
346 /* If this was a read request, wait for the response. */
347 if ((devc->state & STATE_EXPECT_RESPONSE) != 0) {
348 submit_transfer(devc, acq->xfer_in);
351 if (acq->reg_seq_pos < acq->reg_seq_len)
352 acq->reg_seq_pos++; /* register write completed */
354 /* Repeat until all queued registers have been written. */
355 if (acq->reg_seq_pos < acq->reg_seq_len && !devc->cancel_requested) {
357 submit_transfer(devc, acq->xfer_out);
361 switch (devc->state) {
362 case STATE_START_CAPTURE:
363 sr_info("Acquisition started.");
365 if (!devc->cancel_requested)
366 devc->state = STATE_STATUS_WAIT;
368 submit_request(sdi, STATE_STOP_CAPTURE);
370 case STATE_STOP_CAPTURE:
371 if (!devc->cancel_requested)
372 submit_request(sdi, STATE_LENGTH_REQUEST);
374 devc->state = STATE_IDLE;
376 case STATE_READ_PREPARE:
377 if (acq->mem_addr_next < acq->mem_addr_stop && !devc->cancel_requested)
378 submit_request(sdi, STATE_READ_REQUEST);
380 submit_request(sdi, STATE_READ_FINISH);
382 case STATE_READ_FINISH:
383 devc->state = STATE_IDLE;
386 sr_err("Unexpected device state %d.", devc->state);
387 devc->transfer_error = TRUE;
392 /* USB input transfer completion callback.
394 static void LIBUSB_CALL transfer_in_completed(struct libusb_transfer *transfer)
396 const struct sr_dev_inst *sdi;
397 struct dev_context *devc;
398 struct acquisition_state *acq;
400 sdi = transfer->user_data;
402 acq = devc->acquisition;
404 if (transfer->status != LIBUSB_TRANSFER_COMPLETED) {
405 sr_err("Transfer from device failed (state %d): %s.",
406 devc->state, libusb_error_name(transfer->status));
407 devc->transfer_error = TRUE;
410 if ((devc->state & STATE_EXPECT_RESPONSE) == 0) {
411 sr_err("Unexpected completion of input transfer (state %d).",
413 devc->transfer_error = TRUE;
417 if (acq->reg_seq_pos < acq->reg_seq_len && !devc->cancel_requested) {
418 /* Complete register read sequence. */
419 if (read_reg_response(acq) != SR_OK) {
420 devc->transfer_error = TRUE;
423 /* Repeat until all queued registers have been read. */
424 if (++acq->reg_seq_pos < acq->reg_seq_len) {
426 submit_transfer(devc, acq->xfer_out);
431 switch (devc->state) {
432 case STATE_STATUS_REQUEST:
433 if (devc->cancel_requested)
434 submit_request(sdi, STATE_STOP_CAPTURE);
436 handle_status_response(sdi);
438 case STATE_LENGTH_REQUEST:
439 if (devc->cancel_requested)
440 submit_request(sdi, STATE_READ_FINISH);
442 handle_length_response(sdi);
444 case STATE_READ_REQUEST:
445 handle_read_response(sdi);
448 sr_err("Unexpected device state %d.", devc->state);
449 devc->transfer_error = TRUE;
454 /* Set up the acquisition state record.
456 static int init_acquisition_state(const struct sr_dev_inst *sdi)
458 struct dev_context *devc;
459 struct sr_usb_dev_inst *usb;
460 struct acquisition_state *acq;
465 if (devc->acquisition) {
466 sr_err("Acquisition still in progress?");
469 if (devc->cfg_clock_source == CLOCK_INTERNAL && devc->samplerate == 0) {
470 sr_err("Samplerate not set.");
474 acq = g_try_malloc0(sizeof(struct acquisition_state));
476 return SR_ERR_MALLOC;
478 acq->xfer_in = libusb_alloc_transfer(0);
481 return SR_ERR_MALLOC;
483 acq->xfer_out = libusb_alloc_transfer(0);
484 if (!acq->xfer_out) {
485 libusb_free_transfer(acq->xfer_in);
487 return SR_ERR_MALLOC;
490 libusb_fill_bulk_transfer(acq->xfer_out, usb->devhdl, EP_COMMAND,
491 (unsigned char *)acq->xfer_buf_out, 0,
492 &transfer_out_completed,
493 (struct sr_dev_inst *)sdi, USB_TIMEOUT_MS);
495 libusb_fill_bulk_transfer(acq->xfer_in, usb->devhdl, EP_REPLY,
496 (unsigned char *)acq->xfer_buf_in,
497 sizeof(acq->xfer_buf_in),
498 &transfer_in_completed,
499 (struct sr_dev_inst *)sdi, USB_TIMEOUT_MS);
501 if (devc->limit_msec > 0) {
502 acq->duration_max = devc->limit_msec;
503 sr_info("Acquisition time limit %" PRIu64 " ms.",
506 acq->duration_max = MAX_LIMIT_MSEC;
508 if (devc->limit_samples > 0) {
509 acq->samples_max = devc->limit_samples;
510 sr_info("Acquisition sample count limit %" PRIu64 ".",
511 devc->limit_samples);
513 acq->samples_max = MAX_LIMIT_SAMPLES;
515 if (devc->cfg_clock_source == CLOCK_INTERNAL) {
516 sr_info("Internal clock, samplerate %" PRIu64 ".",
518 /* Ramp up clock speed to enable samplerates above 100 MS/s. */
519 acq->clock_boost = (devc->samplerate > SR_MHZ(100));
521 /* If only one of the limits is set, derive the other one. */
522 if (devc->limit_msec == 0 && devc->limit_samples > 0)
523 acq->duration_max = devc->limit_samples
524 * 1000 / devc->samplerate + 1;
525 else if (devc->limit_samples == 0 && devc->limit_msec > 0)
526 acq->samples_max = devc->limit_msec
527 * devc->samplerate / 1000;
529 acq->clock_boost = TRUE;
531 if (devc->cfg_clock_edge == EDGE_POSITIVE)
532 sr_info("External clock, rising edge.");
534 sr_info("External clock, falling edge.");
537 acq->rle_enabled = devc->cfg_rle;
538 devc->acquisition = acq;
543 SR_PRIV int lwla_start_acquisition(const struct sr_dev_inst *sdi)
545 struct drv_context *drvc;
546 struct dev_context *devc;
549 const int poll_interval_ms = 100;
551 drvc = sdi->driver->context;
554 if (devc->state != STATE_IDLE) {
555 sr_err("Not in idle state, cannot start acquisition.");
558 devc->cancel_requested = FALSE;
559 devc->transfer_error = FALSE;
561 ret = init_acquisition_state(sdi);
565 ret = (*devc->model->setup_acquisition)(sdi);
567 sr_err("Failed to set up device for acquisition.");
568 clear_acquisition_state(sdi);
571 /* Register event source for asynchronous USB I/O. */
572 ret = usb_source_add(sdi->session, drvc->sr_ctx, poll_interval_ms,
573 &transfer_event, (struct sr_dev_inst *)sdi);
575 clear_acquisition_state(sdi);
578 ret = submit_request(sdi, STATE_START_CAPTURE);
581 /* Send header packet to the session bus. */
582 ret = std_session_send_df_header(sdi, LOG_PREFIX);
585 usb_source_remove(sdi->session, drvc->sr_ctx);
586 clear_acquisition_state(sdi);