| Line | Branch | Exec | Source |
|---|---|---|---|
| 1 | /* | ||
| 2 | * UPEK TouchChip driver for libfprint | ||
| 3 | * Copyright (C) 2013 Vasily Khoruzhick <anarsoul@gmail.com> | ||
| 4 | * | ||
| 5 | * This library is free software; you can redistribute it and/or | ||
| 6 | * modify it under the terms of the GNU Lesser General Public | ||
| 7 | * License as published by the Free Software Foundation; either | ||
| 8 | * version 2.1 of the License, or (at your option) any later version. | ||
| 9 | * | ||
| 10 | * This library is distributed in the hope that it will be useful, | ||
| 11 | * but WITHOUT ANY WARRANTY; without even the implied warranty of | ||
| 12 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | ||
| 13 | * Lesser General Public License for more details. | ||
| 14 | * | ||
| 15 | * You should have received a copy of the GNU Lesser General Public | ||
| 16 | * License along with this library; if not, write to the Free Software | ||
| 17 | * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA | ||
| 18 | */ | ||
| 19 | |||
| 20 | #define FP_COMPONENT "upektc_img" | ||
| 21 | |||
| 22 | #include "drivers_api.h" | ||
| 23 | #include "upek_proto.h" | ||
| 24 | #include "upektc_img.h" | ||
| 25 | |||
| 26 | static void start_capture (FpImageDevice *dev); | ||
| 27 | static void start_deactivation (FpImageDevice *dev); | ||
| 28 | |||
| 29 | #define EP_IN (1 | FPI_USB_ENDPOINT_IN) | ||
| 30 | #define EP_OUT (2 | FPI_USB_ENDPOINT_OUT) | ||
| 31 | #define CTRL_TIMEOUT 4000 | ||
| 32 | #define BULK_TIMEOUT 4000 | ||
| 33 | |||
| 34 | #define MAX_CMD_SIZE 64 | ||
| 35 | #define MAX_RESPONSE_SIZE 2052 | ||
| 36 | #define SHORT_RESPONSE_SIZE 64 | ||
| 37 | |||
| 38 | struct _FpiDeviceUpektcImg | ||
| 39 | { | ||
| 40 | FpImageDevice parent; | ||
| 41 | |||
| 42 | unsigned char cmd[MAX_CMD_SIZE]; | ||
| 43 | unsigned char response[MAX_RESPONSE_SIZE]; | ||
| 44 | unsigned char *image_bits; | ||
| 45 | unsigned char seq; | ||
| 46 | size_t expected_image_size; | ||
| 47 | size_t image_size; | ||
| 48 | size_t response_rest; | ||
| 49 | gboolean area_sensor; | ||
| 50 | gboolean deactivating; | ||
| 51 | }; | ||
| 52 | G_DECLARE_FINAL_TYPE (FpiDeviceUpektcImg, fpi_device_upektc_img, FPI, | ||
| 53 | DEVICE_UPEKTC_IMG, FpImageDevice); | ||
| 54 |
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 (FpiDeviceUpektcImg, fpi_device_upektc_img, FP_TYPE_IMAGE_DEVICE); |
| 55 | |||
| 56 | /****** HELPERS ******/ | ||
| 57 | |||
| 58 | static void | ||
| 59 | 70 | upektc_img_cmd_fix_seq (unsigned char *cmd_buf, unsigned char seq) | |
| 60 | { | ||
| 61 | 70 | uint8_t byte; | |
| 62 | |||
| 63 | 70 | byte = cmd_buf[5]; | |
| 64 | 70 | byte &= 0x0f; | |
| 65 | 70 | byte |= (seq << 4); | |
| 66 | 70 | cmd_buf[5] = byte; | |
| 67 | } | ||
| 68 | |||
| 69 | static void | ||
| 70 | 70 | upektc_img_cmd_update_crc (unsigned char *cmd_buf, size_t size) | |
| 71 | { | ||
| 72 | /* CRC does not cover Ciao prefix (4 bytes) and CRC location (2 bytes) */ | ||
| 73 | 70 | uint16_t crc = udf_crc (cmd_buf + 4, size - 6); | |
| 74 | |||
| 75 | 70 | cmd_buf[size - 2] = (crc & 0x00ff); | |
| 76 | 70 | cmd_buf[size - 1] = (crc & 0xff00) >> 8; | |
| 77 | 70 | } | |
| 78 | |||
| 79 | FP_GNUC_ACCESS (read_only, 3, 4) | ||
| 80 | static void | ||
| 81 | 70 | upektc_img_submit_req (FpiSsm *ssm, | |
| 82 | FpImageDevice *dev, | ||
| 83 | const unsigned char *buf, | ||
| 84 | size_t buf_size, | ||
| 85 | unsigned char seq, | ||
| 86 | FpiUsbTransferCallback cb) | ||
| 87 | { | ||
| 88 | 70 | FpiDeviceUpektcImg *self = FPI_DEVICE_UPEKTC_IMG (dev); | |
| 89 | 70 | FpiUsbTransfer *transfer = fpi_usb_transfer_new (FP_DEVICE (dev)); | |
| 90 | |||
| 91 |
1/2✗ Branch 0 (3→4) not taken.
✓ Branch 1 (3→7) taken 70 times.
|
70 | BUG_ON (buf_size > MAX_CMD_SIZE); |
| 92 | |||
| 93 | 70 | memcpy (self->cmd, buf, buf_size); | |
| 94 | 70 | upektc_img_cmd_fix_seq (self->cmd, seq); | |
| 95 | 70 | upektc_img_cmd_update_crc (self->cmd, buf_size); | |
| 96 | |||
| 97 | 70 | fpi_usb_transfer_fill_bulk_full (transfer, EP_OUT, self->cmd, buf_size, | |
| 98 | NULL); | ||
| 99 | 70 | transfer->ssm = ssm; | |
| 100 | 70 | transfer->short_is_error = TRUE; | |
| 101 | 70 | fpi_usb_transfer_submit (transfer, BULK_TIMEOUT, NULL, cb, NULL); | |
| 102 | 70 | } | |
| 103 | |||
| 104 | static void | ||
| 105 | 132 | upektc_img_read_data (FpiSsm *ssm, | |
| 106 | FpImageDevice *dev, | ||
| 107 | size_t buf_size, | ||
| 108 | size_t buf_offset, | ||
| 109 | FpiUsbTransferCallback cb) | ||
| 110 | { | ||
| 111 | 132 | FpiUsbTransfer *transfer = fpi_usb_transfer_new (FP_DEVICE (dev)); | |
| 112 | 132 | FpiDeviceUpektcImg *self = FPI_DEVICE_UPEKTC_IMG (dev); | |
| 113 | |||
| 114 |
1/2✗ Branch 0 (3→4) not taken.
✓ Branch 1 (3→7) taken 132 times.
|
132 | BUG_ON (buf_offset + buf_size > MAX_RESPONSE_SIZE); |
| 115 | |||
| 116 | 132 | fpi_usb_transfer_fill_bulk_full (transfer, EP_IN, | |
| 117 | 132 | self->response + buf_offset, buf_size, | |
| 118 | NULL); | ||
| 119 | 132 | transfer->ssm = ssm; | |
| 120 | 132 | fpi_usb_transfer_submit (transfer, BULK_TIMEOUT, NULL, cb, NULL); | |
| 121 | 132 | } | |
| 122 | |||
| 123 | /****** CAPTURE ******/ | ||
| 124 | |||
| 125 | enum capture_states { | ||
| 126 | CAPTURE_INIT_CAPTURE, | ||
| 127 | CAPTURE_READ_DATA, | ||
| 128 | CAPTURE_READ_DATA_TERM, | ||
| 129 | CAPTURE_ACK_00_28, | ||
| 130 | CAPTURE_ACK_08, | ||
| 131 | CAPTURE_ACK_FRAME, | ||
| 132 | CAPTURE_ACK_00_28_TERM, | ||
| 133 | CAPTURE_NUM_STATES, | ||
| 134 | }; | ||
| 135 | |||
| 136 | static void | ||
| 137 | 60 | capture_reqs_cb (FpiUsbTransfer *transfer, FpDevice *device, | |
| 138 | gpointer user_data, GError *error) | ||
| 139 | { | ||
| 140 |
1/2✗ Branch 0 (2→3) not taken.
✓ Branch 1 (2→5) taken 60 times.
|
60 | if (error) |
| 141 | { | ||
| 142 | ✗ | fpi_ssm_mark_failed (transfer->ssm, error); | |
| 143 | ✗ | return; | |
| 144 | } | ||
| 145 |
1/2✗ Branch 0 (6→7) not taken.
✓ Branch 1 (6→9) taken 60 times.
|
60 | switch (fpi_ssm_get_cur_state (transfer->ssm)) |
| 146 | { | ||
| 147 | ✗ | case CAPTURE_ACK_00_28_TERM: | |
| 148 | ✗ | fpi_ssm_jump_to_state (transfer->ssm, CAPTURE_READ_DATA_TERM); | |
| 149 | ✗ | break; | |
| 150 | |||
| 151 | 60 | default: | |
| 152 | 60 | fpi_ssm_jump_to_state (transfer->ssm, CAPTURE_READ_DATA); | |
| 153 | 60 | break; | |
| 154 | } | ||
| 155 | } | ||
| 156 | |||
| 157 | static int | ||
| 158 | 54 | upektc_img_process_image_frame (unsigned char *image_buf, unsigned char *cmd_res) | |
| 159 | { | ||
| 160 | 54 | int offset = 8; | |
| 161 | 54 | int len = ((cmd_res[5] & 0x0f) << 8) | (cmd_res[6]); | |
| 162 | |||
| 163 | 54 | len -= 1; | |
| 164 |
2/2✓ Branch 0 (2→3) taken 2 times.
✓ Branch 1 (2→4) taken 52 times.
|
54 | if (cmd_res[7] == 0x2c) |
| 165 | { | ||
| 166 | 2 | len -= 10; | |
| 167 | 2 | offset += 10; | |
| 168 | } | ||
| 169 |
2/2✓ Branch 0 (4→5) taken 2 times.
✓ Branch 1 (4→6) taken 52 times.
|
54 | if (cmd_res[7] == 0x20) |
| 170 | 2 | len -= 4; | |
| 171 | 54 | memcpy (image_buf, cmd_res + offset, len); | |
| 172 | |||
| 173 | 54 | return len; | |
| 174 | } | ||
| 175 | |||
| 176 | static void | ||
| 177 | 118 | capture_read_data_cb (FpiUsbTransfer *transfer, FpDevice *device, | |
| 178 | gpointer user_data, GError *error) | ||
| 179 | { | ||
| 180 | 118 | FpImageDevice *dev = FP_IMAGE_DEVICE (device); | |
| 181 |
1/2✗ Branch 0 (2→3) not taken.
✓ Branch 1 (2→6) taken 118 times.
|
118 | FpImageDeviceClass *img_class = FP_IMAGE_DEVICE_GET_CLASS (dev); |
| 182 | 118 | FpiDeviceUpektcImg *self = FPI_DEVICE_UPEKTC_IMG (dev); | |
| 183 | 118 | unsigned char *data = self->response; | |
| 184 | 118 | FpImage *img; | |
| 185 | 118 | size_t response_size; | |
| 186 | |||
| 187 |
1/2✗ Branch 0 (2→3) not taken.
✓ Branch 1 (2→6) taken 118 times.
|
118 | if (error) |
| 188 | { | ||
| 189 | ✗ | fp_dbg ("request is not completed, %s", error->message); | |
| 190 | ✗ | fpi_ssm_mark_failed (transfer->ssm, error); | |
| 191 | ✗ | return; | |
| 192 | } | ||
| 193 | |||
| 194 |
1/2✗ Branch 0 (6→7) not taken.
✓ Branch 1 (6→10) taken 118 times.
|
118 | if (self->deactivating) |
| 195 | { | ||
| 196 | ✗ | fp_dbg ("Deactivate requested"); | |
| 197 | ✗ | fpi_ssm_mark_completed (transfer->ssm); | |
| 198 | ✗ | return; | |
| 199 | } | ||
| 200 | |||
| 201 | 118 | fp_dbg ("request completed, len: %.4x", (gint) transfer->actual_length); | |
| 202 |
2/2✓ Branch 0 (11→12) taken 4 times.
✓ Branch 1 (11→15) taken 114 times.
|
118 | if (transfer->actual_length == 0) |
| 203 | { | ||
| 204 | 4 | fpi_ssm_jump_to_state (transfer->ssm, | |
| 205 | fpi_ssm_get_cur_state (transfer->ssm)); | ||
| 206 | 4 | return; | |
| 207 | } | ||
| 208 | |||
| 209 |
1/2✗ Branch 0 (16→17) not taken.
✓ Branch 1 (16→20) taken 114 times.
|
114 | if (fpi_ssm_get_cur_state (transfer->ssm) == CAPTURE_READ_DATA_TERM) |
| 210 | { | ||
| 211 | ✗ | fp_dbg ("Terminating SSM"); | |
| 212 | ✗ | fpi_ssm_mark_completed (transfer->ssm); | |
| 213 | ✗ | return; | |
| 214 | } | ||
| 215 | |||
| 216 |
2/2✓ Branch 0 (20→21) taken 60 times.
✓ Branch 1 (20→30) taken 54 times.
|
114 | if (!self->response_rest) |
| 217 | { | ||
| 218 | 60 | response_size = ((data[5] & 0x0f) << 8) + data[6]; | |
| 219 | 60 | response_size += 9; /* 7 bytes for header, 2 for CRC */ | |
| 220 |
2/2✓ Branch 0 (21→22) taken 54 times.
✓ Branch 1 (21→30) taken 6 times.
|
60 | if (response_size > transfer->actual_length) |
| 221 | { | ||
| 222 | 54 | fp_dbg ("response_size is %lu, actual_length is %d", | |
| 223 | (gulong) response_size, (gint) transfer->actual_length); | ||
| 224 | 54 | fp_dbg ("Waiting for rest of transfer"); | |
| 225 |
1/2✗ Branch 0 (24→25) not taken.
✓ Branch 1 (24→28) taken 54 times.
|
54 | BUG_ON (self->response_rest); |
| 226 | 54 | self->response_rest = response_size - transfer->actual_length; | |
| 227 | 54 | fpi_ssm_jump_to_state (transfer->ssm, CAPTURE_READ_DATA); | |
| 228 | 54 | return; | |
| 229 | } | ||
| 230 | } | ||
| 231 | 60 | self->response_rest = 0; | |
| 232 | |||
| 233 |
2/3✓ Branch 0 (30→31) taken 59 times.
✓ Branch 1 (30→88) taken 1 times.
✗ Branch 2 (30→90) not taken.
|
60 | switch (data[4]) |
| 234 | { | ||
| 235 | 59 | case 0x00: | |
| 236 |
4/5✓ Branch 0 (31→32) taken 5 times.
✓ Branch 1 (31→69) taken 2 times.
✓ Branch 2 (31→70) taken 50 times.
✓ Branch 3 (31→73) taken 2 times.
✗ Branch 4 (31→84) not taken.
|
59 | switch (data[7]) |
| 237 | { | ||
| 238 | /* No finger */ | ||
| 239 | 5 | case 0x28: | |
| 240 | 5 | fp_dbg ("18th byte is %.2x", data[18]); | |
| 241 |
3/7✓ Branch 0 (33→34) taken 2 times.
✓ Branch 1 (33→36) taken 1 times.
✓ Branch 2 (33→41) taken 2 times.
✗ Branch 3 (33→44) not taken.
✗ Branch 4 (33→47) not taken.
✗ Branch 5 (33→54) not taken.
✗ Branch 6 (33→61) not taken.
|
5 | switch (data[18]) |
| 242 | { | ||
| 243 | 2 | case 0x0c: | |
| 244 | /* no finger */ | ||
| 245 | 2 | fpi_ssm_jump_to_state (transfer->ssm, | |
| 246 | CAPTURE_ACK_00_28); | ||
| 247 | 2 | break; | |
| 248 | |||
| 249 | 1 | case 0x13: | |
| 250 | /* finger is present keep your finger on reader */ | ||
| 251 | 1 | fpi_device_report_finger_status_changes (device, | |
| 252 | FP_FINGER_STATUS_NEEDED, | ||
| 253 | FP_FINGER_STATUS_NONE); | ||
| 254 | 2 | fpi_ssm_jump_to_state (transfer->ssm, | |
| 255 |
1/2✗ Branch 0 (37→38) not taken.
✓ Branch 1 (37→39) taken 1 times.
|
1 | self->area_sensor ? |
| 256 | CAPTURE_ACK_00_28 : CAPTURE_ACK_00_28_TERM); | ||
| 257 | 1 | break; | |
| 258 | |||
| 259 | 2 | case 0x00: | |
| 260 | /* finger is present! */ | ||
| 261 | 2 | fpi_device_report_finger_status_changes (device, | |
| 262 | FP_FINGER_STATUS_PRESENT, | ||
| 263 | FP_FINGER_STATUS_NONE); | ||
| 264 | 2 | fpi_ssm_jump_to_state (transfer->ssm, | |
| 265 | CAPTURE_ACK_00_28); | ||
| 266 | 2 | break; | |
| 267 | |||
| 268 | ✗ | case 0x01: | |
| 269 | /* no finger! */ | ||
| 270 | ✗ | fpi_device_report_finger_status_changes (device, | |
| 271 | FP_FINGER_STATUS_NONE, | ||
| 272 | FP_FINGER_STATUS_PRESENT); | ||
| 273 | ✗ | fpi_ssm_jump_to_state (transfer->ssm, | |
| 274 | CAPTURE_ACK_00_28); | ||
| 275 | ✗ | break; | |
| 276 | |||
| 277 | ✗ | case 0x1e: | |
| 278 | /* short scan */ | ||
| 279 | ✗ | fp_err ("short scan, aborting"); | |
| 280 | ✗ | fpi_image_device_retry_scan (dev, | |
| 281 | FP_DEVICE_RETRY_TOO_SHORT); | ||
| 282 | ✗ | fpi_image_device_report_finger_status (dev, | |
| 283 | FALSE); | ||
| 284 | ✗ | fpi_ssm_jump_to_state (transfer->ssm, | |
| 285 | ✗ | self->area_sensor ? | |
| 286 | CAPTURE_ACK_00_28 : CAPTURE_ACK_00_28_TERM); | ||
| 287 | ✗ | break; | |
| 288 | |||
| 289 | ✗ | case 0x1d: | |
| 290 | /* too much horizontal movement */ | ||
| 291 | ✗ | fp_err ("too much horizontal movement, aborting"); | |
| 292 | ✗ | fpi_image_device_retry_scan (dev, | |
| 293 | FP_DEVICE_RETRY_CENTER_FINGER); | ||
| 294 | ✗ | fpi_image_device_report_finger_status (dev, | |
| 295 | FALSE); | ||
| 296 | ✗ | fpi_ssm_jump_to_state (transfer->ssm, | |
| 297 | ✗ | self->area_sensor ? | |
| 298 | CAPTURE_ACK_00_28 : CAPTURE_ACK_00_28_TERM); | ||
| 299 | ✗ | break; | |
| 300 | |||
| 301 | ✗ | default: | |
| 302 | /* some error happened, cancel scan */ | ||
| 303 | ✗ | fp_err ("something bad happened, stop scan"); | |
| 304 | ✗ | fpi_image_device_retry_scan (dev, | |
| 305 | ✗ | FP_DEVICE_RETRY); | |
| 306 | ✗ | fpi_image_device_report_finger_status (dev, | |
| 307 | FALSE); | ||
| 308 | ✗ | fpi_ssm_jump_to_state (transfer->ssm, | |
| 309 | ✗ | self->area_sensor ? | |
| 310 | CAPTURE_ACK_00_28 : CAPTURE_ACK_00_28_TERM); | ||
| 311 | ✗ | break; | |
| 312 | } | ||
| 313 | break; | ||
| 314 | |||
| 315 | /* Image frame with additional info */ | ||
| 316 | 2 | case 0x2c: | |
| 317 | 2 | fpi_image_device_report_finger_status (dev, | |
| 318 | TRUE); | ||
| 319 | |||
| 320 | /* Plain image frame */ | ||
| 321 | 52 | case 0x24: | |
| 322 | 104 | self->image_size += | |
| 323 | 52 | upektc_img_process_image_frame (self->image_bits + self->image_size, | |
| 324 | data); | ||
| 325 | 52 | fpi_ssm_jump_to_state (transfer->ssm, | |
| 326 | CAPTURE_ACK_FRAME); | ||
| 327 | 52 | break; | |
| 328 | |||
| 329 | /* Last image frame */ | ||
| 330 | 2 | case 0x20: | |
| 331 | 4 | self->image_size += | |
| 332 | 2 | upektc_img_process_image_frame (self->image_bits + self->image_size, | |
| 333 | data); | ||
| 334 |
1/2✗ Branch 0 (74→75) not taken.
✓ Branch 1 (74→78) taken 2 times.
|
2 | BUG_ON (self->image_size != self->expected_image_size); |
| 335 | 2 | fp_dbg ("Image size is %lu", | |
| 336 | (gulong) self->image_size); | ||
| 337 | 2 | img = fp_image_new (img_class->img_width, img_class->img_height); | |
| 338 | 2 | img->flags |= FPI_IMAGE_PARTIAL; | |
| 339 | 2 | memcpy (img->data, self->image_bits, | |
| 340 | self->image_size); | ||
| 341 | 2 | fpi_image_device_image_captured (dev, img); | |
| 342 | 2 | fpi_image_device_report_finger_status (dev, | |
| 343 | FALSE); | ||
| 344 | 2 | fpi_ssm_mark_completed (transfer->ssm); | |
| 345 | 2 | break; | |
| 346 | |||
| 347 | ✗ | default: | |
| 348 | ✗ | fp_err ("Unknown response!"); | |
| 349 | ✗ | fpi_ssm_mark_failed (transfer->ssm, fpi_device_error_new (FP_DEVICE_ERROR_GENERAL)); | |
| 350 | ✗ | break; | |
| 351 | } | ||
| 352 | break; | ||
| 353 | |||
| 354 | 1 | case 0x08: | |
| 355 | 1 | fpi_ssm_jump_to_state (transfer->ssm, CAPTURE_ACK_08); | |
| 356 | 1 | break; | |
| 357 | |||
| 358 | ✗ | default: | |
| 359 | ✗ | fp_err ("Not handled response!"); | |
| 360 | ✗ | fpi_ssm_mark_failed (transfer->ssm, fpi_device_error_new (FP_DEVICE_ERROR_GENERAL)); | |
| 361 | } | ||
| 362 | } | ||
| 363 | |||
| 364 | static void | ||
| 365 | 178 | capture_run_state (FpiSsm *ssm, FpDevice *_dev) | |
| 366 | { | ||
| 367 | 178 | FpImageDevice *dev = FP_IMAGE_DEVICE (_dev); | |
| 368 | 178 | FpiDeviceUpektcImg *self = FPI_DEVICE_UPEKTC_IMG (_dev); | |
| 369 | |||
| 370 |
5/6✓ Branch 0 (3→4) taken 2 times.
✓ Branch 1 (3→8) taken 118 times.
✓ Branch 2 (3→11) taken 5 times.
✓ Branch 3 (3→13) taken 1 times.
✓ Branch 4 (3→15) taken 52 times.
✗ Branch 5 (3→17) not taken.
|
178 | switch (fpi_ssm_get_cur_state (ssm)) |
| 371 | { | ||
| 372 | 2 | case CAPTURE_INIT_CAPTURE: | |
| 373 |
2/2✓ Branch 0 (4→5) taken 1 times.
✓ Branch 1 (4→6) taken 1 times.
|
2 | if (self->area_sensor) |
| 374 | 1 | upektc_img_submit_req (ssm, dev, upek2020_init_capture_press, sizeof (upek2020_init_capture_press), | |
| 375 | 1 | self->seq, capture_reqs_cb); | |
| 376 | else | ||
| 377 | 1 | upektc_img_submit_req (ssm, dev, upek2020_init_capture, sizeof (upek2020_init_capture), | |
| 378 | 1 | self->seq, capture_reqs_cb); | |
| 379 | 2 | self->seq++; | |
| 380 | 2 | break; | |
| 381 | |||
| 382 | 118 | case CAPTURE_READ_DATA: | |
| 383 | case CAPTURE_READ_DATA_TERM: | ||
| 384 |
2/2✓ Branch 0 (8→9) taken 64 times.
✓ Branch 1 (8→10) taken 54 times.
|
118 | if (!self->response_rest) |
| 385 | 64 | upektc_img_read_data (ssm, dev, SHORT_RESPONSE_SIZE, 0, capture_read_data_cb); | |
| 386 | else | ||
| 387 | 54 | upektc_img_read_data (ssm, dev, MAX_RESPONSE_SIZE - SHORT_RESPONSE_SIZE, | |
| 388 | SHORT_RESPONSE_SIZE, capture_read_data_cb); | ||
| 389 | break; | ||
| 390 | |||
| 391 | 5 | case CAPTURE_ACK_00_28: | |
| 392 | case CAPTURE_ACK_00_28_TERM: | ||
| 393 | 5 | upektc_img_submit_req (ssm, dev, upek2020_ack_00_28, sizeof (upek2020_ack_00_28), | |
| 394 | 5 | self->seq, capture_reqs_cb); | |
| 395 | 5 | self->seq++; | |
| 396 | 5 | break; | |
| 397 | |||
| 398 | 1 | case CAPTURE_ACK_08: | |
| 399 | 1 | upektc_img_submit_req (ssm, dev, upek2020_ack_08, sizeof (upek2020_ack_08), | |
| 400 | 0, capture_reqs_cb); | ||
| 401 | 1 | break; | |
| 402 | |||
| 403 | 52 | case CAPTURE_ACK_FRAME: | |
| 404 | 52 | upektc_img_submit_req (ssm, dev, upek2020_ack_frame, sizeof (upek2020_ack_frame), | |
| 405 | 52 | self->seq, capture_reqs_cb); | |
| 406 | 52 | self->seq++; | |
| 407 | 52 | break; | |
| 408 | } | ||
| 409 | 178 | ; | |
| 410 | 178 | } | |
| 411 | |||
| 412 | static void | ||
| 413 | 2 | capture_sm_complete (FpiSsm *ssm, FpDevice *_dev, GError *error_arg) | |
| 414 | { | ||
| 415 | 2 | FpImageDevice *dev = FP_IMAGE_DEVICE (_dev); | |
| 416 | 2 | FpiDeviceUpektcImg *self = FPI_DEVICE_UPEKTC_IMG (_dev); | |
| 417 | |||
| 418 | 4 | g_autoptr(GError) error = error_arg; | |
| 419 | |||
| 420 | |||
| 421 | /* Note: We assume that the error is a cancellation in the deactivation case */ | ||
| 422 |
1/2✓ Branch 0 (2→3) taken 2 times.
✗ Branch 1 (2→4) not taken.
|
2 | if (self->deactivating) |
| 423 | 2 | start_deactivation (dev); | |
| 424 | ✗ | else if (error) | |
| 425 | ✗ | fpi_image_device_session_error (dev, g_steal_pointer (&error)); | |
| 426 | else | ||
| 427 | ✗ | start_capture (dev); | |
| 428 | 2 | } | |
| 429 | |||
| 430 | static void | ||
| 431 | 2 | start_capture (FpImageDevice *dev) | |
| 432 | { | ||
| 433 | 2 | FpiDeviceUpektcImg *self = FPI_DEVICE_UPEKTC_IMG (dev); | |
| 434 | 2 | FpiSsm *ssm; | |
| 435 | |||
| 436 | 2 | self->image_size = 0; | |
| 437 | |||
| 438 | 2 | ssm = fpi_ssm_new (FP_DEVICE (dev), capture_run_state, | |
| 439 | CAPTURE_NUM_STATES); | ||
| 440 | 2 | fpi_ssm_start (ssm, capture_sm_complete); | |
| 441 | 2 | } | |
| 442 | |||
| 443 | /****** INITIALIZATION/DEINITIALIZATION ******/ | ||
| 444 | |||
| 445 | enum deactivate_states { | ||
| 446 | DEACTIVATE_DEINIT, | ||
| 447 | DEACTIVATE_READ_DEINIT_DATA, | ||
| 448 | DEACTIVATE_NUM_STATES, | ||
| 449 | }; | ||
| 450 | |||
| 451 | static void | ||
| 452 | 2 | deactivate_reqs_cb (FpiUsbTransfer *transfer, FpDevice *device, | |
| 453 | gpointer user_data, GError *error) | ||
| 454 | { | ||
| 455 |
1/2✓ Branch 0 (2→3) taken 2 times.
✗ Branch 1 (2→4) not taken.
|
2 | if (!error) |
| 456 | 2 | fpi_ssm_jump_to_state (transfer->ssm, CAPTURE_READ_DATA); | |
| 457 | else | ||
| 458 | ✗ | fpi_ssm_mark_failed (transfer->ssm, error); | |
| 459 | 2 | } | |
| 460 | |||
| 461 | /* TODO: process response properly */ | ||
| 462 | static void | ||
| 463 | 2 | deactivate_read_data_cb (FpiUsbTransfer *transfer, FpDevice *device, | |
| 464 | gpointer user_data, GError *error) | ||
| 465 | { | ||
| 466 |
1/2✓ Branch 0 (2→3) taken 2 times.
✗ Branch 1 (2→4) not taken.
|
2 | if (!error) |
| 467 | 2 | fpi_ssm_mark_completed (transfer->ssm); | |
| 468 | else | ||
| 469 | ✗ | fpi_ssm_mark_failed (transfer->ssm, error); | |
| 470 | 2 | } | |
| 471 | |||
| 472 | static void | ||
| 473 | 4 | deactivate_run_state (FpiSsm *ssm, FpDevice *_dev) | |
| 474 | { | ||
| 475 | 4 | FpImageDevice *dev = FP_IMAGE_DEVICE (_dev); | |
| 476 | 4 | FpiDeviceUpektcImg *self = FPI_DEVICE_UPEKTC_IMG (_dev); | |
| 477 | |||
| 478 |
2/3✓ Branch 0 (3→4) taken 2 times.
✓ Branch 1 (3→6) taken 2 times.
✗ Branch 2 (3→8) not taken.
|
4 | switch (fpi_ssm_get_cur_state (ssm)) |
| 479 | { | ||
| 480 | 2 | case DEACTIVATE_DEINIT: | |
| 481 | 2 | upektc_img_submit_req (ssm, dev, upek2020_deinit, sizeof (upek2020_deinit), | |
| 482 | 2 | self->seq, deactivate_reqs_cb); | |
| 483 | 2 | self->seq++; | |
| 484 | 2 | break; | |
| 485 | |||
| 486 | 2 | case DEACTIVATE_READ_DEINIT_DATA: | |
| 487 | 2 | upektc_img_read_data (ssm, dev, SHORT_RESPONSE_SIZE, 0, deactivate_read_data_cb); | |
| 488 | 2 | break; | |
| 489 | } | ||
| 490 | 4 | ; | |
| 491 | 4 | } | |
| 492 | |||
| 493 | static void | ||
| 494 | 2 | deactivate_sm_complete (FpiSsm *ssm, FpDevice *_dev, GError *error) | |
| 495 | { | ||
| 496 | 2 | FpImageDevice *dev = FP_IMAGE_DEVICE (_dev); | |
| 497 | 2 | FpiDeviceUpektcImg *self = FPI_DEVICE_UPEKTC_IMG (_dev); | |
| 498 | |||
| 499 | 2 | fp_dbg ("Deactivate completed"); | |
| 500 | |||
| 501 | 2 | self->deactivating = FALSE; | |
| 502 | 2 | fpi_image_device_deactivate_complete (dev, error); | |
| 503 | 2 | } | |
| 504 | |||
| 505 | static void | ||
| 506 | 2 | start_deactivation (FpImageDevice *dev) | |
| 507 | { | ||
| 508 | 2 | FpiDeviceUpektcImg *self = FPI_DEVICE_UPEKTC_IMG (dev); | |
| 509 | 2 | FpiSsm *ssm; | |
| 510 | |||
| 511 | 2 | self->image_size = 0; | |
| 512 | |||
| 513 | 2 | ssm = fpi_ssm_new (FP_DEVICE (dev), deactivate_run_state, | |
| 514 | DEACTIVATE_NUM_STATES); | ||
| 515 | 2 | fpi_ssm_start (ssm, deactivate_sm_complete); | |
| 516 | 2 | } | |
| 517 | |||
| 518 | enum activate_states { | ||
| 519 | ACTIVATE_CONTROL_REQ_1, | ||
| 520 | ACTIVATE_READ_CTRL_RESP_1, | ||
| 521 | ACTIVATE_INIT_1, | ||
| 522 | ACTIVATE_READ_INIT_1_RESP, | ||
| 523 | ACTIVATE_INIT_2, | ||
| 524 | ACTIVATE_READ_INIT_2_RESP, | ||
| 525 | ACTIVATE_CONTROL_REQ_2, | ||
| 526 | ACTIVATE_READ_CTRL_RESP_2, | ||
| 527 | ACTIVATE_INIT_3, | ||
| 528 | ACTIVATE_READ_INIT_3_RESP, | ||
| 529 | ACTIVATE_INIT_4, | ||
| 530 | ACTIVATE_READ_INIT_4_RESP, | ||
| 531 | ACTIVATE_NUM_STATES, | ||
| 532 | }; | ||
| 533 | |||
| 534 | static void | ||
| 535 | 8 | init_reqs_cb (FpiUsbTransfer *transfer, FpDevice *device, | |
| 536 | gpointer user_data, GError *error) | ||
| 537 | { | ||
| 538 |
1/2✓ Branch 0 (2→3) taken 8 times.
✗ Branch 1 (2→4) not taken.
|
8 | if (!error) |
| 539 | 8 | fpi_ssm_next_state (transfer->ssm); | |
| 540 | else | ||
| 541 | ✗ | fpi_ssm_mark_failed (transfer->ssm, error); | |
| 542 | 8 | } | |
| 543 | |||
| 544 | static void | ||
| 545 | 12 | init_read_data_cb (FpiUsbTransfer *transfer, FpDevice *device, | |
| 546 | gpointer user_data, GError *error) | ||
| 547 | { | ||
| 548 | 12 | FpImageDevice *dev = FP_IMAGE_DEVICE (device); | |
| 549 | 12 | FpiDeviceUpektcImg *self = FPI_DEVICE_UPEKTC_IMG (dev); | |
| 550 | 12 | unsigned char *data = self->response; | |
| 551 | |||
| 552 |
1/2✗ Branch 0 (2→3) not taken.
✓ Branch 1 (2→5) taken 12 times.
|
12 | if (error) |
| 553 | { | ||
| 554 | ✗ | fpi_ssm_mark_failed (transfer->ssm, error); | |
| 555 | ✗ | return; | |
| 556 | } | ||
| 557 | |||
| 558 |
3/4✓ Branch 0 (5→6) taken 2 times.
✓ Branch 1 (5→44) taken 10 times.
✓ Branch 2 (6→7) taken 2 times.
✗ Branch 3 (6→44) not taken.
|
12 | if (data[12] == 0x06 && data[13] == 0x14) /* if get_info */ |
| 559 | { | ||
| 560 |
2/6✓ Branch 0 (7→8) taken 1 times.
✗ Branch 1 (7→14) not taken.
✗ Branch 2 (7→20) not taken.
✓ Branch 3 (7→26) taken 1 times.
✗ Branch 4 (7→32) not taken.
✗ Branch 5 (7→38) not taken.
|
2 | FpImageDeviceClass *img_class = FP_IMAGE_DEVICE_GET_CLASS (dev); |
| 561 | 2 | uint16_t width = (data[51] << 8) | data[50]; | |
| 562 | 2 | uint16_t height = (data[53] << 8) | data[52]; | |
| 563 | |||
| 564 | 2 | self->area_sensor = !(data[49] & 0x80); | |
| 565 | |||
| 566 |
2/6✓ Branch 0 (7→8) taken 1 times.
✗ Branch 1 (7→14) not taken.
✗ Branch 2 (7→20) not taken.
✓ Branch 3 (7→26) taken 1 times.
✗ Branch 4 (7→32) not taken.
✗ Branch 5 (7→38) not taken.
|
2 | switch (width) |
| 567 | { | ||
| 568 | 1 | case 256: | |
| 569 | 1 | fp_dbg ("Sensor type : TCS1x, width x height: %hu x %hu", width, height); /* 360x256 --- 270x192 must be set */ | |
| 570 |
1/2✗ Branch 0 (9→10) not taken.
✓ Branch 1 (9→13) taken 1 times.
|
1 | BUG_ON (height != 360); |
| 571 | 1 | img_class->img_width = 192; | |
| 572 | 1 | img_class->img_height = 270; | |
| 573 | 1 | break; | |
| 574 | |||
| 575 | ✗ | case 208: | |
| 576 | ✗ | fp_dbg ("Sensor type : TCS2, width x height: %hu x %hu", width, height); /* 288x208 --- 216x156 must be set */ | |
| 577 | ✗ | BUG_ON (height != 288); | |
| 578 | ✗ | img_class->img_width = 156; | |
| 579 | ✗ | img_class->img_height = 216; | |
| 580 | ✗ | break; | |
| 581 | |||
| 582 | ✗ | case 248: | |
| 583 | ✗ | fp_dbg ("Sensor type : TCS3, width x height: %hu x %hu", width, height); /* 360x248 --- 270x186 must be set */ | |
| 584 | ✗ | BUG_ON (height != 360); | |
| 585 | ✗ | img_class->img_width = 186; | |
| 586 | ✗ | img_class->img_height = 270; | |
| 587 | ✗ | break; | |
| 588 | |||
| 589 | 1 | case 192: | |
| 590 | 1 | fp_dbg ("Sensor type : TCS4x, width x height: %hu x %hu", width, height); /* 512x192 --- 384x144 must be set */ | |
| 591 |
1/2✗ Branch 0 (27→28) not taken.
✓ Branch 1 (27→31) taken 1 times.
|
1 | BUG_ON (height != 512); |
| 592 | 1 | img_class->img_width = 144; | |
| 593 | 1 | img_class->img_height = 384; | |
| 594 | 1 | break; | |
| 595 | |||
| 596 | ✗ | case 144: | |
| 597 | ✗ | fp_dbg ("Sensor type : TCS5x, width x height: %hu x %hu", width, height); /* 512x144 --- 384x108 must be set */ | |
| 598 | ✗ | BUG_ON (height != 512); | |
| 599 | ✗ | img_class->img_width = 108; | |
| 600 | ✗ | img_class->img_height = 384; | |
| 601 | ✗ | break; | |
| 602 | |||
| 603 | ✗ | default: | |
| 604 | ✗ | fp_dbg ("Sensor type : Unknown"); | |
| 605 | |||
| 606 | ✗ | fpi_ssm_mark_failed (transfer->ssm, | |
| 607 | fpi_device_error_new_msg (FP_DEVICE_ERROR_PROTO, | ||
| 608 | "Unknown sensor type (reported size %dx%d)", | ||
| 609 | width, height)); | ||
| 610 | |||
| 611 | ✗ | return; | |
| 612 | } | ||
| 613 | |||
| 614 | 2 | self->expected_image_size = img_class->img_width * img_class->img_height; | |
| 615 | 2 | self->image_bits = g_malloc0 (self->expected_image_size * 2); | |
| 616 | } | ||
| 617 | |||
| 618 | 12 | fpi_ssm_next_state (transfer->ssm); | |
| 619 | } | ||
| 620 | |||
| 621 | static void | ||
| 622 | 24 | activate_run_state (FpiSsm *ssm, FpDevice *dev) | |
| 623 | { | ||
| 624 | 24 | FpiUsbTransfer *transfer; | |
| 625 | 24 | FpImageDevice *idev = FP_IMAGE_DEVICE (dev); | |
| 626 | 24 | FpiDeviceUpektcImg *self = FPI_DEVICE_UPEKTC_IMG (dev); | |
| 627 | |||
| 628 |
6/7✓ Branch 0 (3→4) taken 4 times.
✓ Branch 1 (3→8) taken 2 times.
✓ Branch 2 (3→10) taken 2 times.
✓ Branch 3 (3→12) taken 2 times.
✓ Branch 4 (3→14) taken 2 times.
✓ Branch 5 (3→16) taken 12 times.
✗ Branch 6 (3→18) not taken.
|
24 | switch (fpi_ssm_get_cur_state (ssm)) |
| 629 | { | ||
| 630 | 4 | case ACTIVATE_CONTROL_REQ_1: | |
| 631 | case ACTIVATE_CONTROL_REQ_2: | ||
| 632 | { | ||
| 633 | 4 | transfer = fpi_usb_transfer_new (dev); | |
| 634 | |||
| 635 | 4 | fpi_usb_transfer_fill_control (transfer, | |
| 636 | G_USB_DEVICE_DIRECTION_HOST_TO_DEVICE, | ||
| 637 | G_USB_DEVICE_REQUEST_TYPE_VENDOR, | ||
| 638 | G_USB_DEVICE_RECIPIENT_DEVICE, | ||
| 639 | 0x0c, 0x100, 0x0400, 1); | ||
| 640 | 4 | transfer->buffer[0] = '\0'; | |
| 641 | 4 | transfer->ssm = ssm; | |
| 642 | 4 | fpi_usb_transfer_submit (transfer, CTRL_TIMEOUT, NULL, | |
| 643 | fpi_ssm_usb_transfer_cb, NULL); | ||
| 644 | } | ||
| 645 | 4 | break; | |
| 646 | |||
| 647 | 2 | case ACTIVATE_INIT_1: | |
| 648 | 2 | upektc_img_submit_req (ssm, idev, upek2020_init_1, sizeof (upek2020_init_1), | |
| 649 | 0, init_reqs_cb); | ||
| 650 | 2 | break; | |
| 651 | |||
| 652 | 2 | case ACTIVATE_INIT_2: | |
| 653 | 2 | upektc_img_submit_req (ssm, idev, upek2020_init_2, sizeof (upek2020_init_2), | |
| 654 | 0, init_reqs_cb); | ||
| 655 | 2 | break; | |
| 656 | |||
| 657 | 2 | case ACTIVATE_INIT_3: | |
| 658 | 2 | upektc_img_submit_req (ssm, idev, upek2020_init_3, sizeof (upek2020_init_3), | |
| 659 | 0, init_reqs_cb); | ||
| 660 | 2 | break; | |
| 661 | |||
| 662 | 2 | case ACTIVATE_INIT_4: | |
| 663 | 2 | upektc_img_submit_req (ssm, idev, upek2020_init_4, sizeof (upek2020_init_4), | |
| 664 | 2 | self->seq, init_reqs_cb); | |
| 665 | /* Seq should be updated after 4th init */ | ||
| 666 | 2 | self->seq++; | |
| 667 | 2 | break; | |
| 668 | |||
| 669 | 12 | case ACTIVATE_READ_CTRL_RESP_1: | |
| 670 | case ACTIVATE_READ_CTRL_RESP_2: | ||
| 671 | case ACTIVATE_READ_INIT_1_RESP: | ||
| 672 | case ACTIVATE_READ_INIT_2_RESP: | ||
| 673 | case ACTIVATE_READ_INIT_3_RESP: | ||
| 674 | case ACTIVATE_READ_INIT_4_RESP: | ||
| 675 | 12 | upektc_img_read_data (ssm, idev, SHORT_RESPONSE_SIZE, 0, init_read_data_cb); | |
| 676 | 12 | break; | |
| 677 | } | ||
| 678 | 24 | } | |
| 679 | |||
| 680 | static void | ||
| 681 | 2 | activate_sm_complete (FpiSsm *ssm, FpDevice *_dev, GError *error) | |
| 682 | { | ||
| 683 | 2 | FpImageDevice *dev = FP_IMAGE_DEVICE (_dev); | |
| 684 | |||
| 685 | 2 | fpi_image_device_activate_complete (dev, error); | |
| 686 | |||
| 687 |
1/2✓ Branch 0 (3→4) taken 2 times.
✗ Branch 1 (3→5) not taken.
|
2 | if (!error) |
| 688 | 2 | start_capture (dev); | |
| 689 | 2 | } | |
| 690 | |||
| 691 | static void | ||
| 692 | 2 | dev_activate (FpImageDevice *dev) | |
| 693 | { | ||
| 694 | 2 | FpiDeviceUpektcImg *self = FPI_DEVICE_UPEKTC_IMG (dev); | |
| 695 | 2 | FpiSsm *ssm = fpi_ssm_new (FP_DEVICE (dev), activate_run_state, | |
| 696 | ACTIVATE_NUM_STATES); | ||
| 697 | |||
| 698 | 2 | self->seq = 0; | |
| 699 | 2 | fpi_ssm_start (ssm, activate_sm_complete); | |
| 700 | 2 | } | |
| 701 | |||
| 702 | static void | ||
| 703 | 2 | dev_deactivate (FpImageDevice *dev) | |
| 704 | { | ||
| 705 | 2 | FpiDeviceUpektcImg *self = FPI_DEVICE_UPEKTC_IMG (dev); | |
| 706 | |||
| 707 | 2 | self->deactivating = TRUE; | |
| 708 | 2 | } | |
| 709 | |||
| 710 | static void | ||
| 711 | 2 | dev_init (FpImageDevice *dev) | |
| 712 | { | ||
| 713 | 2 | GError *error = NULL; | |
| 714 | |||
| 715 | /* TODO check that device has endpoints we're using */ | ||
| 716 | |||
| 717 |
1/2✗ Branch 0 (4→5) not taken.
✓ Branch 1 (4→7) taken 2 times.
|
2 | if (!g_usb_device_claim_interface (fpi_device_get_usb_device (FP_DEVICE (dev)), 0, 0, &error)) |
| 718 | { | ||
| 719 | ✗ | fpi_image_device_open_complete (dev, error); | |
| 720 | ✗ | return; | |
| 721 | } | ||
| 722 | |||
| 723 | 2 | fpi_image_device_open_complete (dev, NULL); | |
| 724 | } | ||
| 725 | |||
| 726 | static void | ||
| 727 | 2 | dev_deinit (FpImageDevice *dev) | |
| 728 | { | ||
| 729 | 2 | FpiDeviceUpektcImg *self = FPI_DEVICE_UPEKTC_IMG (dev); | |
| 730 | 2 | GError *error = NULL; | |
| 731 | |||
| 732 |
1/2✓ Branch 0 (2→3) taken 2 times.
✗ Branch 1 (2→4) not taken.
|
2 | g_clear_pointer (&self->image_bits, g_free); |
| 733 | 2 | g_usb_device_release_interface (fpi_device_get_usb_device (FP_DEVICE (dev)), | |
| 734 | 0, 0, &error); | ||
| 735 | 2 | fpi_image_device_close_complete (dev, error); | |
| 736 | 2 | } | |
| 737 | |||
| 738 | static int | ||
| 739 | 2 | discover (GUsbDevice *usb_device) | |
| 740 | { | ||
| 741 | 2 | gint16 pid = g_usb_device_get_pid (usb_device); | |
| 742 | 2 | gint16 bcd = g_usb_device_get_release (usb_device); | |
| 743 | |||
| 744 |
1/2✓ Branch 0 (4→5) taken 2 times.
✗ Branch 1 (4→7) not taken.
|
2 | if (pid == 0x2020 && bcd == 1) |
| 745 | return 100; | ||
| 746 |
1/2✓ Branch 0 (5→6) taken 2 times.
✗ Branch 1 (5→7) not taken.
|
2 | if (pid == 0x2016 && bcd == 2) |
| 747 | 2 | return 100; | |
| 748 | |||
| 749 | return 0; | ||
| 750 | } | ||
| 751 | |||
| 752 | static const FpIdEntry id_table[] = { | ||
| 753 | { .vid = 0x147e, .pid = 0x2016, }, | ||
| 754 | { .vid = 0x147e, .pid = 0x2020, }, | ||
| 755 | { .vid = 0, .pid = 0, .driver_data = 0 }, | ||
| 756 | }; | ||
| 757 | |||
| 758 | static void | ||
| 759 | 2 | fpi_device_upektc_img_init (FpiDeviceUpektcImg *self) | |
| 760 | { | ||
| 761 | 2 | } | |
| 762 | static void | ||
| 763 | 121 | fpi_device_upektc_img_class_init (FpiDeviceUpektcImgClass *klass) | |
| 764 | { | ||
| 765 | 121 | FpDeviceClass *dev_class = FP_DEVICE_CLASS (klass); | |
| 766 | 121 | FpImageDeviceClass *img_class = FP_IMAGE_DEVICE_CLASS (klass); | |
| 767 | |||
| 768 | 121 | dev_class->id = "upektc_img"; | |
| 769 | 121 | dev_class->full_name = "Upek TouchChip Fingerprint Coprocessor"; | |
| 770 | 121 | dev_class->type = FP_DEVICE_TYPE_USB; | |
| 771 | 121 | dev_class->id_table = id_table; | |
| 772 | 121 | dev_class->scan_type = FP_SCAN_TYPE_SWIPE; | |
| 773 | 121 | dev_class->usb_discover = discover; | |
| 774 | |||
| 775 | 121 | img_class->img_open = dev_init; | |
| 776 | 121 | img_class->img_close = dev_deinit; | |
| 777 | 121 | img_class->activate = dev_activate; | |
| 778 | 121 | img_class->deactivate = dev_deactivate; | |
| 779 | |||
| 780 | 121 | img_class->bz3_threshold = 20; | |
| 781 | |||
| 782 | 121 | img_class->img_width = -1; | |
| 783 | 121 | img_class->img_height = -1; | |
| 784 | } | ||
| 785 |