mirrors/libfprint
1
0
Fork 0
mirror of https://gitlab.freedesktop.org/libfprint/libfprint.git synced 2025-11-15 07:38:12 +00:00
Code Issues Packages Projects Releases Wiki Activity

Merge branch 'egiscalib' into 'master'

Browse Source 
Draft: fix: calibration for egis0570

See merge request libfprint/libfprint!548
This commit is contained in:
Saeed/Ali Rk (PesarAmmehZa)
2025-10-28 13:50:04 +00:00
parent 596b5f8032 05f7631023
commit 0726462d3b
7 changed files with 1624 additions and 18 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
doc/libfprint-2-sections.txt
View File

@@ -40,6 +40,8 @@ fp_device_has_feature
fp_device_has_storage fp_device_has_storage
fp_device_supports_identify fp_device_supports_identify
fp_device_supports_capture fp_device_supports_capture
fp_device_get_persistent_data
fp_device_set_persistent_data
fp_device_is_open fp_device_is_open
fp_device_open fp_device_open
fp_device_close fp_device_close

1007
libfprint/drivers/egis0570.c
View File

File diff suppressed because it is too large Load Diff

415
libfprint/drivers/egis0570.h
View File

@@ -18,10 +18,13 @@
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/ */
#include "drivers_api.h"
#ifndef __EGIS0570_H #ifndef __EGIS0570_H
#define __EGIS0570_H 1 #define __EGIS0570_H 1
/* /*
* Device data * Device data
*/ */
@@ -54,6 +57,33 @@
#define EGIS0570_INIT_TOTAL (sizeof ((init_pkts)) / sizeof ((init_pkts[0]))) #define EGIS0570_INIT_TOTAL (sizeof ((init_pkts)) / sizeof ((init_pkts[0])))
// static unsigned char init_pkts[][EGIS0570_PKTSIZE] =
// {
// { 0x45, 0x47, 0x49, 0x53, 0x01, 0x20, 0x3f },
// { 0x45, 0x47, 0x49, 0x53, 0x01, 0x58, 0x3f },
// { 0x45, 0x47, 0x49, 0x53, 0x01, 0x21, 0x09 },
// { 0x45, 0x47, 0x49, 0x53, 0x01, 0x57, 0x09 },
// { 0x45, 0x47, 0x49, 0x53, 0x01, 0x22, 0x03 },
// { 0x45, 0x47, 0x49, 0x53, 0x01, 0x56, 0x03 },
// { 0x45, 0x47, 0x49, 0x53, 0x01, 0x23, 0x01 },
// { 0x45, 0x47, 0x49, 0x53, 0x01, 0x55, 0x01 },
// { 0x45, 0x47, 0x49, 0x53, 0x01, 0x24, 0x01 },
// { 0x45, 0x47, 0x49, 0x53, 0x01, 0x54, 0x01 },
// { 0x45, 0x47, 0x49, 0x53, 0x01, 0x16, 0x3e },
// { 0x45, 0x47, 0x49, 0x53, 0x01, 0x09, 0x0b },
// { 0x45, 0x47, 0x49, 0x53, 0x01, 0x14, 0x03 },
// { 0x45, 0x47, 0x49, 0x53, 0x01, 0x15, 0x00 },
// { 0x45, 0x47, 0x49, 0x53, 0x01, 0x02, 0x0f },
// { 0x45, 0x47, 0x49, 0x53, 0x01, 0x10, 0x00 },
// { 0x45, 0x47, 0x49, 0x53, 0x01, 0x11, 0x38 },
// { 0x45, 0x47, 0x49, 0x53, 0x01, 0x12, 0x00 },
// { 0x45, 0x47, 0x49, 0x53, 0x01, 0x13, 0x71 },
// { 0x45, 0x47, 0x49, 0x53, 0x01, 0x03, 0x80 },
// { 0x45, 0x47, 0x49, 0x53, 0x00, 0x02, 0x80 },
// { 0x45, 0x47, 0x49, 0x53, 0x01, 0x02, 0x2f },
// { 0x45, 0x47, 0x49, 0x53, 0x06, 0x00, 0xfe } /* image returned after this packet */
// };
static unsigned char init_pkts[][EGIS0570_PKTSIZE] = static unsigned char init_pkts[][EGIS0570_PKTSIZE] =
{ {
{ 0x45, 0x47, 0x49, 0x53, 0x01, 0x20, 0x3f }, { 0x45, 0x47, 0x49, 0x53, 0x01, 0x20, 0x3f },
@@ -66,6 +96,8 @@ static unsigned char init_pkts[][EGIS0570_PKTSIZE] =
{ 0x45, 0x47, 0x49, 0x53, 0x01, 0x55, 0x01 }, { 0x45, 0x47, 0x49, 0x53, 0x01, 0x55, 0x01 },
{ 0x45, 0x47, 0x49, 0x53, 0x01, 0x24, 0x01 }, { 0x45, 0x47, 0x49, 0x53, 0x01, 0x24, 0x01 },
{ 0x45, 0x47, 0x49, 0x53, 0x01, 0x54, 0x01 }, { 0x45, 0x47, 0x49, 0x53, 0x01, 0x54, 0x01 },
{ 0x45, 0x47, 0x49, 0x53, 0x01, 0x25, 0x00 },
{ 0x45, 0x47, 0x49, 0x53, 0x01, 0x53, 0x00 },
{ 0x45, 0x47, 0x49, 0x53, 0x01, 0x16, 0x3e }, { 0x45, 0x47, 0x49, 0x53, 0x01, 0x16, 0x3e },
{ 0x45, 0x47, 0x49, 0x53, 0x01, 0x09, 0x0b }, { 0x45, 0x47, 0x49, 0x53, 0x01, 0x09, 0x0b },
{ 0x45, 0x47, 0x49, 0x53, 0x01, 0x14, 0x03 }, { 0x45, 0x47, 0x49, 0x53, 0x01, 0x14, 0x03 },
@@ -175,3 +207,386 @@ static unsigned char repeat_pkts[][EGIS0570_PKTSIZE] =
#define EGIS0570_RESIZE 2 #define EGIS0570_RESIZE 2
#endif #endif
// Calibration
enum driver_version {
PACKET_CALIBRATION,
PACKET_VERSION_1,
NONE,
};
#define PRESISTENT_DATA_LENGTH 9
#define EGIS0570_CAL_IMG_TOT 22 //124
#define EGIS0570_CAL_INPSIZE 6528
#define EGIS0570_CAL_BS_ELM 7
#define IMG_COL_IGNORE 23
#define TARGET_UPPER 80
#define TARGET_LOWER 70
// #define SIDE_DIFF (-10)
#define SIDE_DIFF (+5)
/* static pkts */
static guint8 EGIS0570_CAL_CONFIGURATION_MODE_PKT[][EGIS0570_PKTSIZE] =
{
{0x45, 0x47, 0x49, 0x53, 0x01, 0x0d, 0x00},
{0x45, 0x47, 0x49, 0x53, 0x01, 0x0e, 0x00},
{0x45, 0x47, 0x49, 0x53, 0x01, 0x02, 0x1f},
{0x45, 0x47, 0x49, 0x53, 0x01, 0x05, 0x08},
{0x45, 0x47, 0x49, 0x53, 0x01, 0x03, 0xff}
};
static guint8 EGIS0570_CAL_PKT_ZERO_RANGE[][EGIS0570_PKTSIZE] =
{
{0x45, 0x47, 0x49, 0x53, 0x01, 0x01, 0x10},
{0x45, 0x47, 0x49, 0x53, 0x01, 0x02, 0x00},
{0x45, 0x47, 0x49, 0x53, 0x01, 0x03, 0x80},
{0x45, 0x47, 0x49, 0x53, 0x01, 0x04, 0x00},
{0x45, 0x47, 0x49, 0x53, 0x01, 0x05, 0x08},
{0x45, 0x47, 0x49, 0x53, 0x01, 0x06, 0x00},
{0x45, 0x47, 0x49, 0x53, 0x01, 0x07, 0x00},
{0x45, 0x47, 0x49, 0x53, 0x01, 0x08, 0x00},
{0x45, 0x47, 0x49, 0x53, 0x01, 0x09, 0x0a},
{0x45, 0x47, 0x49, 0x53, 0x01, 0x0a, 0x00},
{0x45, 0x47, 0x49, 0x53, 0x01, 0x0b, 0x00},
{0x45, 0x47, 0x49, 0x53, 0x01, 0x0c, 0xff},
{0x45, 0x47, 0x49, 0x53, 0x01, 0x0d, 0x00},
{0x45, 0x47, 0x49, 0x53, 0x01, 0x0e, 0x00}
};
static guint8 EGIS0570_CAL_CAPTURING_AREA[][EGIS0570_PKTSIZE] =
{
{0x45, 0x47, 0x49, 0x53, 0x01, 0x10, 0x00},
{0x45, 0x47, 0x49, 0x53, 0x01, 0x11, 0x38},
{0x45, 0x47, 0x49, 0x53, 0x01, 0x12, 0x00},
{0x45, 0x47, 0x49, 0x53, 0x01, 0x13, 0x71}
};
static guint8 EGIS0570_CAL_SENSOR_AND_EMITTER[][EGIS0570_PKTSIZE] =
{
{0x45, 0x47, 0x49, 0x53, 0x01, 0x14, 0x15},
{0x45, 0x47, 0x49, 0x53, 0x01, 0x15, 0x00},
{0x45, 0x47, 0x49, 0x53, 0x01, 0x16, 0x08}
};
static guint8 EGIS0570_CAL_WHITE_SETTING[][EGIS0570_PKTSIZE] =
{
{0x45, 0x47, 0x49, 0x53, 0x01, 0x09, 0x0f},
{0x45, 0x47, 0x49, 0x53, 0x01, 0x14, 0x3f},
{0x45, 0x47, 0x49, 0x53, 0x01, 0x15, 0x00},
{0x45, 0x47, 0x49, 0x53, 0x01, 0x16, 0x00},
{0x45, 0x47, 0x49, 0x53, 0x00, 0x02, 0x00}
};
static guint8 EGIS0570_CAL_BLACK_WHITE_GET_IMAGE[][EGIS0570_PKTSIZE] =
{
{0x45, 0x47, 0x49, 0x53, 0x01, 0x02, 0x20},
{0x45, 0x47, 0x49, 0x53, 0x06, 0x00, 0x33}
};
static guint8 EGIS0570_CAL_BLACK_WHITE_AFTER_IMAGE[][EGIS0570_PKTSIZE] =
{
{0x45, 0x47, 0x49, 0x53, 0x01, 0x02, 0x00}
};
static guint8 EGIS0570_CAL_BLACK_SETTING[][EGIS0570_PKTSIZE] =
{
{0x45, 0x47, 0x49, 0x53, 0x01, 0x09, 0x00},
{0x45, 0x47, 0x49, 0x53, 0x01, 0x14, 0x00},
{0x45, 0x47, 0x49, 0x53, 0x01, 0x15, 0x03},
{0x45, 0x47, 0x49, 0x53, 0x01, 0x16, 0xff},
{0x45, 0x47, 0x49, 0x53, 0x00, 0x02, 0xff}
};
static guint8 EGIS0570_CAL_BLACK_WHITE_CLEAR[][EGIS0570_PKTSIZE] =
{
{0x45, 0x47, 0x49, 0x53, 0x01, 0x15, 0x00},
{0x45, 0x47, 0x49, 0x53, 0x01, 0x16, 0x00},
{0x45, 0x47, 0x49, 0x53, 0x01, 0x09, 0x00},
{0x45, 0x47, 0x49, 0x53, 0x01, 0x14, 0x00},
{0x45, 0x47, 0x49, 0x53, 0x01, 0x02, 0x0f},
{0x45, 0x47, 0x49, 0x53, 0x01, 0x03, 0x80},
{0x45, 0x47, 0x49, 0x53, 0x01, 0x09, 0x00},
{0x45, 0x47, 0x49, 0x53, 0x01, 0x14, 0x00},
{0x45, 0x47, 0x49, 0x53, 0x01, 0x15, 0x00},
{0x45, 0x47, 0x49, 0x53, 0x01, 0x16, 0x00}
};
static guint8 EGIS0570_CAL_MIDDLE_BLACK_SETTING[][EGIS0570_PKTSIZE] =
{
{0x45, 0x47, 0x49, 0x53, 0x01, 0x09, 0x0a},
{0x45, 0x47, 0x49, 0x53, 0x01, 0x15, 0x00},
{0x45, 0x47, 0x49, 0x53, 0x01, 0x16, 0x7f},
{0x45, 0x47, 0x49, 0x53, 0x00, 0x02, 0x7f},
{0x45, 0x47, 0x49, 0x53, 0x01, 0x02, 0x2f}
};
static guint8 EGIS0570_CAL_GET_IMAGE[][EGIS0570_PKTSIZE] =
{
{0x45, 0x47, 0x49, 0x53, 0x06, 0x00, 0x33}
};
static guint8 EGIS0570_CAL_AFTER_IMAGE[][EGIS0570_PKTSIZE] =
{
{0x45, 0x47, 0x49, 0x53, 0x01, 0x02, 0x0f}
};
static guint8 EGIS0570_CAL_REPEAT[][EGIS0570_PKTSIZE] =
{
{0x45, 0x47, 0x49, 0x53, 0x00, 0x02, 0x0f},
{0x45, 0x47, 0x49, 0x53, 0x01, 0x02, 0x2f}
};
static guint8 EGIS0570_CAL_BORDER_WHITE_SETTING[][EGIS0570_PKTSIZE] =
{
{0x45, 0x47, 0x49, 0x53, 0x01, 0x09, 0x0a},
{0x45, 0x47, 0x49, 0x53, 0x01, 0x15, 0x00},
{0x45, 0x47, 0x49, 0x53, 0x01, 0x16, 0x3f},
{0x45, 0x47, 0x49, 0x53, 0x00, 0x02, 0x3f},
{0x45, 0x47, 0x49, 0x53, 0x01, 0x02, 0x2f}
};
static guint8 EGIS0570_CAL_FIRST_BS_SETTING[][EGIS0570_PKTSIZE] =
{
{0x45, 0x47, 0x49, 0x53, 0x01, 0x15, 0x00},
{0x45, 0x47, 0x49, 0x53, 0x01, 0x16, 0x00},
};
static guint8 EGIS0570_CAL_BEFORE_GET_IMAGE[][EGIS0570_PKTSIZE] =
{
{0x45, 0x47, 0x49, 0x53, 0x01, 0x02, 0x2f}
};
static guint8 EGIS0570_CAL_NO_IMAGE_CAPTURING_AREA[][EGIS0570_PKTSIZE] =
{
{0x45, 0x47, 0x49, 0x53, 0x01, 0x10, 0x1c},
{0x45, 0x47, 0x49, 0x53, 0x01, 0x11, 0x1c},
{0x45, 0x47, 0x49, 0x53, 0x01, 0x12, 0x31},
{0x45, 0x47, 0x49, 0x53, 0x01, 0x13, 0x40}
};
static guint8 EGIS0570_CAL_NO_IMAGE_SETTING_0[][EGIS0570_PKTSIZE] =
{
{0x45, 0x47, 0x49, 0x53, 0x01, 0x09, 0x05},
{0x45, 0x47, 0x49, 0x53, 0x01, 0x14, 0x00},
{0x45, 0x47, 0x49, 0x53, 0x01, 0x15, 0x00},
{0x45, 0x47, 0x49, 0x53, 0x01, 0x16, 0x00},
{0x45, 0x47, 0x49, 0x53, 0x01, 0x08, 0x1c}
};
static guint8 EGIS0570_CAL_NO_IMAGE_BINARY_14_SETTING[][EGIS0570_PKTSIZE] =
{
{0x45, 0x47, 0x49, 0x53, 0x01, 0x0b, 0x00},
{0x45, 0x47, 0x49, 0x53, 0x01, 0x0c, 0xff},
{0x45, 0x47, 0x49, 0x53, 0x01, 0x0d, 0x00},
{0x45, 0x47, 0x49, 0x53, 0x01, 0x0e, 0xff},
{0x45, 0x47, 0x49, 0x53, 0x01, 0x02, 0x1d},
{0x45, 0x47, 0x49, 0x53, 0x01, 0x04, 0x00}
};
static guint8 EGIS0570_CAL_NO_IMAGE_PRE_FIRST[][EGIS0570_PKTSIZE] =
{
{0x45, 0x47, 0x49, 0x53, 0x01, 0x01, 0x00},
{0x45, 0x47, 0x49, 0x53, 0x00, 0x01, 0x00}
};
static guint8 EGIS0570_CAL_NO_IMAGE_REQUEST[][EGIS0570_PKTSIZE] =
{
{0x45, 0x47, 0x49, 0x53, 0x01, 0x01, 0x00},
{0x45, 0x47, 0x49, 0x53, 0x00, 0x01, 0x00},
{0x45, 0x47, 0x49, 0x53, 0x00, 0x01, 0x00}
};
#define EGIS0570_CAL_STATIC_LIST_SIZEOF (sizeof ((EGIS0570_CAL_STATIC_LIST)) / sizeof ((EGIS0570_CAL_STATIC_LIST[0])))
static guint8 * EGIS0570_CAL_STATIC_LIST[] = {
*EGIS0570_CAL_CONFIGURATION_MODE_PKT,
*EGIS0570_CAL_PKT_ZERO_RANGE,
*EGIS0570_CAL_CAPTURING_AREA,
*EGIS0570_CAL_SENSOR_AND_EMITTER,
*EGIS0570_CAL_WHITE_SETTING,
*EGIS0570_CAL_BLACK_WHITE_GET_IMAGE,
*EGIS0570_CAL_BLACK_WHITE_AFTER_IMAGE,
*EGIS0570_CAL_BLACK_SETTING,
*EGIS0570_CAL_BLACK_WHITE_CLEAR,
*EGIS0570_CAL_MIDDLE_BLACK_SETTING,
*EGIS0570_CAL_GET_IMAGE,
*EGIS0570_CAL_AFTER_IMAGE,
*EGIS0570_CAL_REPEAT,
*EGIS0570_CAL_BORDER_WHITE_SETTING,
*EGIS0570_CAL_FIRST_BS_SETTING,
*EGIS0570_CAL_BEFORE_GET_IMAGE,
*EGIS0570_CAL_NO_IMAGE_CAPTURING_AREA,
*EGIS0570_CAL_NO_IMAGE_SETTING_0,
*EGIS0570_CAL_NO_IMAGE_BINARY_14_SETTING,
*EGIS0570_CAL_NO_IMAGE_PRE_FIRST,
*EGIS0570_CAL_NO_IMAGE_REQUEST,
};
#define EGIS0570_HELPER_PKT_SIZEOF(x) (sizeof (x) / sizeof (x[0]))
static guint8 EGIS0570_CAL_STATIC_LIST_SIZE[] = {
EGIS0570_HELPER_PKT_SIZEOF (EGIS0570_CAL_CONFIGURATION_MODE_PKT),
EGIS0570_HELPER_PKT_SIZEOF (EGIS0570_CAL_PKT_ZERO_RANGE),
EGIS0570_HELPER_PKT_SIZEOF (EGIS0570_CAL_CAPTURING_AREA),
EGIS0570_HELPER_PKT_SIZEOF (EGIS0570_CAL_SENSOR_AND_EMITTER),
EGIS0570_HELPER_PKT_SIZEOF (EGIS0570_CAL_WHITE_SETTING),
EGIS0570_HELPER_PKT_SIZEOF (EGIS0570_CAL_BLACK_WHITE_GET_IMAGE),
EGIS0570_HELPER_PKT_SIZEOF (EGIS0570_CAL_BLACK_WHITE_AFTER_IMAGE),
EGIS0570_HELPER_PKT_SIZEOF (EGIS0570_CAL_BLACK_SETTING),
EGIS0570_HELPER_PKT_SIZEOF (EGIS0570_CAL_BLACK_WHITE_CLEAR),
EGIS0570_HELPER_PKT_SIZEOF (EGIS0570_CAL_MIDDLE_BLACK_SETTING),
EGIS0570_HELPER_PKT_SIZEOF (EGIS0570_CAL_GET_IMAGE),
EGIS0570_HELPER_PKT_SIZEOF (EGIS0570_CAL_AFTER_IMAGE),
EGIS0570_HELPER_PKT_SIZEOF (EGIS0570_CAL_REPEAT),
EGIS0570_HELPER_PKT_SIZEOF (EGIS0570_CAL_BORDER_WHITE_SETTING),
EGIS0570_HELPER_PKT_SIZEOF (EGIS0570_CAL_FIRST_BS_SETTING),
EGIS0570_HELPER_PKT_SIZEOF (EGIS0570_CAL_BEFORE_GET_IMAGE),
EGIS0570_HELPER_PKT_SIZEOF (EGIS0570_CAL_NO_IMAGE_CAPTURING_AREA),
EGIS0570_HELPER_PKT_SIZEOF (EGIS0570_CAL_NO_IMAGE_SETTING_0),
EGIS0570_HELPER_PKT_SIZEOF (EGIS0570_CAL_NO_IMAGE_BINARY_14_SETTING),
EGIS0570_HELPER_PKT_SIZEOF (EGIS0570_CAL_NO_IMAGE_PRE_FIRST),
EGIS0570_HELPER_PKT_SIZEOF (EGIS0570_CAL_NO_IMAGE_REQUEST),
};
/* Calibration logic */
enum cal_proc_en {
CAL_CONF_PKT,
CAL_PKT_ZERO_RNG,
CAL_CAPT_AREA,
CAL_SENS_AND_EMIT,
CAL_RNG_20_58,
CAL_RNG_60_D0,
CAL_WHITE_SET,
CAL_BLACK_WHITE_GET_IMG,
CAL_BLACK_WHITE_AFTER_IMAGE,
CAL_BLACK_SET,
CAL_CHECK_BLACK_WHITE,
CAL_5_ROWS_ZEROS,
CAL_BLACK_WHITE_CLEAR,
CAL_RNG_60_D1,
CAL_MID_BLACK_SET,
CAL_GET_IMG,
CAL_AFTER_IMG,
CAL_GET_9,
CAL_BORDER_WHITE_SET,
CAL_FIRST_BS_SET,
CAL_BS_CHK_SET,
CAL_PKT_02,
CAL_BEFORE_IMG,
CAL_BS_JUMP,
CAL_BS_END,
CAL_PKT_15_0,
CAL_PKT_16_3C,
CAL_CHK_NEW_CONF,
CAL_GET_21,
CAL_NO_IMG_CAP_AREA,
CAL_NO_IMG_SET_0,
CAL_NO_IMG_03_1C,
CAL_NO_CHK_03_80,
CAL_NO_SET_03_80,
CAL_NO_IMG_14_BS_SET,
CAL_NO_IMG_14_BS_CHK_SET,
CAL_NO_IMG_PRE_FIRST,
CAL_NO_IMG_GET_8,
CAL_NO_IMG_14_BS_JUMP,
CAL_NO_IMG_14_BS_END,
CAL_NO_IMG_16_BS_SET,
CAL_NO_IMG_16_BS_CHK_SET_15,
CAL_NO_IMG_16_BS_SET_16,
CAL_NO_IMG_16_BS_JUMP,
CAL_NO_IMG_16_BS_END,
CAL_END,
};
#define EGIS0570_CAL_PROC_SIZEOF (sizeof ((calibration_procedure)) / sizeof ((calibration_procedure[0])))
static guint8 calibration_procedure[] = {
// conf
CAL_CONF_PKT,
// sensor check
CAL_PKT_ZERO_RNG,
CAL_CAPT_AREA,
CAL_SENS_AND_EMIT,
CAL_RNG_20_58,
CAL_RNG_60_D0,
CAL_WHITE_SET,
CAL_BLACK_WHITE_GET_IMG,
CAL_BLACK_WHITE_AFTER_IMAGE,
CAL_BLACK_SET,
CAL_BLACK_WHITE_GET_IMG,
CAL_BLACK_WHITE_AFTER_IMAGE,
CAL_CHECK_BLACK_WHITE,
// not binary 16
CAL_CAPT_AREA,
CAL_5_ROWS_ZEROS,
CAL_BLACK_WHITE_CLEAR,
CAL_RNG_20_58,
CAL_RNG_60_D1,
CAL_MID_BLACK_SET,
CAL_GET_IMG,
CAL_AFTER_IMG,
CAL_GET_9,
CAL_BORDER_WHITE_SET,
CAL_GET_IMG,
CAL_AFTER_IMG,
CAL_GET_9,
// binary
CAL_FIRST_BS_SET,
CAL_BS_CHK_SET, // 0
CAL_PKT_02, // 1
CAL_BEFORE_IMG, // 2
CAL_GET_IMG, // 3
CAL_AFTER_IMG, // 4
CAL_GET_9, // 5
CAL_BS_JUMP, // 6
CAL_BS_END, // 7
// check pictures.
CAL_PKT_15_0,
CAL_PKT_16_3C,
CAL_CHK_NEW_CONF,
CAL_PKT_02,
CAL_BEFORE_IMG,
CAL_GET_IMG,
CAL_AFTER_IMG,
CAL_GET_21,
// no image 14
CAL_NO_IMG_CAP_AREA,
CAL_NO_IMG_SET_0,
CAL_NO_IMG_03_1C,
CAL_NO_CHK_03_80,
CAL_NO_SET_03_80,
CAL_NO_IMG_14_BS_SET,
CAL_NO_IMG_14_BS_CHK_SET, // 0
CAL_NO_IMG_PRE_FIRST, // 1
CAL_NO_IMG_GET_8, // 2
CAL_NO_IMG_14_BS_JUMP, // 3
CAL_NO_IMG_14_BS_END, // 4
// no image 16
CAL_NO_IMG_16_BS_SET,
CAL_NO_IMG_16_BS_CHK_SET_15, // 0
CAL_NO_IMG_16_BS_SET_16, // 1
CAL_NO_IMG_PRE_FIRST, // 2
CAL_NO_IMG_GET_8, // 3
CAL_NO_IMG_16_BS_JUMP, // 4
CAL_NO_IMG_16_BS_END, // 5
// end
CAL_CONF_PKT,
CAL_CONF_PKT,
CAL_END,
};

1
libfprint/fp-device-private.h
View File

@@ -61,6 +61,7 @@ typedef struct
FpDeviceFeature features; FpDeviceFeature features;
guint64 driver_data; guint64 driver_data;
GVariant *persistent_data;
gint nr_enroll_stages; gint nr_enroll_stages;
GSList *sources; GSList *sources;

160
libfprint/fp-device.c
View File

@@ -54,6 +54,7 @@ enum {
PROP_FPI_UDEV_DATA_SPIDEV, PROP_FPI_UDEV_DATA_SPIDEV,
PROP_FPI_UDEV_DATA_HIDRAW, PROP_FPI_UDEV_DATA_HIDRAW,
PROP_FPI_DRIVER_DATA, PROP_FPI_DRIVER_DATA,
PROP_FPI_PERSISTENT_DATA,
N_PROPS N_PROPS
}; };
@@ -235,6 +236,8 @@ fp_device_finalize (GObject *object)
g_clear_pointer (&priv->udev_data.spidev_path, g_free); g_clear_pointer (&priv->udev_data.spidev_path, g_free);
g_clear_pointer (&priv->udev_data.hidraw_path, g_free); g_clear_pointer (&priv->udev_data.hidraw_path, g_free);
g_clear_pointer (&priv->persistent_data, g_variant_unref);
G_OBJECT_CLASS (fp_device_parent_class)->finalize (object); G_OBJECT_CLASS (fp_device_parent_class)->finalize (object);
} }
@@ -304,6 +307,10 @@ fp_device_get_property (GObject *object,
g_value_set_string (value, NULL); g_value_set_string (value, NULL);
break; break;
case PROP_FPI_PERSISTENT_DATA:
g_value_set_variant (value, priv->persistent_data);
break;
default: default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
} }
@@ -354,6 +361,11 @@ fp_device_set_property (GObject *object,
priv->driver_data = g_value_get_uint64 (value); priv->driver_data = g_value_get_uint64 (value);
break; break;
case PROP_FPI_PERSISTENT_DATA:
g_clear_pointer (&priv->persistent_data, g_variant_unref);
priv->persistent_data = g_value_dup_variant (value);
break;
default: default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
} }
@@ -594,6 +606,21 @@ fp_device_class_init (FpDeviceClass *klass)
0, 0,
G_PARAM_STATIC_STRINGS | G_PARAM_WRITABLE | G_PARAM_CONSTRUCT_ONLY); G_PARAM_STATIC_STRINGS | G_PARAM_WRITABLE | G_PARAM_CONSTRUCT_ONLY);
/**
* FpDevice::fpi-persistent-data: (skip)
*
* This property is only for internal purposes.
*
* Stability: private
*/
properties[PROP_FPI_PERSISTENT_DATA] =
g_param_spec_variant ("fpi-persistent-data",
"Persistent Driver Data",
"Private: Previously stored data for the device",
G_VARIANT_TYPE_ANY,
NULL,
G_PARAM_STATIC_STRINGS | G_PARAM_READWRITE);
g_object_class_install_properties (object_class, N_PROPS, properties); g_object_class_install_properties (object_class, N_PROPS, properties);
} }
@@ -739,6 +766,139 @@ fp_device_get_temperature (FpDevice *device)
return priv->temp_current; return priv->temp_current;
} }
/**
* fp_device_get_persistent_data:
* @device: A #FpDevice
* @data: (array length=length) (transfer full) (out): Return location for data pointer
* @length: (transfer full) (out): Length of @data
* @error: Return location for error
*
* Retrieves persistent data that should be stored for this device. Storage
* needs to be device specific, i.e. device ID and driver must match when
* restored.
*
* Returns: (type void): %TRUE on success
*/
gboolean
fp_device_get_persistent_data (FpDevice *device,
guchar **data,
gsize *length,
GError **error)
{
g_autoptr(GVariant) res = NULL;
FpDevicePrivate *priv = fp_device_get_instance_private (device);
g_assert (data);
g_assert (length);
if (priv->persistent_data == NULL)
{
*data = NULL;
*length = 0;
return TRUE;
}
/* Version + variant from driver */
res = g_variant_new ("(issv)",
1,
fp_device_get_driver (device),
priv->device_id,
priv->persistent_data);
*length = g_variant_get_size (res);
*data = g_malloc (*length);
g_variant_store (res, *data);
return TRUE;
}
/**
* fp_device_get_persistent_data:
* @device: A #FpDevice
* @data: (array length=length) (transfer none): Persistent Data
* @length: (transfer none): Length of @data
* @error: Return location for error
*
* Load persistent data from storage. This function should be called after
* a device was discovered and before it is opened for the first time. It is
* an error to call it if data has already been set (or generated by the
* driver).
*
* Note that the driver may update the data. The API user should retrieve the
* value when done with the device and store it in a persistent location.
*
* Returns: (type void): %TRUE on success
*/
gboolean
fp_device_set_persistent_data (FpDevice *device,
guchar *data,
gsize length,
GError **error)
{
g_autoptr(GVariant) stored = NULL;
g_autoptr(GVariant) loaded = NULL;
FpDevicePrivate *priv = fp_device_get_instance_private (device);
guchar *copy;
gint version;
const gchar *device_id;
const gchar *driver;
if (priv->is_open)
{
g_set_error (error, G_IO_ERROR, G_IO_ERROR_NOT_SUPPORTED,
"Data can only be set right after device creation");
return FALSE;
}
if (priv->persistent_data)
{
g_set_error (error, G_IO_ERROR, G_IO_ERROR_EXISTS,
"Data has already been set");
return FALSE;
}
if (length == 0)
{
g_clear_pointer (&priv->persistent_data, g_variant_unref);
g_object_notify_by_pspec (G_OBJECT (device), properties[PROP_FPI_PERSISTENT_DATA]);
return TRUE;
}
g_assert (data);
copy = g_memdup2 (data, length);
stored = g_variant_new_from_data (G_VARIANT_TYPE ("(issv)"), copy, length, FALSE, g_free, copy);
if (!stored)
{
g_set_error (error, G_IO_ERROR, G_IO_ERROR_INVALID_DATA,
"Data could not be parsed");
return FALSE;
}
g_variant_get (stored, "(issv)", &version, &driver, &device_id, &loaded);
if (version != 1)
{
g_set_error (error, G_IO_ERROR, G_IO_ERROR_INVALID_DATA,
"Unknown data storage version");
return FALSE;
}
if (g_strcmp0 (device_id, priv->device_id) != 0 ||
g_strcmp0 (driver, fp_device_get_driver (device)) != 0)
{
g_set_error (error, G_IO_ERROR, G_IO_ERROR_INVALID_DATA,
"Driver or device ID mismatch!");
return FALSE;
}
g_clear_pointer (&priv->persistent_data, g_variant_unref);
priv->persistent_data = g_steal_pointer (&loaded);
g_object_notify_by_pspec (G_OBJECT (device), properties[PROP_FPI_PERSISTENT_DATA]);
return TRUE;
}
/** /**
* fp_device_supports_identify: * fp_device_supports_identify:
* @device: A #FpDevice * @device: A #FpDevice

9
libfprint/fp-device.h
View File

@@ -233,6 +233,15 @@ FpDeviceFeature fp_device_get_features (FpDevice *device);
gboolean fp_device_has_feature (FpDevice *device, gboolean fp_device_has_feature (FpDevice *device,
FpDeviceFeature feature); FpDeviceFeature feature);
gboolean fp_device_get_persistent_data (FpDevice *device,
guchar **data,
gsize *length,
GError **error);
gboolean fp_device_set_persistent_data (FpDevice *device,
guchar *data,
gsize length,
GError **error);
/* Opening the device */ /* Opening the device */
void fp_device_open (FpDevice *device, void fp_device_open (FpDevice *device,
GCancellable *cancellable, GCancellable *cancellable,

48
tests/test-fp-device.c
View File

@@ -262,6 +262,53 @@ test_device_identify_null_prints (void)
g_assert_error (error, FP_DEVICE_ERROR, FP_DEVICE_ERROR_DATA_INVALID); g_assert_error (error, FP_DEVICE_ERROR, FP_DEVICE_ERROR_DATA_INVALID);
} }
static void
test_device_persistent_data (void)
{
g_autoptr(FptContext) tctx = fpt_context_new_with_virtual_device (FPT_VIRTUAL_DEVICE_IMAGE);
g_autoptr(GVariant) initial = NULL;
g_autoptr(GVariant) loaded = NULL;
g_autoptr(GError) error = NULL;
guint8 *data = (guint8 *) 0xdeadbeef;
gsize length = 1;
initial = g_variant_ref_sink (g_variant_new ("(s)", "stored data"));
g_assert_true (fp_device_get_persistent_data (tctx->device, &data, &length, &error));
g_assert_cmpint (length, ==, 0);
g_assert_null (data);
g_assert_no_error (error);
/* Use the fact that this is a property that we can poke from the outside. */
g_object_set (tctx->device, "fpi-persistent-data", initial, NULL);
/* Works now */
g_assert_true (fp_device_get_persistent_data (tctx->device, &data, &length, &error));
g_assert_cmpint (length, !=, 0);
g_assert_nonnull (data);
g_assert_no_error (error);
/* We can't load the data, as data has been set already. */
g_assert_false (fp_device_set_persistent_data (tctx->device, data, length, &error));
g_assert_error (error, G_IO_ERROR, G_IO_ERROR_EXISTS);
g_clear_pointer (&error, g_error_free);
/* Abuse that we can "load" again if the data is set to NULL.
* This is an implementation detail and just a lack of error checking. */
g_object_set (tctx->device, "fpi-persistent-data", NULL, NULL);
/* Incomplete data, causes parsing error */
g_assert_false (fp_device_set_persistent_data (tctx->device, data, 5, &error));
g_assert_error (error, G_IO_ERROR, G_IO_ERROR_INVALID_DATA);
g_clear_pointer (&error, g_error_free);
g_assert_true (fp_device_set_persistent_data (tctx->device, data, length, &error));
g_assert_no_error (error);
g_object_get (tctx->device, "fpi-persistent-data", &loaded, NULL);
g_assert_cmpvariant (initial, loaded);
}
int int
main (int argc, char *argv[]) main (int argc, char *argv[])
{ {
@@ -284,6 +331,7 @@ main (int argc, char *argv[])
g_test_add_func ("/device/sync/has_storage", test_device_has_storage); g_test_add_func ("/device/sync/has_storage", test_device_has_storage);
g_test_add_func ("/device/sync/identify/cancelled", test_device_identify_cancelled); g_test_add_func ("/device/sync/identify/cancelled", test_device_identify_cancelled);
g_test_add_func ("/device/sync/identify/null-prints", test_device_identify_null_prints); g_test_add_func ("/device/sync/identify/null-prints", test_device_identify_null_prints);
g_test_add_func ("/device/persistent_data", test_device_persistent_data);
return g_test_run (); return g_test_run ();
} }