| Line | Branch | Exec | Source |
|---|---|---|---|
| 1 | /* | ||
| 2 | * Next Biometrics driver for libfprint | ||
| 3 | * | ||
| 4 | * Copyright (C) 2021 Huan Wang <fredwanghuan@gmail.com> | ||
| 5 | * Copyright (C) 2011-2012 Andrej Krutak <dev@andree.sk> | ||
| 6 | * | ||
| 7 | * This library is free software; you can redistribute it and/or | ||
| 8 | * modify it under the terms of the GNU Lesser General Public | ||
| 9 | * License as published by the Free Software Foundation; either | ||
| 10 | * version 2.1 of the License, or (at your option) any later version. | ||
| 11 | * | ||
| 12 | * This library is distributed in the hope that it will be useful, | ||
| 13 | * but WITHOUT ANY WARRANTY; without even the implied warranty of | ||
| 14 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | ||
| 15 | * Lesser General Public License for more details. | ||
| 16 | * | ||
| 17 | * You should have received a copy of the GNU Lesser General Public | ||
| 18 | * License along with this library; if not, write to the Free Software | ||
| 19 | * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA | ||
| 20 | */ | ||
| 21 | |||
| 22 | #define FP_COMPONENT "nb1010" | ||
| 23 | #include "fpi-log.h" | ||
| 24 | |||
| 25 | #include "drivers_api.h" | ||
| 26 | |||
| 27 | #define FRAME_HEIGHT 180 | ||
| 28 | #define FRAME_WIDTH 256 | ||
| 29 | |||
| 30 | #define NB1010_EP_OUT 0x02 | FPI_USB_ENDPOINT_OUT | ||
| 31 | #define NB1010_EP_IN 0x03 | FPI_USB_ENDPOINT_IN | ||
| 32 | |||
| 33 | #define NB1010_SENSITIVITY_BIT 12 | ||
| 34 | |||
| 35 | #define NB1010_CMD_RECV_LEN 16 | ||
| 36 | #define NB1010_CAPTURE_RECV_LEN 540 | ||
| 37 | #define NB1010_CAPTURE_HEADER_LEN 25 | ||
| 38 | |||
| 39 | #define NB1010_LINE_PER_PARTIAL 2 | ||
| 40 | #define NB1010_N_PARTIAL (FRAME_HEIGHT / NB1010_LINE_PER_PARTIAL) | ||
| 41 | |||
| 42 | #define NB1010_DEFAULT_TIMEOUT 500 | ||
| 43 | #define NB1010_TRANSITION_DELAY 50 | ||
| 44 | |||
| 45 | /* Loop ssm states */ | ||
| 46 | enum { | ||
| 47 | M_WAIT_PRINT, | ||
| 48 | M_REQUEST_PRINT, | ||
| 49 | M_CHECK_PRINT, | ||
| 50 | M_READ_PRINT_PRESTART, | ||
| 51 | M_READ_PRINT_START, | ||
| 52 | M_READ_PRINT_POLL, | ||
| 53 | M_SUBMIT_PRINT, | ||
| 54 | |||
| 55 | /* Number of states */ | ||
| 56 | M_LOOP_NUM_STATES, | ||
| 57 | }; | ||
| 58 | |||
| 59 | /* | ||
| 60 | * The Follow Commands are obtained by decoding the usbcap, so it does not expose all the command available to the device. | ||
| 61 | * Known: | ||
| 62 | * 1. every command starts with 0x80 | ||
| 63 | * 2. second byte is the comand, third byte is the seqence nubmer, init with rand, gets incremented | ||
| 64 | * everytime a new instruction is sent to the device. However device does not care or check the sequence, just echo back | ||
| 65 | * whatever chosen by the host. | ||
| 66 | * 3. cmd: 0x07 check, expect [0x80, 0x29...] as response | ||
| 67 | * 4. cmd: 0x16 ???, expect [0x80, 0x20...] as response. Happens during device init. | ||
| 68 | * 5. cmd: 0x13 print device, expect [0x80, 0x23...] as response. Response contains the device string | ||
| 69 | * 6. cmd: 0x38 check finger, expect [0x80, 0x37...] as response. The 14th byte indicate whether finger present [0-255] | ||
| 70 | * 7. cmd: 0x0d ???, expect [0x80, 0x20...] as response. Happens before capture. | ||
| 71 | * 8. cmd: 0x12 capture, expect [0x80, 0x20...] as response. After capture read 90 times in sequence to get all the frame. | ||
| 72 | */ | ||
| 73 | |||
| 74 | static guint8 nb1010_cmd_check_finger[] = { | ||
| 75 | 0x80, 0x38, 0x01, 0x00, 0x08, 0x00, 0x00, 0x00, | ||
| 76 | }; | ||
| 77 | |||
| 78 | /* pre capture, dont know what does it do, but appears everytime a capture begins */ | ||
| 79 | static guint8 nb1010_cmd_precapture[] = { | ||
| 80 | 0x80, 0x0d, 0x03, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, | ||
| 81 | }; | ||
| 82 | |||
| 83 | static guint8 nb1010_cmd_capture[] = { | ||
| 84 | 0x80, 0x12, 0x04, 0x00, 0x20, 0x00, 0x00, 0x00, | ||
| 85 | 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, | ||
| 86 | 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, | ||
| 87 | 0x00, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, | ||
| 88 | }; | ||
| 89 | |||
| 90 | struct _FpiDeviceNb1010 | ||
| 91 | { | ||
| 92 | FpImageDevice parent; | ||
| 93 | FpiSsm *ssm; | ||
| 94 | guint8 *scanline_buf; | ||
| 95 | gboolean deactivating; | ||
| 96 | int partial_received; | ||
| 97 | }; | ||
| 98 | G_DECLARE_FINAL_TYPE (FpiDeviceNb1010, fpi_device_nb1010, FPI, DEVICE_NB1010, FpImageDevice); | ||
| 99 |
3/4✓ Branch 0 (2→3) taken 121 times.
✓ Branch 1 (2→7) taken 145 times.
✓ Branch 2 (4→5) taken 121 times.
✗ Branch 3 (4→7) not taken.
|
387 | G_DEFINE_TYPE (FpiDeviceNb1010, fpi_device_nb1010, FP_TYPE_IMAGE_DEVICE); |
| 100 | |||
| 101 | static void | ||
| 102 | 1 | nb1010_dev_init (FpImageDevice *dev) | |
| 103 | { | ||
| 104 | 1 | FpiDeviceNb1010 *self = FPI_DEVICE_NB1010 (dev); | |
| 105 | 1 | GError *error = NULL; | |
| 106 | |||
| 107 | 1 | g_usb_device_claim_interface (fpi_device_get_usb_device (FP_DEVICE (dev)), 0, 0, &error); | |
| 108 | |||
| 109 | 1 | self->scanline_buf = g_malloc0 (FRAME_WIDTH * FRAME_HEIGHT); | |
| 110 | |||
| 111 | 1 | fpi_image_device_open_complete (dev, error); | |
| 112 | 1 | fp_dbg ("nb1010 Initialized"); | |
| 113 | 1 | } | |
| 114 | |||
| 115 | static void | ||
| 116 | 1 | nb1010_dev_deinit (FpImageDevice *dev) | |
| 117 | { | ||
| 118 | 1 | FpiDeviceNb1010 *self = FPI_DEVICE_NB1010 (dev); | |
| 119 | 1 | GError *error = NULL; | |
| 120 | |||
| 121 |
1/2✓ Branch 0 (2→3) taken 1 times.
✗ Branch 1 (2→4) not taken.
|
1 | g_clear_pointer (&self->scanline_buf, g_free); |
| 122 | |||
| 123 | 1 | g_usb_device_release_interface (fpi_device_get_usb_device (FP_DEVICE (dev)), 0, 0, &error); | |
| 124 | 1 | fpi_image_device_close_complete (dev, error); | |
| 125 | 1 | fp_dbg ("nb1010 Deinitialized"); | |
| 126 | 1 | } | |
| 127 | |||
| 128 | static void | ||
| 129 | 1 | nb1010_dev_activate (FpImageDevice *dev) | |
| 130 | { | ||
| 131 | 1 | FpiDeviceNb1010 *self = FPI_DEVICE_NB1010 (dev); | |
| 132 | |||
| 133 | 1 | self->deactivating = FALSE; | |
| 134 | |||
| 135 | 1 | fpi_image_device_activate_complete (dev, NULL); | |
| 136 | 1 | fp_dbg ("nb1010 Activated"); | |
| 137 | 1 | } | |
| 138 | |||
| 139 | static void | ||
| 140 | 1 | nb1010_dev_deactivated (FpImageDevice *dev, GError * err) | |
| 141 | { | ||
| 142 | 1 | fpi_image_device_deactivate_complete (dev, err); | |
| 143 | 1 | fp_dbg ("nb1010 Deactivated"); | |
| 144 | 1 | } | |
| 145 | |||
| 146 | static void | ||
| 147 | 1 | nb1010_dev_deactivate (FpImageDevice *dev) | |
| 148 | { | ||
| 149 | 1 | FpiDeviceNb1010 *self = FPI_DEVICE_NB1010 (dev); | |
| 150 | |||
| 151 | 1 | self->deactivating = TRUE; | |
| 152 |
1/2✓ Branch 0 (2→3) taken 1 times.
✗ Branch 1 (2→4) not taken.
|
1 | if (self->ssm == NULL) |
| 153 | 1 | nb1010_dev_deactivated (dev, NULL); | |
| 154 | 1 | } | |
| 155 | |||
| 156 | static void | ||
| 157 | 1 | nb1010_request_fingerprint (FpiDeviceNb1010 *dev) | |
| 158 | { | ||
| 159 | 1 | FpiUsbTransfer *transfer = NULL; | |
| 160 | |||
| 161 | 1 | transfer = fpi_usb_transfer_new (FP_DEVICE ( dev)); | |
| 162 | 1 | transfer->short_is_error = TRUE; | |
| 163 | 1 | transfer->ssm = dev->ssm; | |
| 164 | |||
| 165 | 1 | fpi_usb_transfer_fill_bulk_full (transfer, NB1010_EP_OUT, | |
| 166 | nb1010_cmd_check_finger, G_N_ELEMENTS (nb1010_cmd_check_finger), | ||
| 167 | NULL); | ||
| 168 | 1 | fpi_usb_transfer_submit (transfer, NB1010_DEFAULT_TIMEOUT, | |
| 169 | fpi_device_get_cancellable (FP_DEVICE (dev)), | ||
| 170 | fpi_ssm_usb_transfer_cb, NULL); | ||
| 171 | 1 | } | |
| 172 | |||
| 173 | static void | ||
| 174 | 1 | nb1010_check_fingerprint_cb (FpiUsbTransfer *transfer, FpDevice *dev, | |
| 175 | gpointer unused_data, GError *error) | ||
| 176 | { | ||
| 177 | 1 | FpiDeviceNb1010 *self = FPI_DEVICE_NB1010 (dev); | |
| 178 | |||
| 179 |
1/2✗ Branch 0 (2→3) not taken.
✓ Branch 1 (2→5) taken 1 times.
|
1 | if (error) |
| 180 | { | ||
| 181 | ✗ | fpi_ssm_mark_failed (transfer->ssm, error); | |
| 182 | ✗ | return; | |
| 183 | } | ||
| 184 |
1/2✗ Branch 0 (5→6) not taken.
✓ Branch 1 (5→8) taken 1 times.
|
1 | if (self->deactivating) |
| 185 | { | ||
| 186 | ✗ | fpi_ssm_mark_completed (transfer->ssm); | |
| 187 | ✗ | return; | |
| 188 | } | ||
| 189 | |||
| 190 |
1/2✓ Branch 0 (8→9) taken 1 times.
✗ Branch 1 (8→10) not taken.
|
1 | if (transfer->buffer[NB1010_SENSITIVITY_BIT] > 0x30) |
| 191 | 1 | fpi_ssm_next_state (transfer->ssm); | |
| 192 | else | ||
| 193 | ✗ | fpi_ssm_jump_to_state (transfer->ssm, M_WAIT_PRINT); | |
| 194 | } | ||
| 195 | |||
| 196 | static void | ||
| 197 | 1 | nb1010_cmd_check_fingerprint (FpiDeviceNb1010 *dev) | |
| 198 | { | ||
| 199 | 1 | FpiUsbTransfer *transfer = NULL; | |
| 200 | |||
| 201 | 1 | transfer = fpi_usb_transfer_new (FP_DEVICE ( dev)); | |
| 202 | 1 | transfer->short_is_error = TRUE; | |
| 203 | 1 | transfer->ssm = dev->ssm; | |
| 204 | |||
| 205 | 1 | fpi_usb_transfer_fill_bulk (transfer, NB1010_EP_IN, NB1010_CMD_RECV_LEN); | |
| 206 | 1 | fpi_usb_transfer_submit (transfer, NB1010_DEFAULT_TIMEOUT, | |
| 207 | fpi_device_get_cancellable (FP_DEVICE (dev)), | ||
| 208 | nb1010_check_fingerprint_cb, NULL); | ||
| 209 | 1 | } | |
| 210 | |||
| 211 | static void | ||
| 212 | 2 | nb1010_read_ignore_data_cb (FpiUsbTransfer *transfer, FpDevice *dev, | |
| 213 | gpointer unused_data, GError *error) | ||
| 214 | { | ||
| 215 | 2 | FpiDeviceNb1010 *self = FPI_DEVICE_NB1010 (dev); | |
| 216 | 2 | FpiUsbTransfer *new_transfer = NULL; | |
| 217 | |||
| 218 |
1/2✗ Branch 0 (2→3) not taken.
✓ Branch 1 (2→5) taken 2 times.
|
2 | if (error) |
| 219 | { | ||
| 220 | ✗ | fpi_ssm_mark_failed (transfer->ssm, error); | |
| 221 | ✗ | return; | |
| 222 | } | ||
| 223 |
1/2✗ Branch 0 (5→6) not taken.
✓ Branch 1 (5→8) taken 2 times.
|
2 | if (self->deactivating) |
| 224 | { | ||
| 225 | ✗ | fpi_ssm_mark_completed (transfer->ssm); | |
| 226 | ✗ | return; | |
| 227 | } | ||
| 228 | |||
| 229 | 2 | new_transfer = fpi_usb_transfer_new ( dev ); | |
| 230 | 2 | new_transfer->short_is_error = TRUE; | |
| 231 | 2 | new_transfer->ssm = transfer->ssm; | |
| 232 | |||
| 233 | 2 | fpi_usb_transfer_fill_bulk (new_transfer, NB1010_EP_IN, NB1010_CMD_RECV_LEN); | |
| 234 | 2 | fpi_usb_transfer_submit (new_transfer, NB1010_DEFAULT_TIMEOUT, | |
| 235 | fpi_device_get_cancellable (FP_DEVICE (dev)), | ||
| 236 | fpi_ssm_usb_transfer_cb, NULL); | ||
| 237 | } | ||
| 238 | |||
| 239 | static void | ||
| 240 | 2 | nb1010_write_ignore_read (FpiDeviceNb1010 *dev, guint8 *buf, gsize len) | |
| 241 | { | ||
| 242 | 2 | FpiUsbTransfer *transfer = NULL; | |
| 243 | |||
| 244 | 2 | transfer = fpi_usb_transfer_new (FP_DEVICE ( dev)); | |
| 245 | 2 | transfer->short_is_error = TRUE; | |
| 246 | 2 | transfer->ssm = dev->ssm; | |
| 247 | |||
| 248 | 2 | fpi_usb_transfer_fill_bulk_full (transfer, NB1010_EP_OUT, buf, len, NULL); | |
| 249 | 2 | fpi_usb_transfer_submit (transfer, NB1010_DEFAULT_TIMEOUT, | |
| 250 | fpi_device_get_cancellable (FP_DEVICE (dev)), | ||
| 251 | nb1010_read_ignore_data_cb, NULL); | ||
| 252 | 2 | } | |
| 253 | |||
| 254 | |||
| 255 | static void | ||
| 256 | 90 | nb1010_read_capture_cb (FpiUsbTransfer *transfer, FpDevice *dev, | |
| 257 | gpointer unused_data, GError *error) | ||
| 258 | { | ||
| 259 | 90 | FpiDeviceNb1010 *self = FPI_DEVICE_NB1010 (dev); | |
| 260 | |||
| 261 |
1/2✗ Branch 0 (2→3) not taken.
✓ Branch 1 (2→5) taken 90 times.
|
90 | if (error) |
| 262 | { | ||
| 263 | ✗ | fpi_ssm_mark_failed (transfer->ssm, error); | |
| 264 | ✗ | return; | |
| 265 | } | ||
| 266 |
1/2✗ Branch 0 (5→6) not taken.
✓ Branch 1 (5→8) taken 90 times.
|
90 | if (self->deactivating) |
| 267 | { | ||
| 268 | ✗ | fpi_ssm_mark_completed (transfer->ssm); | |
| 269 | ✗ | return; | |
| 270 | } | ||
| 271 | |||
| 272 |
1/2✗ Branch 0 (8→9) not taken.
✓ Branch 1 (8→10) taken 90 times.
|
90 | g_assert (transfer->actual_length == NB1010_CAPTURE_RECV_LEN); |
| 273 | |||
| 274 | 90 | size_t offset = self->partial_received * NB1010_LINE_PER_PARTIAL * FRAME_WIDTH; | |
| 275 | |||
| 276 | 90 | memcpy (self->scanline_buf + offset, | |
| 277 | 90 | transfer->buffer + NB1010_CAPTURE_HEADER_LEN, NB1010_LINE_PER_PARTIAL * FRAME_WIDTH); | |
| 278 | |||
| 279 | 90 | self->partial_received++; | |
| 280 |
2/2✓ Branch 0 (10→11) taken 1 times.
✓ Branch 1 (10→13) taken 89 times.
|
90 | if (self->partial_received == NB1010_N_PARTIAL) |
| 281 | { | ||
| 282 | 1 | fpi_ssm_next_state (transfer->ssm); | |
| 283 | 1 | return; | |
| 284 | } | ||
| 285 | |||
| 286 | 89 | fpi_usb_transfer_submit (fpi_usb_transfer_ref (transfer), NB1010_DEFAULT_TIMEOUT, | |
| 287 | fpi_device_get_cancellable (FP_DEVICE (dev)), | ||
| 288 | nb1010_read_capture_cb, NULL); | ||
| 289 | } | ||
| 290 | |||
| 291 | static void | ||
| 292 | 1 | nb1010_read_capture (FpiDeviceNb1010 *dev) | |
| 293 | { | ||
| 294 | 1 | FpiUsbTransfer *transfer = NULL; | |
| 295 | |||
| 296 | 1 | transfer = fpi_usb_transfer_new ( FP_DEVICE ( dev)); | |
| 297 | 1 | transfer->short_is_error = TRUE; | |
| 298 | 1 | transfer->ssm = dev->ssm; | |
| 299 | |||
| 300 | 1 | fpi_usb_transfer_fill_bulk (transfer, NB1010_EP_IN, NB1010_CAPTURE_RECV_LEN); | |
| 301 | 1 | fpi_usb_transfer_submit (transfer, NB1010_DEFAULT_TIMEOUT, | |
| 302 | fpi_device_get_cancellable (FP_DEVICE (dev)), | ||
| 303 | nb1010_read_capture_cb, NULL); | ||
| 304 | 1 | } | |
| 305 | |||
| 306 | static int | ||
| 307 | 1 | submit_image (FpiSsm *ssm, | |
| 308 | FpImageDevice *dev) | ||
| 309 | { | ||
| 310 | 1 | FpiDeviceNb1010 *self = FPI_DEVICE_NB1010 (dev); | |
| 311 | 1 | FpImage *img; | |
| 312 | |||
| 313 | 1 | img = fp_image_new (FRAME_WIDTH, FRAME_HEIGHT); | |
| 314 |
1/2✓ Branch 0 (3→4) taken 1 times.
✗ Branch 1 (3→6) not taken.
|
1 | if (img == NULL) |
| 315 | return 0; | ||
| 316 | |||
| 317 | 1 | memcpy (img->data, self->scanline_buf, FRAME_WIDTH * FRAME_HEIGHT); | |
| 318 | 1 | fpi_image_device_image_captured (dev, img); | |
| 319 | |||
| 320 | 1 | return 1; | |
| 321 | } | ||
| 322 | |||
| 323 | static void | ||
| 324 | 1 | m_loop_complete (FpiSsm *ssm, FpDevice *_dev, GError *error) | |
| 325 | { | ||
| 326 | 1 | fp_dbg ("nb1010 ssm complete cb"); | |
| 327 | |||
| 328 | 1 | FpImageDevice *dev = FP_IMAGE_DEVICE (_dev); | |
| 329 | 1 | FpiDeviceNb1010 *self = FPI_DEVICE_NB1010 (_dev); | |
| 330 | |||
| 331 | 1 | self->ssm = NULL; | |
| 332 | |||
| 333 |
1/2✗ Branch 0 (3→4) not taken.
✓ Branch 1 (3→5) taken 1 times.
|
1 | if (self->deactivating) |
| 334 | ✗ | nb1010_dev_deactivated (dev, error); | |
| 335 |
1/2✗ Branch 0 (5→6) not taken.
✓ Branch 1 (5→7) taken 1 times.
|
1 | else if (error != NULL) |
| 336 | ✗ | fpi_image_device_session_error (dev, error); | |
| 337 | 1 | } | |
| 338 | |||
| 339 | static void | ||
| 340 | 7 | m_loop_state (FpiSsm *ssm, FpDevice *_dev) | |
| 341 | { | ||
| 342 | 7 | FpImageDevice *dev = FP_IMAGE_DEVICE (_dev); | |
| 343 | 7 | FpiDeviceNb1010 *self = FPI_DEVICE_NB1010 (_dev); | |
| 344 | |||
| 345 |
1/2✗ Branch 0 (2→3) not taken.
✓ Branch 1 (2→5) taken 7 times.
|
7 | if (self->deactivating) |
| 346 | { | ||
| 347 | ✗ | fp_dbg ("deactivating, marking completed"); | |
| 348 | ✗ | fpi_ssm_mark_completed (ssm); | |
| 349 | ✗ | return; | |
| 350 | } | ||
| 351 | |||
| 352 |
7/8✓ Branch 0 (6→7) taken 1 times.
✓ Branch 1 (6→9) taken 1 times.
✓ Branch 2 (6→11) taken 1 times.
✓ Branch 3 (6→13) taken 1 times.
✓ Branch 4 (6→16) taken 1 times.
✓ Branch 5 (6→18) taken 1 times.
✓ Branch 6 (6→20) taken 1 times.
✗ Branch 7 (6→25) not taken.
|
7 | switch (fpi_ssm_get_cur_state (ssm)) |
| 353 | { | ||
| 354 | 1 | case M_WAIT_PRINT: | |
| 355 | /* Wait fingerprint scanning */ | ||
| 356 | 1 | fpi_ssm_next_state_delayed (ssm, NB1010_TRANSITION_DELAY); | |
| 357 | 1 | break; | |
| 358 | |||
| 359 | 1 | case M_REQUEST_PRINT: | |
| 360 | 1 | nb1010_request_fingerprint (self); | |
| 361 | 1 | break; | |
| 362 | |||
| 363 | 1 | case M_CHECK_PRINT: | |
| 364 | 1 | nb1010_cmd_check_fingerprint (self); | |
| 365 | 1 | break; | |
| 366 | |||
| 367 | 1 | case M_READ_PRINT_PRESTART: | |
| 368 | 1 | fpi_image_device_report_finger_status (dev, TRUE); | |
| 369 | 1 | nb1010_write_ignore_read (self, nb1010_cmd_precapture, G_N_ELEMENTS (nb1010_cmd_precapture)); | |
| 370 | 1 | break; | |
| 371 | |||
| 372 | 1 | case M_READ_PRINT_START: | |
| 373 | 1 | self->partial_received = 0; | |
| 374 | 1 | nb1010_write_ignore_read (self, nb1010_cmd_capture, G_N_ELEMENTS (nb1010_cmd_capture)); | |
| 375 | 1 | break; | |
| 376 | |||
| 377 | 1 | case M_READ_PRINT_POLL: | |
| 378 | 1 | nb1010_read_capture (self); | |
| 379 | 1 | break; | |
| 380 | |||
| 381 | 1 | case M_SUBMIT_PRINT: | |
| 382 |
1/2✓ Branch 0 (21→22) taken 1 times.
✗ Branch 1 (21→24) not taken.
|
1 | if (submit_image (ssm, dev)) |
| 383 | { | ||
| 384 | 1 | fpi_ssm_mark_completed (ssm); | |
| 385 | 1 | fpi_image_device_report_finger_status (dev, FALSE); | |
| 386 | } | ||
| 387 | else | ||
| 388 | { | ||
| 389 | ✗ | fpi_ssm_jump_to_state (ssm, M_WAIT_PRINT); | |
| 390 | } | ||
| 391 | break; | ||
| 392 | |||
| 393 | ✗ | default: | |
| 394 | ✗ | g_assert_not_reached (); | |
| 395 | } | ||
| 396 | } | ||
| 397 | |||
| 398 | static void | ||
| 399 | 8 | nb1010_dev_change_state (FpImageDevice *dev, FpiImageDeviceState state) | |
| 400 | { | ||
| 401 | 8 | FpiDeviceNb1010 *self = FPI_DEVICE_NB1010 (dev); | |
| 402 | 8 | FpiSsm *ssm_loop; | |
| 403 | |||
| 404 |
2/2✓ Branch 0 (2→3) taken 1 times.
✓ Branch 1 (2→5) taken 7 times.
|
8 | if (state == FPI_IMAGE_DEVICE_STATE_AWAIT_FINGER_ON) |
| 405 | { | ||
| 406 | 1 | ssm_loop = fpi_ssm_new (FP_DEVICE (dev), m_loop_state, M_LOOP_NUM_STATES); | |
| 407 | 1 | self->ssm = ssm_loop; | |
| 408 | 1 | fpi_ssm_start (ssm_loop, m_loop_complete); | |
| 409 | } | ||
| 410 | 8 | } | |
| 411 | |||
| 412 | |||
| 413 | static const FpIdEntry id_table[] = { | ||
| 414 | { .vid = 0x298d, .pid = 0x1010, }, | ||
| 415 | { .vid = 0, .pid = 0, .driver_data = 0 }, | ||
| 416 | }; | ||
| 417 | |||
| 418 | static void | ||
| 419 | 1 | fpi_device_nb1010_init (FpiDeviceNb1010 *self) | |
| 420 | { | ||
| 421 | 1 | } | |
| 422 | |||
| 423 | static void | ||
| 424 | 121 | fpi_device_nb1010_class_init (FpiDeviceNb1010Class *klass) | |
| 425 | { | ||
| 426 | 121 | FpDeviceClass *dev_class = FP_DEVICE_CLASS (klass); | |
| 427 | 121 | FpImageDeviceClass *img_class = FP_IMAGE_DEVICE_CLASS (klass); | |
| 428 | |||
| 429 | 121 | dev_class->id = FP_COMPONENT; | |
| 430 | 121 | dev_class->full_name = "NextBiometrics NB-1010-U"; | |
| 431 | 121 | dev_class->type = FP_DEVICE_TYPE_USB; | |
| 432 | 121 | dev_class->id_table = id_table; | |
| 433 | 121 | dev_class->scan_type = FP_SCAN_TYPE_PRESS; | |
| 434 | |||
| 435 | 121 | img_class->img_height = FRAME_HEIGHT; | |
| 436 | 121 | img_class->img_width = FRAME_WIDTH; | |
| 437 | |||
| 438 | 121 | img_class->bz3_threshold = 24; | |
| 439 | |||
| 440 | 121 | img_class->img_open = nb1010_dev_init; | |
| 441 | 121 | img_class->img_close = nb1010_dev_deinit; | |
| 442 | 121 | img_class->activate = nb1010_dev_activate; | |
| 443 | 121 | img_class->deactivate = nb1010_dev_deactivate; | |
| 444 | 121 | img_class->change_state = nb1010_dev_change_state; | |
| 445 | } | ||
| 446 |