static void sm_exec_cmd(struct fpi_ssm *ssm, unsigned char cmd, unsigned char param) { struct fp_img_dev *dev = ssm->priv; struct libusb_transfer *transfer = libusb_alloc_transfer(0); unsigned char *data; int r; if (!transfer) { fpi_ssm_mark_aborted(ssm, -ENOMEM); return; } fp_dbg("cmd %02x param %02x", cmd, param); data = g_malloc(LIBUSB_CONTROL_SETUP_SIZE); libusb_fill_control_setup(data, CTRL_IN, cmd, param, 0, 0); libusb_fill_control_transfer(transfer, dev->udev, data, sm_exec_cmd_cb, ssm, CTRL_TIMEOUT); r = libusb_submit_transfer(transfer); if (r < 0) { g_free(data); libusb_free_transfer(transfer); fpi_ssm_mark_aborted(ssm, r); } }
static void aesX660_read_response(struct fpi_ssm *ssm, size_t buf_len, libusb_transfer_cb_fn callback) { struct fp_img_dev *dev = ssm->priv; struct libusb_transfer *transfer = libusb_alloc_transfer(0); unsigned char *data; int r; if (!transfer) { fpi_ssm_mark_aborted(ssm, -ENOMEM); return; } data = g_malloc(buf_len); libusb_fill_bulk_transfer(transfer, dev->udev, EP_IN, data, buf_len, callback, ssm, BULK_TIMEOUT); r = libusb_submit_transfer(transfer); if (r < 0) { fp_dbg("Failed to submit rx transfer: %d\n", r); g_free(data); libusb_free_transfer(transfer); fpi_ssm_mark_aborted(ssm, r); } }
static void sm_write_reg(struct fpi_ssm *ssm, unsigned char reg, unsigned char value) { struct fp_img_dev *dev = ssm->priv; struct libusb_transfer *transfer = libusb_alloc_transfer(0); unsigned char *data; int r; if (!transfer) { fpi_ssm_mark_aborted(ssm, -ENOMEM); return; } fp_dbg("set %02x=%02x", reg, value); data = g_malloc(LIBUSB_CONTROL_SETUP_SIZE); libusb_fill_control_setup(data, CTRL_OUT, reg, value, 0, 0); libusb_fill_control_transfer(transfer, dev->udev, data, sm_write_reg_cb, ssm, CTRL_TIMEOUT); r = libusb_submit_transfer(transfer); if (r < 0) { g_free(data); libusb_free_transfer(transfer); fpi_ssm_mark_aborted(ssm, r); } }
static void capture_read_data_cb(struct libusb_transfer *transfer) { struct fpi_ssm *ssm = transfer->user_data; struct fp_img_dev *dev = ssm->priv; unsigned char *data = transfer->buffer; struct fp_img *img; if (transfer->status != LIBUSB_TRANSFER_COMPLETED) { fp_dbg("request is not completed, %d", transfer->status); fpi_ssm_mark_aborted(ssm, -EIO); goto out; } else if (transfer->length != transfer->actual_length) { fp_dbg("expected %d, sent %d bytes", transfer->length, transfer->actual_length); fpi_ssm_mark_aborted(ssm, -EPROTO); goto out; } img = fpi_img_new(IMAGE_SIZE); memcpy(img->data, data, IMAGE_SIZE); fpi_imgdev_image_captured(dev, img); fpi_imgdev_report_finger_status(dev, FALSE); fpi_ssm_mark_completed(ssm); out: g_free(transfer->buffer); libusb_free_transfer(transfer); }
static void et_write_init_cb(struct libusb_transfer* transfer) { struct init_data* adata=transfer->user_data; if(transfer->status!=LIBUSB_TRANSFER_COMPLETED) { fpi_ssm_mark_aborted(adata->ssm,-EIO); } else if(transfer->length!=transfer->actual_length) { fpi_ssm_mark_aborted(adata->ssm,-EPROTO); } else { switch(adata->init->stage) { case 3: case 5: case 7: case 11: case 13: case 15: case 17: case 36: case 40: case 42: case 44: case 46: case 48: case 50: if(!adata->init->rstage) { //fp_dbg("(%02d) ->: %s",adata->init->stage,print_cmd_buf()); adata->init->rstage++; fpi_ssm_jump_to_state(adata->ssm,adata->init->ssm_state); goto _wicb; } else { adata->init->rstage=0; //fp_dbg("(%02d) ->: RETURN BUF %d",adata->init->stage,transfer->actual_length); goto _wicbn; } break; } //fp_dbg("(%02d) ->: %s",adata->init->stage,print_cmd_buf()); _wicbn: fpi_ssm_next_state(adata->ssm); } _wicb: libusb_free_transfer(transfer); }
static void activate_read_id_cb(struct libusb_transfer *transfer) { struct fpi_ssm *ssm = transfer->user_data; struct fp_img_dev *dev = ssm->priv; struct aesX660_dev *aesdev = dev->priv; unsigned char *data = transfer->buffer; if ((transfer->status != LIBUSB_TRANSFER_COMPLETED) || (transfer->length != transfer->actual_length)) { fp_dbg("read_id cmd failed\n"); fpi_ssm_mark_aborted(ssm, -EIO); goto out; } /* ID was read correctly */ if (data[0] == 0x07) { fp_dbg("Sensor device id: %.2x%2x, bcdDevice: %.2x.%.2x, init status: %.2x\n", data[4], data[3], data[5], data[6], data[7]); } else { fp_dbg("Bogus read ID response: %.2x\n", data[AESX660_RESPONSE_TYPE_OFFSET]); fpi_ssm_mark_aborted(ssm, -EPROTO); goto out; } switch (aesdev->init_seq_idx) { case 0: aesdev->init_seq = aesdev->init_seqs[0]; aesdev->init_seq_len = aesdev->init_seqs_len[0]; aesdev->init_seq_idx = 1; aesdev->init_cmd_idx = 0; /* Do calibration only after 1st init sequence */ fpi_ssm_jump_to_state(ssm, ACTIVATE_SEND_INIT_CMD); break; case 1: aesdev->init_seq = aesdev->init_seqs[1]; aesdev->init_seq_len = aesdev->init_seqs_len[1]; aesdev->init_seq_idx = 2; aesdev->init_cmd_idx = 0; fpi_ssm_next_state(ssm); break; default: fp_dbg("Failed to init device! init status: %.2x\n", data[7]); fpi_ssm_mark_aborted(ssm, -EPROTO); break; } out: g_free(transfer->buffer); libusb_free_transfer(transfer); }
static void activate_run_state(struct fpi_ssm *ssm) { struct fp_img_dev *dev = ssm->priv; struct upektc_dev *upekdev = dev->priv; int r; switch (ssm->cur_state) { case WRITE_INIT: { struct libusb_transfer *transfer = libusb_alloc_transfer(0); if (!transfer) { fpi_ssm_mark_aborted(ssm, -ENOMEM); return; } libusb_fill_bulk_transfer(transfer, dev->udev, upekdev->ep_out, (unsigned char*)upekdev->setup_commands[upekdev->init_idx].cmd, UPEKTC_CMD_LEN, write_init_cb, ssm, BULK_TIMEOUT); r = libusb_submit_transfer(transfer); if (r < 0) { libusb_free_transfer(transfer); fpi_ssm_mark_aborted(ssm, -ENOMEM); } } break; case READ_DATA: { struct libusb_transfer *transfer = libusb_alloc_transfer(0); unsigned char *data; if (!transfer) { fpi_ssm_mark_aborted(ssm, -ENOMEM); break; } data = g_malloc(upekdev->setup_commands[upekdev->init_idx].response_len); libusb_fill_bulk_transfer(transfer, dev->udev, upekdev->ep_in, data, upekdev->setup_commands[upekdev->init_idx].response_len, read_init_data_cb, ssm, BULK_TIMEOUT); r = libusb_submit_transfer(transfer); if (r < 0) { g_free(data); libusb_free_transfer(transfer); fpi_ssm_mark_aborted(ssm, r); } } break; } }
static void capture_run_state(struct fpi_ssm *ssm) { struct fp_img_dev *dev = ssm->priv; struct upektc_dev *upekdev = dev->priv; int r; switch (ssm->cur_state) { case CAPTURE_WRITE_CMD: { struct libusb_transfer *transfer = libusb_alloc_transfer(0); if (!transfer) { fpi_ssm_mark_aborted(ssm, -ENOMEM); return; } libusb_fill_bulk_transfer(transfer, dev->udev, upekdev->ep_out, (unsigned char *)scan_cmd, UPEKTC_CMD_LEN, capture_cmd_cb, ssm, BULK_TIMEOUT); r = libusb_submit_transfer(transfer); if (r < 0) { libusb_free_transfer(transfer); fpi_ssm_mark_aborted(ssm, -ENOMEM); } } break; case CAPTURE_READ_DATA: { struct libusb_transfer *transfer = libusb_alloc_transfer(0); unsigned char *data; if (!transfer) { fpi_ssm_mark_aborted(ssm, -ENOMEM); break; } data = g_malloc(IMAGE_SIZE); libusb_fill_bulk_transfer(transfer, dev->udev, upekdev->ep_in, data, IMAGE_SIZE, capture_read_data_cb, ssm, BULK_TIMEOUT); r = libusb_submit_transfer(transfer); if (r < 0) { g_free(data); libusb_free_transfer(transfer); fpi_ssm_mark_aborted(ssm, r); } } break; }; }
static void capture_set_idle_cmd_cb(struct libusb_transfer *transfer) { struct fpi_ssm *ssm = transfer->user_data; struct fp_img_dev *dev = ssm->priv; struct aesX660_dev *aesdev = dev->priv; if ((transfer->status == LIBUSB_TRANSFER_COMPLETED) && (transfer->length == transfer->actual_length)) { struct fp_img *img; aesdev->strips = g_slist_reverse(aesdev->strips); img = fpi_assemble_frames(aesdev->assembling_ctx, aesdev->strips, aesdev->strips_len); img->flags |= aesdev->extra_img_flags; g_slist_foreach(aesdev->strips, (GFunc) g_free, NULL); g_slist_free(aesdev->strips); aesdev->strips = NULL; aesdev->strips_len = 0; fpi_imgdev_image_captured(dev, img); fpi_imgdev_report_finger_status(dev, FALSE); fpi_ssm_mark_completed(ssm); } else { fpi_ssm_mark_aborted(ssm, -EIO); } libusb_free_transfer(transfer); }
static void capture_cb(struct libusb_transfer *transfer) { struct fpi_ssm *ssm = transfer->user_data; struct fp_img_dev *dev = ssm->priv; struct v5s_dev *vdev = dev->priv; if (transfer->status != LIBUSB_TRANSFER_COMPLETED) { fpi_ssm_mark_aborted(ssm, -EIO); goto out; } if (++vdev->capture_iteration == NR_REQS) { struct fp_img *img = vdev->capture_img; /* must clear this early, otherwise the call chain takes us into * loopsm_complete where we would free it, when in fact we are * supposed to be handing off this image */ vdev->capture_img = NULL; fpi_imgdev_report_finger_status(dev, finger_is_present(img->data)); fpi_imgdev_image_captured(dev, img); fpi_ssm_next_state(ssm); } else { capture_iterate(ssm); } out: libusb_free_transfer(transfer); }
static void read_init_data_cb(struct libusb_transfer *transfer) { struct fpi_ssm *ssm = transfer->user_data; if (transfer->status == LIBUSB_TRANSFER_COMPLETED) upektc_next_init_cmd(ssm); else fpi_ssm_mark_aborted(ssm, -EIO); g_free(transfer->buffer); libusb_free_transfer(transfer); }
static void capture_cmd_cb(struct libusb_transfer *transfer) { struct fpi_ssm *ssm = transfer->user_data; if ((transfer->status == LIBUSB_TRANSFER_COMPLETED) && (transfer->length == transfer->actual_length)) { fpi_ssm_next_state(ssm); } else { fpi_ssm_mark_aborted(ssm, -EIO); } libusb_free_transfer(transfer); }
static void sm_write_reg_cb(struct libusb_transfer *transfer) { struct fpi_ssm *ssm = transfer->user_data; if (transfer->status != LIBUSB_TRANSFER_COMPLETED) fpi_ssm_mark_aborted(ssm, -EIO); else fpi_ssm_next_state(ssm); g_free(transfer->buffer); libusb_free_transfer(transfer); }
static void finger_det_read_fd_data_cb(struct libusb_transfer *transfer) { struct fpi_ssm *ssm = transfer->user_data; struct fp_img_dev *dev = ssm->priv; struct aesX660_dev *aesdev = dev->priv; unsigned char *data = transfer->buffer; aesdev->fd_data_transfer = NULL; if (transfer->status == LIBUSB_TRANSFER_CANCELLED) { fp_dbg("Cancelling transfer...\n"); fpi_ssm_next_state(ssm); goto out; } if ((transfer->status != LIBUSB_TRANSFER_COMPLETED) || (transfer->length != transfer->actual_length)) { fp_dbg("Failed to read FD data\n"); fpi_ssm_mark_aborted(ssm, -EIO); goto out; } if (data[AESX660_RESPONSE_TYPE_OFFSET] != AESX660_FINGER_DET_RESPONSE) { fp_dbg("Bogus FD response: %.2x\n", data[0]); fpi_ssm_mark_aborted(ssm, -EPROTO); goto out; } if (data[AESX660_FINGER_PRESENT_OFFSET] == AESX660_FINGER_PRESENT || aesdev->deactivating) { /* Finger present or we're deactivating... */ fpi_ssm_next_state(ssm); } else { fp_dbg("Wait for finger returned %.2x as result\n", data[AESX660_FINGER_PRESENT_OFFSET]); fpi_ssm_jump_to_state(ssm, FINGER_DET_SEND_FD_CMD); } out: g_free(data); libusb_free_transfer(transfer); }
static void capture_read_stripe_data_cb(struct libusb_transfer *transfer) { struct fpi_ssm *ssm = transfer->user_data; struct fp_img_dev *dev = ssm->priv; struct aesX660_dev *aesdev = dev->priv; unsigned char *data = transfer->buffer; int finger_missing = 0; size_t copied, actual_len = transfer->actual_length; if (transfer->status != LIBUSB_TRANSFER_COMPLETED) { fpi_ssm_mark_aborted(ssm, -EIO); goto out; } fp_dbg("Got %d bytes of data", actual_len); do { copied = min(aesdev->buffer_max - aesdev->buffer_size, actual_len); memcpy(aesdev->buffer + aesdev->buffer_size, data, copied); actual_len -= copied; data += copied; aesdev->buffer_size += copied; fp_dbg("Copied %.4x bytes into internal buffer", copied); if (aesdev->buffer_size == aesdev->buffer_max) { if (aesdev->buffer_max == AESX660_HEADER_SIZE) { aesdev->buffer_max = aesdev->buffer[AESX660_RESPONSE_SIZE_LSB_OFFSET] + (aesdev->buffer[AESX660_RESPONSE_SIZE_MSB_OFFSET] << 8) + AESX660_HEADER_SIZE; fp_dbg("Got frame, type %.2x size %.4x", aesdev->buffer[AESX660_RESPONSE_TYPE_OFFSET], aesdev->buffer_max); continue; } else { finger_missing |= process_stripe_data(ssm, aesdev->buffer); aesdev->buffer_max = AESX660_HEADER_SIZE; aesdev->buffer_size = 0; } } } while (actual_len); fp_dbg("finger %s\n", finger_missing ? "missing" : "present"); if (finger_missing) { fpi_ssm_next_state(ssm); } else { fpi_ssm_jump_to_state(ssm, CAPTURE_READ_STRIPE_DATA); } out: g_free(transfer->buffer); libusb_free_transfer(transfer); }
static void et_write_enroll_cb(struct libusb_transfer* transfer) { struct init_data* adata=transfer->user_data; if(transfer->status!=LIBUSB_TRANSFER_COMPLETED) { fpi_ssm_mark_aborted(adata->ssm,-EIO); } else if(transfer->length!=transfer->actual_length) { fpi_ssm_mark_aborted(adata->ssm,-EPROTO); } else { switch(adata->init->stage) { case 26: case 29: case 31: if(!adata->init->rstage) { adata->init->rstage++; fpi_ssm_jump_to_state(adata->ssm,adata->init->ssm_state); goto _out; } else { adata->init->rstage=0; goto _wedcbn; } break; } //fp_dbg("(%02d) ->: %s",adata->init->stage,print_cmd_buf()); _wedcbn: fpi_ssm_next_state(adata->ssm); } _out: libusb_free_transfer(transfer); }
static void aesX660_read_calibrate_data_cb(struct libusb_transfer *transfer) { struct fpi_ssm *ssm = transfer->user_data; unsigned char *data = transfer->buffer; if ((transfer->status != LIBUSB_TRANSFER_COMPLETED) || (transfer->length != transfer->actual_length)) { fpi_ssm_mark_aborted(ssm, -EIO); goto out; } /* Calibrate response was read correctly? */ if (data[AESX660_RESPONSE_TYPE_OFFSET] != AESX660_CALIBRATE_RESPONSE) { fp_dbg("Bogus calibrate response: %.2x\n", data[0]); fpi_ssm_mark_aborted(ssm, -EPROTO); goto out; } fpi_ssm_next_state(ssm); out: g_free(transfer->buffer); libusb_free_transfer(transfer); }
static void aesX660_send_cmd_timeout(struct fpi_ssm *ssm, const unsigned char *cmd, size_t cmd_len, libusb_transfer_cb_fn callback, int timeout) { struct fp_img_dev *dev = ssm->priv; struct libusb_transfer *transfer = libusb_alloc_transfer(0); int r; if (!transfer) { fpi_ssm_mark_aborted(ssm, -ENOMEM); return; } libusb_fill_bulk_transfer(transfer, dev->udev, EP_OUT, (unsigned char *)cmd, cmd_len, callback, ssm, timeout); r = libusb_submit_transfer(transfer); if (r < 0) { fp_dbg("failed to submit transfer\n"); libusb_free_transfer(transfer); fpi_ssm_mark_aborted(ssm, -ENOMEM); } }
static void capture_iterate(struct fpi_ssm *ssm) { struct fp_img_dev *dev = ssm->priv; struct v5s_dev *vdev = dev->priv; int iteration = vdev->capture_iteration; struct libusb_transfer *transfer = libusb_alloc_transfer(0); int r; if (!transfer) { fpi_ssm_mark_aborted(ssm, -ENOMEM); return; } libusb_fill_bulk_transfer(transfer, dev->udev, EP_IN, vdev->capture_img->data + (RQ_SIZE * iteration), RQ_SIZE, capture_cb, ssm, CTRL_TIMEOUT); transfer->flags = LIBUSB_TRANSFER_SHORT_NOT_OK; r = libusb_submit_transfer(transfer); if (r < 0) { libusb_free_transfer(transfer); fpi_ssm_mark_aborted(ssm, r); } }
static void aesX660_send_cmd_cb(struct libusb_transfer *transfer) { struct fpi_ssm *ssm = transfer->user_data; if ((transfer->status == LIBUSB_TRANSFER_COMPLETED) && (transfer->length == transfer->actual_length)) { fpi_ssm_next_state(ssm); } else { fp_dbg("tx transfer status: %d, actual_len: %.4x\n", transfer->status, transfer->actual_length); fpi_ssm_mark_aborted(ssm, -EIO); } libusb_free_transfer(transfer); }
static void activate_read_init_cb(struct libusb_transfer *transfer) { struct fpi_ssm *ssm = transfer->user_data; struct fp_img_dev *dev = ssm->priv; struct aesX660_dev *aesdev = dev->priv; unsigned char *data = transfer->buffer; fp_dbg("read_init_cb\n"); if ((transfer->status != LIBUSB_TRANSFER_COMPLETED) || (transfer->length != transfer->actual_length)) { fp_dbg("read_init transfer status: %d, actual_len: %d\n", transfer->status, transfer->actual_length); fpi_ssm_mark_aborted(ssm, -EIO); goto out; } /* ID was read correctly */ if (data[0] != 0x42 || data[3] != 0x01) { fp_dbg("Bogus read init response: %.2x %.2x\n", data[0], data[3]); fpi_ssm_mark_aborted(ssm, -EPROTO); goto out; } aesdev->init_cmd_idx++; if (aesdev->init_cmd_idx == aesdev->init_seq_len) { if (aesdev->init_seq_idx < 2) fpi_ssm_jump_to_state(ssm, ACTIVATE_SEND_READ_ID_CMD); else fpi_ssm_mark_completed(ssm); goto out; } fpi_ssm_jump_to_state(ssm, ACTIVATE_SEND_INIT_CMD); out: g_free(transfer->buffer); libusb_free_transfer(transfer); }
/* Submit asynchronous sleep */ static void async_sleep(unsigned int msec, struct fpi_ssm *ssm) { struct fp_img_dev *dev = ssm->priv; struct fpi_timeout *timeout; /* Add timeout */ timeout = fpi_timeout_add(msec, async_sleep_cb, ssm); if (timeout == NULL) { /* Failed to add timeout */ fp_err("failed to add timeout"); fpi_imgdev_session_error(dev, -ETIME); fpi_ssm_mark_aborted(ssm, -ETIME); } }
static void write_init_cb(struct libusb_transfer *transfer) { struct fpi_ssm *ssm = transfer->user_data; struct fp_img_dev *dev = ssm->priv; struct upektc_dev *upekdev = dev->priv; if ((transfer->status == LIBUSB_TRANSFER_COMPLETED) && (transfer->length == transfer->actual_length)) { if (upekdev->setup_commands[upekdev->init_idx].response_len) fpi_ssm_next_state(ssm); else upektc_next_init_cmd(ssm); } else { fpi_ssm_mark_aborted(ssm, -EIO); } libusb_free_transfer(transfer); }
static void activate_run_state(struct fpi_ssm *ssm) { int r; struct fp_img_dev *dev = ssm->priv; /* Activation process of SS801U is not understandable at the moment. Simply repeats captured protocol. And, I don't know how to enter in initial state without device reset */ switch (ssm->cur_state) { case 0: //Reset device libusb_release_interface(dev->udev,0); r=libusb_reset_device(dev->udev); if(r<0) { _eop: fpi_ssm_mark_aborted(ssm,r); return; } r=libusb_claim_interface(dev->udev,0); if(r) goto _eop; memset(&einit,0,sizeof(struct et_init)); einit.stage=1; case 2: case 4: case 6: case 8: case 10: case 12: case 14: case 16: case 18: case 20: case 22: case 24: case 26: case 28: case 30: case 32: case 34: case 36: case 38: case 40: case 42: case 44: case 46: case 48: case 50: case 52: case 54: case 56: case 58: case 60: case 62: case 64: case 66: case 68: case 70: case 72: case 74: case 76: case 78: case 80: case 82: case 84: case 86: case 88: case 90: case 92: case 94: case 96: case 98: case 100: case 102: case 104: case 106: case 108: case 110: case 112: case 114: case 116: einit.ssm_state=ssm->cur_state; r=et_write_init(dev,&einit,ssm); if(r) { _mabort: fpi_ssm_mark_aborted(ssm,r); } break; case 1: case 3: case 5: case 7: case 9: case 11: case 13: case 15: case 17: case 19: case 21: case 23: case 25: case 27: case 29: case 31: case 33: case 35: case 37: case 39: case 41: case 43: case 45: case 47: case 49: case 51: case 53: case 55: case 57: case 59: case 61: case 63: case 65: case 67: case 69: case 71: case 73: case 75: case 77: case 79: case 81: case 83: case 85: case 87: case 89: case 91: case 93: case 95: case 97: case 99: case 101: case 103: case 105: case 107: case 109: case 111: case 113: case 115: case 117: einit.ssm_state=ssm->cur_state; r=et_read_answer(dev,&einit,ssm); if(r) goto _mabort; break; } }
static void et_read_enroll_cb(struct libusb_transfer* transfer) { int r; int len; int comb=0; //Combined buffer (data+result) flag char* result; struct init_data* adata=transfer->user_data; if(transfer->status!=LIBUSB_TRANSFER_COMPLETED) { fpi_ssm_mark_aborted(adata->ssm,-EIO); } else { if((transfer->actual_length%2) && transfer->actual_length!=13) comb=1; if(comb) { len=transfer->actual_length-13; //fp_dbg("<-: Read %d (combined)",transfer->actual_length-13); } else { len=transfer->actual_length; //fp_dbg("<-: Read %d",transfer->actual_length); } //Data buffer received if(len!=13) r=et_verify_enroll_data(adata->init,len); else { //fp_dbg("Result: %s",print_buf(ret_buf)); r=et_verify_result(ret_buf); if(r) goto _erv; goto _ern; } //fp_dbg("verified"); if(r) { _erv: fpi_ssm_mark_aborted(adata->ssm,r); goto _eret; } adata->init->rstage++; if(!comb && len!=13) { fp_dbg("We should not be here!"); fpi_ssm_mark_aborted(adata->ssm,-EPROTO); //fpi_ssm_jump_to_state(adata->ssm,adata->init->ssm_state); //Jump back, and receive result } else { //Result received at the end of data switch(adata->init->stage) { case 17: case 18: case 19: case 20: case 21: case 22: case 23: case 24: //fp_dbg("Piece %d: %s",(adata->init->stage-17)+1,print_buf(et_img_buf[adata->init->stage-17])); result=(char*)&et_img_buf[adata->init->stage-17][len]; break; default: result=(char*)&ret_buf[len]; break; } r=et_verify_result(result); if(r) goto _erv; _ern: adata->init->rstage=0; adata->init->stage++; fpi_ssm_next_state(adata->ssm); } } _eret: libusb_free_transfer(transfer); }
static void capture_run_state(struct fpi_ssm *ssm) { struct fp_img_dev *dev = ssm->priv; int r; switch(ssm->cur_state) { case 0: //fp_dbg("Initializing before get image data"); memset(&einit,0,sizeof(struct et_init)); einit.stage=1; case 2: case 4: case 6: case 8: case 10: case 12: case 14: case 16: case 18: case 20: case 22: case 24: case 26: case 28: case 30: case 32: //fp_dbg("Get image from scanner"); case 34: case 36: case 38: case 40: case 42: case 44: case 46: goto _castate; case 48: fp_dbg("Image captured, send stop and reinit"); case 50: case 52: case 54: case 56: case 58: case 60: case 62: case 64: case 66: case 68: case 70: case 72: case 74: case 76: case 78: case 80: _castate: einit.ssm_state=ssm->cur_state; r=et_write_enroll_data(dev,&einit,ssm); if(r) { _cabort: fpi_ssm_mark_aborted(ssm,r); } break; case 1: case 3: case 5: case 7: case 9: case 11: case 13: case 15: case 17: case 19: case 21: case 23: case 25: case 27: case 29: case 31: case 33: case 35: case 37: case 39: case 41: case 43: case 45: case 47: case 49: case 51: case 53: case 55: case 57: case 59: case 61: case 63: case 65: case 67: case 69: case 71: case 73: case 75: case 77: case 79: case 81: r=et_read_enroll_data(dev,&einit,ssm); if(r) goto _cabort; break; } }
static void et_read_answer_cb(struct libusb_transfer* transfer) { int r; int len; int comb=0; //Combined buffer (answer+data) flag char* result; struct init_data* adata=transfer->user_data; if(transfer->status!=LIBUSB_TRANSFER_COMPLETED) { fpi_ssm_mark_aborted(adata->ssm,-EIO); } else { if((transfer->actual_length%2) && transfer->actual_length!=13) comb=1; if(comb) { len=transfer->actual_length-13; //fp_dbg("<-: Read %d (combined)",transfer->actual_length-13); } else { len=transfer->actual_length; //fp_dbg("<-: Read %d",transfer->actual_length); } if(!adata->init->rstage) { //Data buffer received if(len!=13) r=et_verify_answer(adata->init,len); else { //fp_dbg("Result: %s",print_buf(ret_buf)); r=et_verify_result(ret_buf); if(r) goto _erv; goto _ern; } //fp_dbg("verified"); if(r) { _erv: fpi_ssm_mark_aborted(adata->ssm,r); goto _eret; } adata->init->rstage++; if(!comb && len!=13) fpi_ssm_jump_to_state(adata->ssm,adata->init->ssm_state); //Jump back, and receive result else { //Result received at the end of data result=(char*)&ret_buf[len]; r=et_verify_result(result); if(r) goto _erv; _ern: adata->init->rstage=0; adata->init->stage++; fpi_ssm_next_state(adata->ssm); } } else { //Result received if(len!=13) { r=-EPROTO; goto _erv; } r=et_verify_result(ret_buf); if(r) goto _erv; adata->init->stage++; adata->init->rstage=0; fpi_ssm_next_state(adata->ssm); } } _eret: libusb_free_transfer(transfer); }