Lines Matching refs:dev
3 Copyright (C) 2007-2013 stef.dev@free.fr
221 static SANE_Status set_lamp_brightness (struct Rts8891_Device *dev,
225 static SANE_Status init_device (struct Rts8891_Device *dev);
227 static SANE_Status detect_device (struct Rts8891_Device *dev);
228 static SANE_Status initialize_device (struct Rts8891_Device *dev);
230 static SANE_Status init_lamp (struct Rts8891_Device *dev);
231 static SANE_Status find_origin (struct Rts8891_Device *dev,
233 static SANE_Status find_margin (struct Rts8891_Device *dev);
234 static SANE_Status dark_calibration (struct Rts8891_Device *dev, int mode,
236 static SANE_Status gain_calibration (struct Rts8891_Device *dev, int mode,
238 static SANE_Status offset_calibration (struct Rts8891_Device *dev, int mode,
240 static SANE_Status shading_calibration (struct Rts8891_Device *dev,
248 static SANE_Status park_head (struct Rts8891_Device *dev, SANE_Bool wait);
518 session->dev = device;
530 if (session->dev->conf.allowsharing == SANE_TRUE)
676 if (s->dev->model->gamma != s->val[option].wa)
678 s->val[option].wa = s->dev->model->gamma;
808 if (s->dev->model->gamma != s->val[option].wa)
815 s->val[option].wa = s->dev->model->gamma;
874 if (option - OPT_BUTTON_1 > s->dev->model->buttons)
1072 struct Rts8891_Device *dev = session->dev;
1089 if (dev->conf.allowsharing == SANE_TRUE)
1091 status = sanei_usb_claim_interface (dev->devnum, 0);
1100 sanei_rts88xx_get_lamp_status (dev->devnum, dev->regs);
1101 if ((dev->regs[0x8e] & 0x60) != 0x60)
1104 dev->regs[0x8e]);
1105 dev->needs_warming = SANE_TRUE;
1107 dev->start_time.tv_sec = current.tv_sec;
1108 dev->last_scan.tv_sec = current.tv_sec;
1116 if ((current.tv_sec - dev->last_scan.tv_sec) / 60 > 10)
1120 dev->needs_warming = SANE_TRUE;
1121 dev->start_time.tv_sec = current.tv_sec;
1122 dev->last_scan.tv_sec = current.tv_sec;
1127 if(dev->parking==SANE_TRUE)
1129 rts8891_wait_for_home (dev, dev->regs);
1133 rts8891_set_default_regs (dev->regs);
1136 init_lamp (dev);
1139 if (dev->needs_warming == SANE_TRUE)
1145 if ((current.tv_sec - dev->start_time.tv_sec) < 15)
1148 if (dev->conf.allowsharing == SANE_TRUE)
1150 sanei_usb_release_interface (dev->devnum, 0);
1156 sleep (15 - (current.tv_sec - dev->start_time.tv_sec));
1165 dev->needs_warming = SANE_FALSE;
1168 dev->regs[LAMP_BRIGHT_REG] = 0xA7;
1169 sanei_rts88xx_write_reg (dev->devnum, LAMP_BRIGHT_REG,
1170 dev->regs + LAMP_BRIGHT_REG);
1172 sensor_name (dev->sensor), dev->sensor);
1179 status = find_origin (dev, &changed);
1182 if (dev->conf.allowsharing == SANE_TRUE)
1184 sanei_usb_release_interface (dev->devnum, 0);
1194 switch (dev->sensor)
1199 dev->sensor = SENSOR_TYPE_XPA;
1204 dev->sensor = SENSOR_TYPE_BARE;
1209 dev->sensor = SENSOR_TYPE_4400_BARE;
1214 dev->sensor = SENSOR_TYPE_4400;
1222 switch (dev->sensor)
1243 sensor_name (dev->sensor), dev->sensor);
1247 status = dark_calibration (dev, mode, light);
1250 if (dev->conf.allowsharing == SANE_TRUE)
1252 sanei_usb_release_interface (dev->devnum, 0);
1259 status = find_margin (dev);
1262 if (dev->conf.allowsharing == SANE_TRUE)
1264 sanei_usb_release_interface (dev->devnum, 0);
1271 dev->regs[LAMP_BRIGHT_REG] = 0xA7;
1272 sanei_rts88xx_write_reg (dev->devnum, LAMP_BRIGHT_REG,
1273 dev->regs + LAMP_BRIGHT_REG);
1276 status = gain_calibration (dev, mode, light);
1279 if (dev->conf.allowsharing == SANE_TRUE)
1281 sanei_usb_release_interface (dev->devnum, 0);
1288 status = offset_calibration (dev, mode, light);
1291 if (dev->conf.allowsharing == SANE_TRUE)
1293 sanei_usb_release_interface (dev->devnum, 0);
1304 if (dev->scanned_data != NULL)
1305 free (dev->scanned_data);
1306 dev->scanned_data =
1307 (SANE_Byte *) malloc (dev->data_size + dev->lds_max + dev->ripple);
1308 dev->start = dev->scanned_data + dev->lds_max + dev->ripple;
1311 dev->end = dev->start + dev->data_size;
1316 sanei_rts88xx_set_offset (dev->regs, dev->red_offset, dev->green_offset,
1317 dev->blue_offset);
1318 sanei_rts88xx_set_gain (dev->regs, dev->red_gain, dev->green_gain,
1319 dev->blue_gain);
1323 shading_calibration (dev, session->params.format == SANE_FRAME_RGB
1327 if (dev->conf.allowsharing == SANE_TRUE)
1329 sanei_usb_release_interface (dev->devnum, 0);
1335 /* step 6b: move at dev->model->min_ydpi to target area */
1336 if (dev->ydpi > dev->model->min_ydpi
1337 && (dev->ystart * MOVE_DPI) / dev->ydpi > 150)
1342 if (dev->conf.allowsharing == SANE_TRUE)
1344 sanei_usb_release_interface (dev->devnum, 0);
1356 if (dev->conf.allowsharing == SANE_TRUE)
1358 sanei_usb_release_interface (dev->devnum, 0);
1368 if (dev->conf.allowsharing == SANE_TRUE)
1370 sanei_usb_release_interface (dev->devnum, 0);
1378 sanei_rts88xx_cancel (dev->devnum);
1379 sanei_rts88xx_write_control (dev->devnum, 0x08);
1380 status = sanei_rts88xx_write_control (dev->devnum, 0x08);
1396 Rts8891_Device *dev = session->dev;
1419 dev->threshold = (255 * SANE_UNFIX (session->val[OPT_THRESHOLD].w)) / 100;
1423 if (dev->model->flags & RTS8891_FLAG_EMULATED_GRAY_MODE)
1462 dev->lines = session->params.lines;
1463 dev->pixels = session->params.pixels_per_line;
1466 dev->xdpi = dpi;
1467 dev->ydpi = dpi;
1470 if (dev->ydpi > dev->model->max_ydpi)
1472 dev->ydpi = dev->model->max_ydpi;
1473 dev->lines = (dev->lines * dev->model->max_ydpi) / dpi;
1474 if (dev->lines == 0)
1475 dev->lines = 1;
1479 (session->params.lines / dev->lines) * dev->lines;
1483 if (dev->ydpi < dev->model->min_ydpi)
1485 dev->ydpi = dev->model->min_ydpi;
1486 dev->lines = (dev->lines * dev->model->min_ydpi) / dpi;
1490 dev->xstart =
1491 ((SANE_UNFIX (dev->model->x_offset) + tl_x) * dev->xdpi) / MM_PER_INCH;
1492 dev->ystart =
1493 ((SANE_UNFIX (dev->model->y_offset) + tl_y) * dev->ydpi) / MM_PER_INCH;
1496 if (dev->xstart & 1)
1497 dev->xstart++;
1501 dev->bytes_per_line = dev->pixels;
1509 dev->bytes_per_line *= 3;
1523 dev->ripple = 0;
1527 dev->lds_r
1528 = ((dev->model->ld_shift_r * dev->ydpi) / dev->model->max_ydpi)
1529 * dev->bytes_per_line;
1530 dev->lds_g
1531 = ((dev->model->ld_shift_g * dev->ydpi) / dev->model->max_ydpi)
1532 * dev->bytes_per_line;
1533 dev->lds_b
1534 = ((dev->model->ld_shift_b * dev->ydpi) / dev->model->max_ydpi)
1535 * dev->bytes_per_line;
1536 if (dev->xdpi == dev->model->max_xdpi)
1538 dev->ripple = 2 * dev->bytes_per_line;
1543 dev->lds_r = 0;
1544 dev->lds_g = 0;
1545 dev->lds_b = 0;
1549 dev->lds_max = dev->lds_r;
1550 if (dev->lds_g > dev->lds_max)
1551 dev->lds_max = dev->lds_g;
1552 if (dev->lds_b > dev->lds_max)
1553 dev->lds_max = dev->lds_b;
1557 dev->lds_r -= dev->lds_max;
1558 dev->lds_g -= dev->lds_max;
1559 dev->lds_b -= dev->lds_max;
1564 dev->lines += (dev->lds_max + dev->ripple) / dev->bytes_per_line;
1568 if (dev->ydpi > dev->model->min_ydpi)
1571 switch (dev->ydpi)
1582 dev->ystart += yshift;
1584 dev->ystart -= (dev->lds_max + dev->ripple) / dev->bytes_per_line;
1589 switch (dev->xdpi)
1600 dev->xstart += xshift;
1602 dev->read = 0;
1603 dev->to_read = dev->lines * dev->bytes_per_line;
1608 if (dev->xdpi < dev->model->max_ydpi)
1610 dev->data_size =
1611 (PREFERED_BUFFER_SIZE / dev->bytes_per_line) * (dev->bytes_per_line);
1615 dev->data_size =
1616 (((PREFERED_BUFFER_SIZE / 2) - dev->lds_max -
1617 dev->ripple) / dev->bytes_per_line) * dev->bytes_per_line;
1621 if (dev->data_size < 32 * dev->bytes_per_line)
1622 dev->data_size = 32 * dev->bytes_per_line;
1625 if (dev->data_size > dev->to_read)
1626 dev->data_size = dev->to_read;
1639 DBG (DBG_data, "compute_parameters: xstart =%d\n", dev->xstart);
1640 DBG (DBG_data, "compute_parameters: ystart =%d\n", dev->ystart);
1641 DBG (DBG_data, "compute_parameters: dev lines =%d\n", dev->lines);
1642 DBG (DBG_data, "compute_parameters: dev extra lines =%d\n",
1643 (dev->lds_max + dev->ripple) / dev->bytes_per_line);
1644 DBG (DBG_data, "compute_parameters: dev bytes per line=%d\n",
1645 dev->bytes_per_line);
1646 DBG (DBG_data, "compute_parameters: dev pixels =%d\n", dev->pixels);
1648 dev->data_size);
1649 DBG (DBG_data, "compute_parameters: to read =%d\n", dev->to_read);
1651 dev->threshold);
1712 struct Rts8891_Device *dev;
1735 dev = session->dev;
1770 park_head (session->dev, SANE_FALSE);
1774 dev->regs[LAMP_REG] = 0xad;
1775 sanei_rts88xx_write_reg (dev->devnum, LAMP_REG, &(dev->regs[LAMP_REG]));
1782 if (dev->read == 0
1788 data_size = dev->data_size + dev->lds_max + dev->ripple;
1789 if (dev->to_read - dev->read < data_size)
1790 data_size = dev->to_read - dev->read;
1792 status = read_data (session, dev->scanned_data, data_size);
1805 dev->current = dev->start;
1809 if (dev->read == 0 || dev->current >= dev->end)
1813 data_size = dev->data_size;
1814 if (dev->to_read - dev->read < data_size)
1815 data_size = dev->to_read - dev->read;
1817 status = read_data (session, dev->start, data_size);
1830 dev->current = dev->start;
1833 dev->regs[LAMP_REG] = 0x8d;
1834 sanei_rts88xx_write_reg (dev->devnum, LAMP_REG, &(dev->regs[LAMP_REG]));
1856 while (dev->current < dev->end && *len < max_len
1862 if (dev->xdpi == dev->model->max_xdpi)
1868 switch (((session->sent * 3) % dev->bytes_per_line) % 6)
1873 val = dev->current[dev->lds_g];
1878 val = dev->current[dev->lds_g - dev->ripple];
1885 if (val <= dev->threshold)
1901 dev->current += 3;
1905 switch ((session->sent % dev->bytes_per_line) % 6)
1908 buf[*len] = dev->current[dev->lds_r];
1911 buf[*len] = dev->current[dev->lds_g];
1914 buf[*len] = dev->current[dev->lds_b];
1917 buf[*len] = dev->current[dev->lds_r - dev->ripple];
1920 buf[*len] = dev->current[dev->lds_g - dev->ripple];
1923 buf[*len] = dev->current[dev->lds_b - dev->ripple];
1928 dev->current++;
1939 dev->bytes_per_line, session->sent);
1940 dev->current -= dev->bytes_per_line;
1943 else if (dev->ydpi == session->val[OPT_RESOLUTION].w)
1949 val = dev->current[dev->lds_g];
1953 if (val <= dev->threshold)
1972 dev->current += 3;
1976 switch ((dev->current - dev->start) % 3)
1979 buf[*len] = dev->current[dev->lds_r];
1982 buf[*len] = dev->current[dev->lds_g];
1985 buf[*len] = dev->current[dev->lds_b];
1990 dev->current++;
2000 val = (dev->current[dev->lds_g]
2001 + dev->current[dev->lds_g +
2002 dev->bytes_per_line]) / 2;
2006 if (val <= dev->threshold)
2024 dev->current += 3;
2028 switch ((dev->current - dev->start) % 3)
2031 buf[*len] = (dev->current[dev->lds_r]
2032 + dev->current[dev->lds_r +
2033 dev->bytes_per_line]) / 2;
2036 buf[*len] = (dev->current[dev->lds_g]
2037 + dev->current[dev->lds_g +
2038 dev->bytes_per_line]) / 2;
2041 buf[*len] = (dev->current[dev->lds_b]
2042 + dev->current[dev->lds_b +
2043 dev->bytes_per_line]) / 2;
2047 dev->current++;
2053 if ((dev->current - dev->start) % dev->bytes_per_line == 0)
2054 dev->current += dev->bytes_per_line;
2063 if (dev->current >= dev->end
2067 memcpy (dev->scanned_data, dev->end - (dev->lds_max + dev->ripple),
2068 dev->lds_max + dev->ripple);
2101 struct Rts8891_Device *dev = session->dev;
2111 dev->last_scan.tv_sec = current.tv_sec;
2118 if (dev->read < dev->to_read)
2120 sanei_rts88xx_cancel (dev->devnum);
2122 sanei_rts88xx_cancel (dev->devnum);
2127 if (park_head (dev, SANE_FALSE) != SANE_STATUS_GOOD)
2134 if (dev->scanned_data != NULL)
2136 free (dev->scanned_data);
2137 dev->scanned_data = NULL;
2139 if (dev->shading_data != NULL)
2141 free (dev->shading_data);
2142 dev->shading_data = NULL;
2146 if (dev->conf.allowsharing == SANE_TRUE)
2148 sanei_usb_release_interface (dev->devnum, 0);
2172 Rts8891_Device *dev;
2191 dev=session->dev;
2199 if(dev->parking==SANE_TRUE)
2201 rts8891_wait_for_home (dev, dev->regs);
2203 set_lamp_brightness (dev, 0);
2212 if (dev->conf.allowsharing == SANE_TRUE)
2214 SANE_Status status = sanei_usb_claim_interface (dev->devnum, 0);
2223 sanei_usb_close (dev->devnum);
2226 if (session->dev->model->gamma != session->val[OPT_GAMMA_VECTOR].wa)
2228 if (session->dev->model->gamma != session->val[OPT_GAMMA_VECTOR_R].wa)
2230 if (session->dev->model->gamma != session->val[OPT_GAMMA_VECTOR_G].wa)
2232 if (session->dev->model->gamma != session->val[OPT_GAMMA_VECTOR_B].wa)
2266 struct Rts8891_Device *dev, *nextdev;
2281 for (dev = first_device; dev; dev = nextdev)
2283 nextdev = dev->next;
2284 free (dev->file_name);
2285 free (dev);
2563 Rts8891_Model *model = session->dev->model;
2920 set_lamp_brightness (struct Rts8891_Device *dev, int level)
2926 sanei_rts88xx_write_reg (dev->devnum, LAMP_BRIGHT_REG, ®);
2939 sanei_rts88xx_write_reg (dev->devnum, LAMP_REG, ®);
2941 dev->regs[LAMP_REG] = reg;
2942 sanei_rts88xx_write_reg (dev->devnum, LAMP_REG, ®);
2943 sanei_rts88xx_write_control (dev->devnum, 0x00);
2944 sanei_rts88xx_write_control (dev->devnum, 0x00);
2945 sanei_rts88xx_get_status (dev->devnum, dev->regs);
2946 DBG (DBG_io, "set_lamp_brightness: status=0x%02x 0x%02x\n", dev->regs[0x10],
2947 dev->regs[0x11]);
2948 if (dev->sensor != SENSOR_TYPE_4400)
2950 dev->regs[0x10] = 0x28;
2951 dev->regs[0x11] = 0x3f;
2955 dev->regs[0x10] = 0x10;
2956 dev->regs[0x11] = 0x2f;
2958 reg = dev->regs[LAMP_REG];
2959 sanei_rts88xx_write_reg (dev->devnum, LAMP_REG, ®);
2960 status = sanei_rts88xx_read_reg (dev->devnum, CONTROL_REG, ®);
2975 init_lamp (struct Rts8891_Device *dev)
2979 sanei_rts88xx_write_control (dev->devnum, 0x01);
2980 sanei_rts88xx_write_control (dev->devnum, 0x01);
2981 sanei_rts88xx_write_control (dev->devnum, 0x00);
2982 sanei_rts88xx_write_control (dev->devnum, 0x00);
2983 sanei_rts88xx_cancel (dev->devnum);
2984 dev->regs[0x12] = 0xff;
2985 dev->regs[0x13] = 0x20;
2986 sanei_rts88xx_write_regs (dev->devnum, 0x12, dev->regs + 0x12, 2);
2988 sanei_rts88xx_write_regs (dev->devnum, 0x14, dev->regs + 0x14, 2);
2989 sanei_rts88xx_write_control (dev->devnum, 0x00);
2990 sanei_rts88xx_write_control (dev->devnum, 0x00);
2991 if (dev->sensor != SENSOR_TYPE_4400 && dev->sensor != SENSOR_TYPE_4400_BARE)
2993 sanei_rts88xx_set_status (dev->devnum, dev->regs, 0x28, 0x3f);
2994 dev->regs[0x11] = 0x3f;
2998 sanei_rts88xx_set_status (dev->devnum, dev->regs, 0x10, 0x22);
2999 dev->regs[0x11] = 0x22;
3002 sanei_rts88xx_write_reg (dev->devnum, LAMP_REG, ®);
3003 dev->regs[LAMP_REG] = 0xa2;
3004 dev->regs[LAMP_BRIGHT_REG] = 0xa0;
3005 rts8891_write_all (dev->devnum, dev->regs, dev->reg_count);
3006 return set_lamp_brightness (dev, 7);
3014 find_origin (struct Rts8891_Device *dev, SANE_Bool * changed)
3034 sanei_rts88xx_read_reg (dev->devnum, CONTROLER_REG, ®);
3037 if (park_head (dev, SANE_TRUE) != SANE_STATUS_GOOD)
3045 sanei_rts88xx_read_reg (dev->devnum, CONTROL_REG, &control);
3051 sanei_rts88xx_reset_lamp (dev->devnum, dev->regs);
3052 sanei_rts88xx_read_reg (dev->devnum, CONTROL_REG, &control);
3058 sanei_rts88xx_reset_lamp (dev->devnum, dev->regs);
3061 init_lamp (dev);
3064 dev->regs[0x00] = 0xe5;
3065 dev->regs[0x32] = 0x80;
3066 dev->regs[0x33] = 0x81;
3067 dev->regs[0x39] = 0x02;
3068 dev->regs[0x64] = 0x01;
3069 dev->regs[0x65] = 0x20;
3070 dev->regs[0x79] = 0x20;
3071 dev->regs[0x7a] = 0x01;
3072 dev->regs[0x90] = 0x1c;
3074 dev->regs[0x35] = 0x1b;
3075 dev->regs[0x36] = 0x29;
3076 dev->regs[0x3a] = 0x1b;
3078 dev->regs[0x85] = 0x00;
3079 dev->regs[0x86] = 0x06;
3080 dev->regs[0x87] = 0x00;
3081 dev->regs[0x88] = 0x06;
3082 dev->regs[0x8d] = 0x80;
3083 dev->regs[0x8e] = 0x68;
3085 dev->regs[0xb2] = 0x02; /* 0x04 -> no data */
3087 dev->regs[0xc0] = 0xff;
3088 dev->regs[0xc1] = 0x0f;
3089 dev->regs[0xc3] = 0xff;
3090 dev->regs[0xc4] = 0xff;
3091 dev->regs[0xc5] = 0xff;
3092 dev->regs[0xc6] = 0xff;
3093 dev->regs[0xc7] = 0xff;
3094 dev->regs[0xc8] = 0xff;
3095 dev->regs[0xc9] = 0x00;
3096 dev->regs[0xca] = 0x0e;
3097 dev->regs[0xcb] = 0x00;
3098 dev->regs[0xcd] = 0xf0;
3099 dev->regs[0xce] = 0xff;
3100 dev->regs[0xcf] = 0xf5;
3101 dev->regs[0xd0] = 0xf7;
3102 dev->regs[0xd1] = 0xea;
3103 dev->regs[0xd2] = 0x0b;
3104 dev->regs[0xd3] = 0x03;
3105 dev->regs[0xd4] = 0x05;
3106 dev->regs[0xd6] = 0xab;
3107 dev->regs[0xd7] = 0x30;
3108 dev->regs[0xd8] = 0xf6;
3109 dev->regs[0xe2] = 0x01;
3110 dev->regs[0xe3] = 0x00;
3111 dev->regs[0xe4] = 0x00;
3112 SET_DOUBLE (dev->regs, EXPOSURE_REG, 4124);
3113 /* dev->regs[0xe5] = 0x1c;
3114 dev->regs[0xe6] = 0x10; 101c=4124 */
3115 dev->regs[0xe7] = 0x00;
3116 dev->regs[0xe8] = 0x00;
3117 dev->regs[0xe9] = 0x00;
3119 if (dev->sensor == SENSOR_TYPE_XPA || dev->sensor == SENSOR_TYPE_4400)
3121 dev->regs[0xc3] = 0x00;
3122 dev->regs[0xc4] = 0xf0;
3123 dev->regs[0xc7] = 0x0f;
3124 dev->regs[0xc8] = 0x00;
3125 dev->regs[0xc9] = 0xff;
3126 dev->regs[0xca] = 0xf1;
3127 dev->regs[0xcb] = 0xff;
3128 dev->regs[0xd7] = 0x10;
3130 if (dev->sensor == SENSOR_TYPE_4400 || dev->sensor == SENSOR_TYPE_4400_BARE)
3133 dev->regs[0x13] = 0x39; /* 0x20 */
3134 dev->regs[0x14] = 0xf0; /* 0xf8 */
3135 dev->regs[0x15] = 0x29; /* 0x28 */
3136 dev->regs[0x16] = 0x0f; /* 0x07 */
3137 dev->regs[0x17] = 0x10; /* 0x00 */
3139 dev->regs[0x23] = 0x00; /* 0xff */
3141 dev->regs[0x39] = 0x00; /* 0x02 */
3143 if (dev->sensor == SENSOR_TYPE_4400_BARE)
3145 dev->regs[0xc3] = 0xff; /* 0x00 */
3146 dev->regs[0xc4] = 0xff; /* 0xf0 */
3147 dev->regs[0xc7] = 0xff; /* 0x0f */
3148 dev->regs[0xc8] = 0xff; /* 0x00 */
3149 dev->regs[0xc9] = 0x00; /* 0xff */
3150 dev->regs[0xca] = 0x0e; /* 0xf1 */
3151 dev->regs[0xcb] = 0x00; /* 0xff */
3152 dev->regs[0xd7] = 0x30; /* 0x10 */
3153 dev->regs[0xda] = 0xa7; /* 0xa0 */
3155 SET_DOUBLE (dev->regs, TIMING_REG, timing);
3156 SET_DOUBLE (dev->regs, TIMING1_REG, timing+1);
3157 SET_DOUBLE (dev->regs, TIMING2_REG, timing+2);
3177 sanei_rts88xx_set_scan_area (dev->regs, starty, starty + height, startx,
3179 sanei_rts88xx_set_offset (dev->regs, 0x7f, 0x7f, 0x7f);
3180 sanei_rts88xx_set_gain (dev->regs, 0x10, 0x10, 0x10);
3183 dev->regs[LAMP_REG] = 0xad;
3184 sanei_rts88xx_write_reg (dev->devnum, LAMP_REG, dev->regs + LAMP_REG);
3185 if (dev->sensor != SENSOR_TYPE_4400
3186 && (dev->sensor != SENSOR_TYPE_4400_BARE))
3188 sanei_rts88xx_set_status (dev->devnum, dev->regs, 0x20, 0x3b);
3192 sanei_rts88xx_set_status (dev->devnum, dev->regs, 0x10, 0x22);
3196 rts8891_simple_scan (dev->devnum, dev->regs, dev->reg_count, 0x03,
3269 dev->top_offset = (48 * dev->model->max_ydpi) / 300;
3279 dev->regs[0x35] = 0x0e;
3280 dev->regs[0x3a] = 0x0e;
3282 dev->regs[0xb2] = 0x06; /* no data (0x04) */
3284 if (dev->sensor == SENSOR_TYPE_4400)
3286 dev->regs[0x36] = 0x21; /* direction reverse (& ~0x08) */
3288 dev->regs[0xe2] = 0x03; /* 0x01 */
3290 /* dev->regs[0xe5] = 0x0d; 0x1c
3291 dev->regs[0xe6] = 0x08; 0x10 080d=2061=1030*2+1 */
3292 SET_DOUBLE (dev->regs, EXPOSURE_REG, 2061);
3296 dev->regs[0x11] = 0x3f; /* 0x3b */
3298 dev->regs[0x36] = 0x24; /* direction reverse (& ~0x08) */
3300 dev->regs[0xe2] = 0x07;
3303 dev->regs[0xe5] = 0x06;
3304 dev->regs[0xe6] = 0x04; 406=1030 */
3305 SET_DOUBLE (dev->regs, EXPOSURE_REG, 1030);
3309 sanei_rts88xx_set_scan_area (dev->regs, height - sum + 10,
3311 rts8891_write_all (dev->devnum, dev->regs, dev->reg_count);
3312 rts8891_commit (dev->devnum, 0x03);
3317 status = sanei_rts88xx_read_reg (dev->devnum, CONTROL_REG, ®);
3332 find_margin (struct Rts8891_Device *dev)
3348 sanei_rts88xx_write_reg (dev->devnum, LAMP_BRIGHT_REG, ®);
3351 if (dev->sensor == SENSOR_TYPE_4400 || dev->sensor == SENSOR_TYPE_4400_BARE)
3353 sanei_rts88xx_set_status (dev->devnum, dev->regs, 0x10, 0x23);
3357 sanei_rts88xx_set_status (dev->devnum, dev->regs, 0x28, 0x3b);
3360 sanei_rts88xx_set_gain (dev->regs, 0x3f, 0x3f, 0x3f);
3363 dev->regs[0x33] = 0x01;
3364 dev->regs[0x34] = 0x10;
3365 dev->regs[0x35] = 0x1b;
3366 dev->regs[0x3a] = 0x1b;
3368 dev->regs[0x72] = 0x3a;
3369 dev->regs[0x73] = 0x15;
3370 dev->regs[0x74] = 0x62;
3374 dev->regs[0xc0] = 0xff;
3375 dev->regs[0xc1] = 0xff;
3376 dev->regs[0xc2] = 0xff;
3377 dev->regs[0xc3] = 0x00;
3378 dev->regs[0xc4] = 0xf0;
3379 dev->regs[0xc7] = 0x0f;
3380 dev->regs[0xc8] = 0x00;
3381 dev->regs[0xcb] = 0xe0;
3382 dev->regs[0xcc] = 0xff;
3383 dev->regs[0xcd] = 0xff;
3384 dev->regs[0xce] = 0xff;
3385 dev->regs[0xcf] = 0xe9;
3386 dev->regs[0xd0] = 0xeb;
3387 dev->regs[0xd3] = 0x0c;
3388 dev->regs[0xd4] = 0x0e;
3389 dev->regs[0xd6] = 0xab;
3390 dev->regs[0xd7] = 0x14;
3391 dev->regs[0xd8] = 0xf6;
3393 dev->regs[0xda] = 0xa7; /* XXX STEF XXX Ã l'origine, pas 'bare' */
3395 dev->regs[0xe2] = 0x01;
3397 /* dev->regs[0xe5] = 0x7b;
3398 dev->regs[0xe6] = 0x15; 157b=5499 */
3399 SET_DOUBLE (dev->regs, EXPOSURE_REG, 5499);
3401 dev->regs[0xe7] = 0x00;
3402 dev->regs[0xe8] = 0x00;
3403 dev->regs[0xe9] = 0x00;
3404 dev->regs[0xea] = 0x00;
3405 dev->regs[0xeb] = 0x00;
3406 dev->regs[0xec] = 0x00;
3407 dev->regs[0xed] = 0x00;
3408 dev->regs[0xef] = 0x00;
3409 dev->regs[0xf0] = 0x00;
3410 dev->regs[0xf2] = 0x00;
3411 if (dev->sensor == SENSOR_TYPE_XPA || dev->sensor == SENSOR_TYPE_4400)
3413 dev->regs[0xc0] = 0x00;
3414 dev->regs[0xc1] = 0xf8;
3415 dev->regs[0xc2] = 0x7f;
3416 dev->regs[0xc4] = 0xf8;
3417 dev->regs[0xc5] = 0x7f;
3418 dev->regs[0xc6] = 0x00;
3419 dev->regs[0xc7] = 0xf8;
3420 dev->regs[0xc8] = 0x7f;
3421 dev->regs[0xc9] = 0xff;
3422 dev->regs[0xca] = 0xff;
3423 dev->regs[0xcb] = 0x8f;
3424 dev->regs[0xcd] = 0x07;
3425 dev->regs[0xce] = 0x80;
3426 dev->regs[0xcf] = 0xea;
3427 dev->regs[0xd0] = 0xec;
3428 dev->regs[0xd1] = 0xf7;
3429 dev->regs[0xd2] = 0x00;
3430 dev->regs[0xd3] = 0x10;
3431 dev->regs[0xd4] = 0x12;
3432 dev->regs[0xd7] = 0x31;
3434 if (dev->sensor == SENSOR_TYPE_4400_BARE)
3436 dev->regs[0x13] = 0x39; /* 0x20 */
3437 dev->regs[0x14] = 0xf0; /* 0xf8 */
3438 dev->regs[0x15] = 0x29; /* 0x28 */
3439 dev->regs[0x16] = 0x0f; /* 0x07 */
3440 dev->regs[0x17] = 0x10; /* 0x00 */
3441 dev->regs[0x23] = 0x00; /* 0xff */
3442 dev->regs[0x39] = 0x00; /* 0x02 */
3443 dev->regs[0x85] = 0x46; /* 0x00 */
3444 dev->regs[0x86] = 0x0b; /* 0x06 */
3445 dev->regs[0x87] = 0x8c; /* 0x00 */
3446 dev->regs[0x88] = 0x10; /* 0x06 */
3447 dev->regs[0x8d] = 0x3b; /* 0x00 */
3450 SET_DOUBLE (dev->regs, TIMING_REG, timing);
3451 SET_DOUBLE (dev->regs, TIMING1_REG, timing+1);
3452 SET_DOUBLE (dev->regs, TIMING2_REG, timing+2);
3455 sanei_rts88xx_set_scan_area (dev->regs, starty, starty + height, startx,
3469 rts8891_simple_scan (dev->devnum, dev->regs, dev->reg_count, 0x0c,
3496 dev->left_offset = ((x - 40) * dev->model->max_xdpi) / 150;
3514 initialize_device (struct Rts8891_Device *dev)
3520 if (dev->initialized == SANE_TRUE)
3523 sanei_rts88xx_set_status (dev->devnum, dev->regs, 0x20, 0x28);
3524 sanei_rts88xx_write_control (dev->devnum, 0x01);
3525 sanei_rts88xx_write_control (dev->devnum, 0x01);
3526 sanei_rts88xx_write_control (dev->devnum, 0x00);
3527 sanei_rts88xx_write_control (dev->devnum, 0x00);
3529 sanei_rts88xx_read_reg (dev->devnum, 0xb0, &control);
3542 status = sanei_rts88xx_get_lamp_status (dev->devnum, dev->regs);
3548 DBG (DBG_io, "initialize_device: lamp status=0x%02x\n", dev->regs[0x8e]);
3554 if (dev->sensor == -1)
3556 dev->sensor = device->model->sensor;
3558 DBG (DBG_info, "initialize_device: initial sensor type is %d\n", dev->sensor);
3559 DBG (DBG_info, "initialize_device: reg[8e]=0x%02x\n", dev->regs[0x8e]);
3562 if ((dev->regs[0x8e] & 0x60) != 0x60)
3565 dev->needs_warming = SANE_TRUE;
3569 dev->needs_warming = SANE_FALSE;
3572 sanei_rts88xx_read_reg (dev->devnum, LAMP_REG, ®);
3574 sanei_rts88xx_write_control (dev->devnum, 0x00);
3575 sanei_rts88xx_write_control (dev->devnum, 0x00);
3578 sanei_rts88xx_read_reg (dev->devnum, LINK_REG, &control);
3586 sanei_rts88xx_read_reg (dev->devnum, CONTROLER_REG, &control);
3589 if (park_head (dev, SANE_TRUE) != SANE_STATUS_GOOD)
3597 dev->regs[0x00] = 0xe5; /* 0xf5 */
3598 dev->regs[0x02] = 0x1f; /* 0x00 */
3599 dev->regs[0x03] = 0x1f; /* 0x00 */
3600 dev->regs[0x04] = 0x1f; /* 0x00 */
3601 dev->regs[0x05] = 0x1f; /* 0x00 */
3602 dev->regs[0x06] = 0x1f; /* 0x00 */
3603 dev->regs[0x07] = 0x1f; /* 0x00 */
3604 dev->regs[0x08] = 0x0a; /* 0x00 */
3605 dev->regs[0x09] = 0x0a; /* 0x00 */
3606 dev->regs[0x0a] = 0x0a; /* 0x00 */
3607 dev->regs[0x10] = 0x28; /* 0x60 */
3608 dev->regs[0x11] = 0x28; /* 0x1b */
3609 dev->regs[0x13] = 0x20; /* 0x3e */
3610 dev->regs[0x14] = 0xf8; /* 0x00 */
3611 dev->regs[0x15] = 0x28; /* 0x00 */
3612 dev->regs[0x16] = 0x07; /* 0xff */
3613 dev->regs[0x17] = 0x00; /* 0x3e */
3614 dev->regs[0x18] = 0xff; /* 0x00 */
3615 dev->regs[0x1d] = 0x20; /* 0x22 */
3618 dev->regs[0x20] = 0x3a; /* 0x00 */
3619 dev->regs[0x21] = 0xf2; /* 0x00 */
3620 dev->regs[0x24] = 0xff; /* 0x00 */
3621 dev->regs[0x25] = 0x00; /* 0xff */
3623 dev->regs[0x30] = 0x00; /* 0x01 */
3624 dev->regs[0x31] = 0x00; /* 0x42 */
3625 dev->regs[0x36] = 0x07; /* 0x00 */
3626 dev->regs[0x39] = 0x00; /* 0x02 */
3627 dev->regs[0x40] = 0x20; /* 0x80 */
3628 dev->regs[0x44] = 0x8c; /* 0x18 */
3629 dev->regs[0x45] = 0x76; /* 0x00 */
3630 dev->regs[0x50] = 0x00; /* 0x20 */
3631 dev->regs[0x51] = 0x00; /* 0x24 */
3632 dev->regs[0x52] = 0x00; /* 0x04 */
3633 dev->regs[0x64] = 0x00; /* 0x10 */
3634 dev->regs[0x68] = 0x00; /* 0x10 */
3635 dev->regs[0x6a] = 0x00; /* 0x01 */
3636 dev->regs[0x70] = 0x00; /* 0x20 */
3637 dev->regs[0x71] = 0x00; /* 0x20 */
3638 dev->regs[0x72] = 0xe1; /* 0x00 */
3639 dev->regs[0x73] = 0x14; /* 0x00 */
3640 dev->regs[0x74] = 0x18; /* 0x00 */
3641 dev->regs[0x75] = 0x15; /* 0x00 */
3642 dev->regs[0x76] = 0x00; /* 0x20 */
3643 dev->regs[0x77] = 0x00; /* 0x01 */
3644 dev->regs[0x79] = 0x00; /* 0x02 */
3645 dev->regs[0x81] = 0x00; /* 0x41 */
3646 dev->regs[0x83] = 0x00; /* 0x10 */
3647 dev->regs[0x84] = 0x00; /* 0x21 */
3648 dev->regs[0x85] = 0x00; /* 0x20 */
3649 dev->regs[0x87] = 0x00; /* 0x20 */
3650 dev->regs[0x88] = 0x00; /* 0x81 */
3651 dev->regs[0x89] = 0x00; /* 0x20 */
3652 dev->regs[0x8a] = 0x00; /* 0x01 */
3653 dev->regs[0x8b] = 0x00; /* 0x01 */
3654 dev->regs[0x8d] = 0x80; /* 0x22 */
3655 dev->regs[0x8e] = 0x68; /* 0x00 */
3656 dev->regs[0x8f] = 0x00; /* 0x40 */
3657 dev->regs[0x90] = 0x00; /* 0x05 */
3658 dev->regs[0x93] = 0x02; /* 0x01 */
3659 dev->regs[0x94] = 0x0e; /* 0x1e */
3660 dev->regs[0xb0] = 0x00; /* 0x80 */
3661 dev->regs[0xb2] = 0x02; /* 0x06 */
3662 dev->regs[0xc0] = 0xff; /* 0x00 */
3663 dev->regs[0xc1] = 0x0f; /* 0x00 */
3664 dev->regs[0xc3] = 0xff; /* 0x00 */
3665 dev->regs[0xc4] = 0xff; /* 0x00 */
3666 dev->regs[0xc5] = 0xff; /* 0x00 */
3667 dev->regs[0xc6] = 0xff; /* 0x00 */
3668 dev->regs[0xc7] = 0xff; /* 0x00 */
3669 dev->regs[0xc8] = 0xff; /* 0x00 */
3670 dev->regs[0xca] = 0x0e; /* 0x00 */
3671 dev->regs[0xcd] = 0xf0; /* 0x00 */
3672 dev->regs[0xce] = 0xff; /* 0x00 */
3673 dev->regs[0xcf] = 0xf5; /* 0x00 */
3674 dev->regs[0xd0] = 0xf7; /* 0x00 */
3675 dev->regs[0xd1] = 0xea; /* 0x00 */
3676 dev->regs[0xd2] = 0x0b; /* 0x00 */
3677 dev->regs[0xd3] = 0x03; /* 0x00 */
3678 dev->regs[0xd4] = 0x05; /* 0x01 */
3679 dev->regs[0xd5] = 0x86; /* 0x06 */
3680 dev->regs[0xd7] = 0x30; /* 0x10 */
3681 dev->regs[0xd8] = 0xf6; /* 0x7a */
3682 dev->regs[0xd9] = 0x80; /* 0x00 */
3683 dev->regs[0xda] = 0x00; /* 0x15 */
3684 dev->regs[0xe2] = 0x01; /* 0x00 */
3685 /* dev->regs[0xe5] = 0x14; 0x0f */
3686 SET_DOUBLE (dev->regs, EXPOSURE_REG, 20);
3688 status = rts8891_write_all (dev->devnum, dev->regs, dev->reg_count);
3691 dev->initialized = SANE_TRUE;
3698 init_registers (struct Rts8891_Device *dev)
3707 switch (dev->sensor)
3711 dev->regs[0x01] = 0x41;
3712 dev->regs[0x0b] = 0x70;
3713 dev->regs[0x0c] = 0x00;
3714 dev->regs[0x0d] = 0x00;
3715 dev->regs[0x0e] = 0x00;
3716 dev->regs[0x0f] = 0x00;
3718 dev->regs[0x12] = 0x00;
3719 dev->regs[0x13] = 0x20;
3720 dev->regs[0x14] = 0x00;
3721 dev->regs[0x15] = 0x20;
3722 dev->regs[0x16] = 0x00;
3723 dev->regs[0x17] = 0x00;
3724 dev->regs[0x18] = 0x00;
3725 dev->regs[0x19] = 0x00;
3726 dev->regs[0x1a] = 0x00;
3727 dev->regs[0x1b] = 0x00;
3728 dev->regs[0x1c] = 0x00;
3729 dev->regs[0x1d] = 0x20;
3730 dev->regs[0x1e] = 0x00;
3731 dev->regs[0x1f] = 0x00;
3734 dev->regs[0x20] = 0x3a;
3735 dev->regs[0x21] = 0xf2;
3736 dev->regs[0x22] = 0x00;
3738 dev->regs[0x23] = 0x00;
3739 dev->regs[0x24] = 0x00;
3740 dev->regs[0x25] = 0x00;
3741 dev->regs[0x26] = 0x00;
3742 dev->regs[0x27] = 0x00;
3743 dev->regs[0x28] = 0x00;
3744 dev->regs[0x29] = 0x00;
3745 dev->regs[0x2a] = 0x00;
3746 dev->regs[0x2b] = 0x00;
3747 dev->regs[0x2c] = 0x00;
3748 dev->regs[0x2d] = 0x00;
3749 dev->regs[0x2e] = 0x00;
3750 dev->regs[0x2f] = 0x00;
3751 dev->regs[0x30] = 0x00;
3752 dev->regs[0x31] = 0x00;
3753 dev->regs[0x32] = 0x00;
3754 dev->regs[0x33] = 0x00;
3755 dev->regs[0x34] = 0x10;
3756 dev->regs[0x35] = 0x00;
3757 dev->regs[0x36] = 0x07;
3758 dev->regs[0x37] = 0x00;
3759 dev->regs[0x38] = 0x00;
3760 dev->regs[0x39] = 0x00;
3761 dev->regs[0x3a] = 0x00;
3762 dev->regs[0x3b] = 0x00;
3763 dev->regs[0x3c] = 0x00;
3764 dev->regs[0x3d] = 0x00;
3765 dev->regs[0x3e] = 0x00;
3766 dev->regs[0x3f] = 0x00;
3767 dev->regs[0x40] = 0x20;
3768 dev->regs[0x41] = 0x00;
3769 dev->regs[0x42] = 0x00;
3770 dev->regs[0x43] = 0x00;
3771 dev->regs[0x44] = 0x8c;
3772 dev->regs[0x45] = 0x76;
3773 dev->regs[0x46] = 0x00;
3774 dev->regs[0x47] = 0x00;
3775 dev->regs[0x48] = 0x00;
3776 dev->regs[0x49] = 0x00;
3777 dev->regs[0x4a] = 0x00;
3778 dev->regs[0x4b] = 0x00;
3779 dev->regs[0x4c] = 0x00;
3780 dev->regs[0x4d] = 0x00;
3781 dev->regs[0x4e] = 0x00;
3782 dev->regs[0x4f] = 0x00;
3783 dev->regs[0x50] = 0x00;
3784 dev->regs[0x51] = 0x00;
3785 dev->regs[0x52] = 0x00;
3786 dev->regs[0x53] = 0x00;
3787 dev->regs[0x54] = 0x00;
3788 dev->regs[0x55] = 0x00;
3789 dev->regs[0x56] = 0x00;
3790 dev->regs[0x57] = 0x00;
3791 dev->regs[0x58] = 0x00;
3792 dev->regs[0x59] = 0x00;
3793 dev->regs[0x5a] = 0x00;
3794 dev->regs[0x5b] = 0x00;
3795 dev->regs[0x5c] = 0x00;
3796 dev->regs[0x5d] = 0x00;
3797 dev->regs[0x5e] = 0x00;
3798 dev->regs[0x5f] = 0x00;
3799 dev->regs[0x64] = 0x00;
3800 dev->regs[0x65] = 0x00;
3801 dev->regs[0x66] = 0x00;
3802 dev->regs[0x67] = 0x00;
3803 dev->regs[0x68] = 0x00;
3804 dev->regs[0x69] = 0x00;
3805 dev->regs[0x6a] = 0x00;
3806 dev->regs[0x6b] = 0x00;
3807 dev->regs[0x6e] = 0x00;
3808 dev->regs[0x6f] = 0x00;
3809 dev->regs[0x70] = 0x00;
3810 dev->regs[0x71] = 0x00;
3811 dev->regs[0x72] = 0x00;
3812 dev->regs[0x73] = 0x00;
3813 dev->regs[0x74] = 0x00;
3814 dev->regs[0x75] = 0x00;
3815 dev->regs[0x76] = 0x00;
3816 dev->regs[0x77] = 0x00;
3817 dev->regs[0x78] = 0x00;
3818 dev->regs[0x79] = 0x00;
3819 dev->regs[0x7a] = 0x00;
3820 dev->regs[0x7b] = 0x00;
3821 dev->regs[0x7c] = 0x00;
3822 dev->regs[0x7d] = 0x00;
3823 dev->regs[0x7e] = 0x00;
3824 dev->regs[0x7f] = 0x00;
3825 dev->regs[0x80] = 0x00;
3826 dev->regs[0x81] = 0x00;
3827 dev->regs[0x82] = 0x00;
3828 dev->regs[0x83] = 0x00;
3829 dev->regs[0x84] = 0x00;
3830 dev->regs[0x85] = 0x00;
3831 dev->regs[0x86] = 0x00;
3832 dev->regs[0x87] = 0x00;
3833 dev->regs[0x88] = 0x00;
3834 dev->regs[0x89] = 0x00;
3835 dev->regs[0x8a] = 0x00;
3836 dev->regs[0x8b] = 0x00;
3837 dev->regs[0x8c] = 0x00;
3838 dev->regs[0x8d] = 0x80;
3839 dev->regs[0x8e] = 0x68;
3840 dev->regs[0x8f] = 0x00;
3841 dev->regs[0x90] = 0x00;
3842 dev->regs[0x91] = 0x00;
3843 dev->regs[0x92] = 0x00;
3844 dev->regs[0x93] = 0x02;
3845 dev->regs[0x94] = 0x0e;
3846 dev->regs[0x95] = 0x00;
3847 dev->regs[0x96] = 0x00;
3848 dev->regs[0x97] = 0x00;
3849 dev->regs[0x98] = 0x00;
3850 dev->regs[0x99] = 0x00;
3851 dev->regs[0x9a] = 0x00;
3852 dev->regs[0x9b] = 0x00;
3853 dev->regs[0x9c] = 0x00;
3854 dev->regs[0x9d] = 0x00;
3855 dev->regs[0x9e] = 0x00;
3856 dev->regs[0x9f] = 0x00;
3857 dev->regs[0xa0] = 0x00;
3858 dev->regs[0xa1] = 0x00;
3859 dev->regs[0xa2] = 0x00;
3860 dev->regs[0xa3] = 0xcc;
3861 dev->regs[0xa4] = 0x27;
3862 dev->regs[0xa5] = 0x64;
3863 dev->regs[0xa6] = 0x00;
3864 dev->regs[0xa7] = 0x00;
3865 dev->regs[0xa8] = 0x00;
3866 dev->regs[0xa9] = 0x00;
3867 dev->regs[0xaa] = 0x00;
3868 dev->regs[0xab] = 0x00;
3869 dev->regs[0xac] = 0x00;
3870 dev->regs[0xad] = 0x00;
3871 dev->regs[0xae] = 0x00;
3872 dev->regs[0xaf] = 0x00;
3873 dev->regs[0xb0] = 0x00;
3874 dev->regs[0xb1] = 0x00;
3875 dev->regs[0xb2] = 0x02;
3876 dev->regs[0xb4] = 0x00;
3877 dev->regs[0xb5] = 0x00;
3878 dev->regs[0xb6] = 0x00;
3879 dev->regs[0xb7] = 0x00;
3880 dev->regs[0xb8] = 0x00;
3881 dev->regs[0xb9] = 0x00;
3882 dev->regs[0xba] = 0x00;
3883 dev->regs[0xbb] = 0x00;
3884 dev->regs[0xbc] = 0x00;
3885 dev->regs[0xbd] = 0x00;
3886 dev->regs[0xbe] = 0x00;
3887 dev->regs[0xbf] = 0x00;
3888 dev->regs[0xc0] = 0x00;
3889 dev->regs[0xc1] = 0x00;
3890 dev->regs[0xc2] = 0x00;
3891 dev->regs[0xc3] = 0x00;
3892 dev->regs[0xc4] = 0x00;
3893 dev->regs[0xc5] = 0x00;
3894 dev->regs[0xc6] = 0x00;
3895 dev->regs[0xc7] = 0x00;
3896 dev->regs[0xc8] = 0x00;
3897 dev->regs[0xc9] = 0x00;
3898 dev->regs[0xca] = 0x00;
3899 dev->regs[0xcb] = 0x00;
3900 dev->regs[0xcc] = 0x00;
3901 dev->regs[0xcd] = 0x00;
3902 dev->regs[0xce] = 0x00;
3903 dev->regs[0xcf] = 0x00;
3904 dev->regs[0xd0] = 0x00;
3905 dev->regs[0xd1] = 0x00;
3906 dev->regs[0xd2] = 0x00;
3907 dev->regs[0xd3] = 0x00;
3908 dev->regs[0xd4] = 0x00;
3909 dev->regs[0xd5] = 0x86;
3910 dev->regs[0xd6] = 0x1b;
3911 dev->regs[0xd7] = 0x00;
3912 dev->regs[0xd8] = 0xff;
3913 dev->regs[0xd9] = 0x00;
3914 dev->regs[0xda] = 0x27;
3915 dev->regs[0xdb] = 0x00;
3916 dev->regs[0xdc] = 0x00;
3917 dev->regs[0xdd] = 0x00;
3918 dev->regs[0xde] = 0x00;
3919 dev->regs[0xdf] = 0x00;
3920 dev->regs[0xe0] = 0x00;
3921 dev->regs[0xe1] = 0x00;
3922 dev->regs[0xe2] = 0x01;
3923 dev->regs[0xe3] = 0x00;
3924 dev->regs[0xe4] = 0x00;
3926 /*dev->regs[0xe5] = 0x14;
3927 dev->regs[0xe6] = 0x00; 14=20 */
3928 SET_DOUBLE (dev->regs, EXPOSURE_REG, 20);
3930 dev->regs[0xe7] = 0x00;
3931 dev->regs[0xe8] = 0x00;
3932 dev->regs[0xe9] = 0x00;
3933 dev->regs[0xea] = 0x00;
3934 dev->regs[0xeb] = 0x00;
3935 dev->regs[0xec] = 0x00;
3936 dev->regs[0xed] = 0x00;
3937 dev->regs[0xee] = 0x00;
3938 dev->regs[0xef] = 0x00;
3939 dev->regs[0xf0] = 0x00;
3940 dev->regs[0xf1] = 0x00;
3941 dev->regs[0xf2] = 0x00;
3942 dev->regs[0xf3] = 0x00;
3946 for (i = 0; i < dev->reg_count; i++)
3947 dev->regs[i] = 0x00;
3949 dev->regs[0x00] = 0xf5;
3950 dev->regs[0x01] = 0x41;
3951 dev->regs[0x0b] = 0x70;
3952 dev->regs[0x10] = 0x50;
3953 dev->regs[0x11] = 0x03;
3954 dev->regs[0x12] = 0xff;
3955 dev->regs[0x13] = 0x3e;
3956 dev->regs[0x16] = 0xff;
3957 dev->regs[0x17] = 0x3e;
3958 dev->regs[0x1d] = 0x22;
3959 dev->regs[0x22] = 0x01;
3960 dev->regs[0x23] = 0xff;
3961 dev->regs[0x25] = 0xfe;
3962 dev->regs[0x34] = 0x10;
3963 dev->regs[0x39] = 0x02;
3964 dev->regs[0x40] = 0x80;
3965 dev->regs[0x44] = 0x8c;
3966 dev->regs[0x45] = 0x76;
3967 dev->regs[0x50] = 0x20;
3968 dev->regs[0x8b] = 0xff;
3969 dev->regs[0x8c] = 0x3f;
3970 dev->regs[0x8d] = 0x80;
3971 dev->regs[0x8e] = 0x68;
3972 dev->regs[0x93] = 0x01;
3973 dev->regs[0x94] = 0x1e;
3974 dev->regs[0xa3] = 0xcc;
3975 dev->regs[0xa4] = 0x27;
3976 dev->regs[0xa5] = 0x64;
3977 dev->regs[0xb0] = 0x80;
3978 dev->regs[0xb1] = 0x01;
3979 dev->regs[0xb2] = 0x06;
3980 dev->regs[0xd4] = 0x01;
3981 dev->regs[0xd5] = 0x06;
3982 dev->regs[0xd6] = 0x1b;
3983 dev->regs[0xd7] = 0x10;
3984 dev->regs[0xd8] = 0x7a;
3985 dev->regs[0xda] = 0xa7;
3986 dev->regs[0xe5] = 0x0f;
3987 if (dev->sensor == SENSOR_TYPE_4400_BARE)
3989 dev->regs[0x30] = 0x40; /* 0x00 */
3990 dev->regs[0x31] = 0x80; /* 0x00 */
3991 dev->regs[0x44] = 0x00; /* 0x8c */
3992 dev->regs[0x45] = 0x00; /* 0x76 */
3993 dev->regs[0x52] = 0x04; /* 0x00 */
3994 dev->regs[0x69] = 0x01; /* 0x00 */
3995 dev->regs[0x6a] = 0x10; /* 0x00 */
3996 dev->regs[0x6e] = 0x08; /* 0x00 */
3997 dev->regs[0x70] = 0x40; /* 0x00 */
3998 dev->regs[0x71] = 0x08; /* 0x00 */
3999 dev->regs[0x78] = 0x08; /* 0x00 */
4000 dev->regs[0x79] = 0x11; /* 0x00 */
4001 dev->regs[0x82] = 0x40; /* 0x00 */
4002 dev->regs[0x83] = 0x30; /* 0x00 */
4003 dev->regs[0x84] = 0x45; /* 0x00 */
4004 dev->regs[0x87] = 0x02; /* 0x00 */
4005 dev->regs[0x88] = 0x05; /* 0x00 */
4006 dev->regs[0x8b] = 0x01; /* 0xff */
4007 dev->regs[0x8c] = 0x80; /* 0x3f */
4008 dev->regs[0x8d] = 0x04; /* 0x80 */
4009 dev->regs[0x8e] = 0x10; /* 0x68 */
4010 dev->regs[0x8f] = 0x01; /* 0x00 */
4011 dev->regs[0x90] = 0x80; /* 0x00 */
4025 init_device (struct Rts8891_Device *dev)
4066 if (dev->initialized == SANE_TRUE)
4070 sanei_rts88xx_read_reg (dev->devnum, CONTROL_REG, &control);
4081 sanei_rts88xx_read_reg (dev->devnum, 0xb0, &control);
4092 sanei_rts88xx_get_status (dev->devnum, dev->regs);
4093 DBG (DBG_io, "init_device: status=0x%02x 0x%02x\n", dev->regs[0x10],
4094 dev->regs[0x11]);
4097 sanei_rts88xx_get_lamp_status (dev->devnum, dev->regs);
4098 DBG (DBG_io, "init_device: lamp status=0x%02x\n", dev->regs[0x8e]);
4101 dev->sensor = dev->model->sensor;
4102 DBG (DBG_info, "init_device: reg[8e]=0x%02x\n", dev->regs[0x8e]);
4105 sanei_rts88xx_reset_lamp (dev->devnum, dev->regs);
4106 if ((dev->regs[0x8e] & 0x60) != 0x60)
4109 dev->needs_warming = SANE_TRUE;
4113 dev->needs_warming = SANE_FALSE;
4117 sanei_rts88xx_get_lcd (dev->devnum, dev->regs);
4119 dev->regs[0x20], dev->regs[0x21], dev->regs[0x22]);
4122 sanei_rts88xx_read_reg (dev->devnum, LINK_REG, &id);
4134 sanei_rts88xx_write_control (dev->devnum, control);
4135 sanei_rts88xx_write_control (dev->devnum, control);
4138 sanei_rts88xx_read_regs (dev->devnum, 0, dev->regs, dev->reg_count);
4142 for (i = 0; i < dev->reg_count; i++)
4143 sprintf (message + strlen (message), "0x%02x ", dev->regs[i]);
4149 val = dev->regs[0x44] + 256 * dev->regs[0x45];
4151 if (dev->sensor == SENSOR_TYPE_4400)
4160 dev->sensor = SENSOR_TYPE_4400_BARE;
4164 init_registers(dev);
4166 sanei_rts88xx_set_offset (dev->regs, 31, 31, 31);
4167 sanei_rts88xx_set_gain (dev->regs, 10, 10, 10);
4168 dev->regs[0] = dev->regs[0] & 0xef;
4170 rts8891_write_all (dev->devnum, dev->regs, dev->reg_count);
4172 sanei_rts88xx_read_regs (dev->devnum, 0x1a, dev->regs + 0x1a, 2);
4174 DBG (DBG_io, "init_device: 0x%02x 0x%02x\n", dev->regs[0x1a],
4175 dev->regs[0x1b]);
4177 dev->regs[0xcf] = 0x00;
4178 dev->regs[0xd0] = 0xe0;
4179 rts8891_write_all (dev->devnum, dev->regs, dev->reg_count);
4180 sanei_rts88xx_read_regs (dev->devnum, 0x1a, dev->regs + 0x1a, 2);
4182 DBG (DBG_io, "init_device: 0x%02x 0x%02x\n", dev->regs[0x1a],
4183 dev->regs[0x1b]);
4185 sanei_rts88xx_set_status (dev->devnum, dev->regs, 0x20, 0x28);
4186 sanei_rts88xx_set_status (dev->devnum, dev->regs, 0x28, 0x28);
4187 sanei_rts88xx_cancel (dev->devnum);
4188 sanei_rts88xx_read_reg (dev->devnum, LAMP_REG, &control);
4189 sanei_rts88xx_write_control (dev->devnum, 0x00);
4190 sanei_rts88xx_write_control (dev->devnum, 0x00);
4191 sanei_rts88xx_read_reg (dev->devnum, LINK_REG, &id);
4198 dev->regs[0x12] = 0xff;
4199 dev->regs[0x14] = 0xf8;
4200 dev->regs[0x15] = 0x28;
4201 dev->regs[0x16] = 0x07;
4202 dev->regs[0x18] = 0xff;
4203 dev->regs[0x23] = 0xff;
4204 dev->regs[0x24] = 0xff;
4206 dev->regs[0x72] = 0xe1;
4207 dev->regs[0x73] = 0x14;
4208 dev->regs[0x74] = 0x18;
4209 dev->regs[0x75] = 0x15;
4210 dev->regs[0xc0] = 0xff;
4211 dev->regs[0xc1] = 0x0f;
4212 dev->regs[0xc3] = 0xff;
4213 dev->regs[0xc4] = 0xff;
4214 dev->regs[0xc5] = 0xff;
4215 dev->regs[0xc6] = 0xff;
4216 dev->regs[0xc7] = 0xff;
4217 dev->regs[0xc8] = 0xff;
4218 dev->regs[0xca] = 0x0e;
4219 dev->regs[0xcd] = 0xf0;
4220 dev->regs[0xce] = 0xff;
4221 dev->regs[0xcf] = 0xf5;
4222 dev->regs[0xd0] = 0xf7;
4223 dev->regs[0xd1] = 0xea;
4224 dev->regs[0xd2] = 0x0b;
4225 dev->regs[0xd3] = 0x03;
4226 dev->regs[0xd4] = 0x05;
4227 dev->regs[0xd7] = 0x30;
4228 dev->regs[0xd8] = 0xf6;
4229 dev->regs[0xd9] = 0x80;
4230 rts8891_write_all (dev->devnum, dev->regs, dev->reg_count);
4236 sanei_rts88xx_write_reg (dev->devnum, 0x93, ®);
4241 sanei_rts88xx_set_mem (dev->devnum, 0x81, 0x00, 2072, buffer);
4242 sanei_rts88xx_get_mem (dev->devnum, 0x81, 0x00, 2072, buffer);
4258 sanei_rts88xx_write_reg (dev->devnum, 0x93, ®);
4263 sanei_rts88xx_set_mem (dev->devnum, 0x81, 0x00, 2072, buffer);
4264 sanei_rts88xx_get_mem (dev->devnum, 0x81, 0x00, 2072, buffer);
4291 sanei_rts88xx_write_reg (dev->devnum, 0x93, ®);
4296 sanei_rts88xx_set_mem (dev->devnum, 0x81, 0x00, 2072, buffer);
4297 sanei_rts88xx_get_mem (dev->devnum, 0x81, 0x00, 2072, buffer);
4313 dev->regs[0x91] = 0x00; /* page 0 ? */
4314 dev->regs[0x92] = 0x00;
4315 dev->regs[0x93] = 0x01;
4316 rts8891_write_all (dev->devnum, dev->regs, dev->reg_count);
4324 sanei_rts88xx_set_mem (dev->devnum, 0x00, 0x00, 32, buffer);
4339 sanei_rts88xx_set_mem (dev->devnum, 0x00, page * 16, 32, buffer);
4341 sanei_rts88xx_get_mem (dev->devnum, 0x00, 0x00, 32, buffer);
4363 sanei_rts88xx_read_reg (dev->devnum, CONTROL_REG, &control);
4364 sanei_rts88xx_read_reg (dev->devnum, CONTROLER_REG, &control);
4367 if (park_head (dev, SANE_TRUE) != SANE_STATUS_GOOD)
4374 sanei_rts88xx_write_reg (dev->devnum, LAMP_REG, ®);
4376 sanei_rts88xx_write_reg (dev->devnum, LAMP_REG, ®);
4377 sanei_rts88xx_read_regs (dev->devnum, 0x14, dev->regs + 0x14, 2);
4379 dev->regs[0x14] = dev->regs[0x14] & 0x7F;
4380 sanei_rts88xx_write_regs (dev->devnum, 0x14, dev->regs + 0x14, 2);
4383 sanei_rts88xx_get_status (dev->devnum, dev->regs);
4384 DBG (DBG_io, "init_device: status=0x%02x 0x%02x\n", dev->regs[0x10],
4385 dev->regs[0x11]);
4386 sanei_rts88xx_read_reg (dev->devnum, LINK_REG, &control);
4388 sanei_rts88xx_read_reg (dev->devnum, CONTROL_REG, &control);
4389 sanei_rts88xx_reset_lamp (dev->devnum, dev->regs);
4391 sanei_rts88xx_write_reg (dev->devnum, LAMP_REG, ®);
4393 sanei_rts88xx_write_reg (dev->devnum, LAMP_REG, ®);
4398 sanei_rts88xx_read_reg (dev->devnum, LINK_REG, &control);
4402 sanei_rts88xx_read_reg (dev->devnum, CONTROL_REG, &control);
4408 sanei_rts88xx_reset_lamp (dev->devnum, dev->regs);
4409 sanei_rts88xx_read_reg (dev->devnum, 0x40, ®);
4411 sanei_rts88xx_read_reg (dev->devnum, 0x40, ®);
4412 sanei_rts88xx_read_reg (dev->devnum, 0x10, ®);
4413 sanei_rts88xx_read_reg (dev->devnum, 0x14, ®);
4415 sanei_rts88xx_write_reg (dev->devnum, 0x10, ®);
4417 sanei_rts88xx_write_reg (dev->devnum, 0x14, ®);
4419 sanei_rts88xx_write_reg (dev->devnum, 0x10, ®);
4421 sanei_rts88xx_write_reg (dev->devnum, CONTROLER_REG, ®);
4426 sanei_rts88xx_setup_nvram (dev->devnum, 21, nv_cmd1);
4427 sanei_rts88xx_setup_nvram (dev->devnum, 21, nv_cmd2);
4428 sanei_rts88xx_setup_nvram (dev->devnum, 21, nv_cmd3);
4429 sanei_rts88xx_set_status (dev->devnum, dev->regs, 0x28, 0x28);
4432 sanei_rts88xx_read_reg (dev->devnum, CONTROL_REG, &control);
4438 sanei_rts88xx_reset_lamp (dev->devnum, dev->regs);
4439 sanei_rts88xx_read_reg (dev->devnum, 0x40, ®);
4441 sanei_rts88xx_read_reg (dev->devnum, 0x40, ®);
4442 sanei_rts88xx_read_reg (dev->devnum, 0x10, ®);
4443 sanei_rts88xx_read_reg (dev->devnum, 0x14, ®);
4445 sanei_rts88xx_write_reg (dev->devnum, 0x10, ®);
4447 sanei_rts88xx_write_reg (dev->devnum, 0x14, ®);
4449 sanei_rts88xx_write_reg (dev->devnum, 0x10, ®);
4451 sanei_rts88xx_write_reg (dev->devnum, CONTROLER_REG, ®);
4455 sanei_rts88xx_setup_nvram (dev->devnum, 21, nv_cmd4);
4456 sanei_rts88xx_setup_nvram (dev->devnum, 21, nv_cmd5);
4457 sanei_rts88xx_setup_nvram (dev->devnum, 21, nv_cmd6);
4458 sanei_rts88xx_setup_nvram (dev->devnum, 21, nv_cmd7);
4460 sanei_rts88xx_set_status (dev->devnum, dev->regs, 0x28, 0x28);
4463 sanei_rts88xx_read_reg (dev->devnum, CONTROL_REG, &control);
4469 sanei_rts88xx_reset_lamp (dev->devnum, dev->regs);
4470 sanei_rts88xx_read_reg (dev->devnum, CONTROL_REG, &control);
4476 sanei_rts88xx_write_control (dev->devnum, 0x01);
4477 sanei_rts88xx_write_control (dev->devnum, 0x01);
4478 sanei_rts88xx_write_control (dev->devnum, 0x00);
4479 sanei_rts88xx_write_control (dev->devnum, 0x00);
4480 dev->regs[0x12] = 0xff;
4481 dev->regs[0x13] = 0x20;
4482 sanei_rts88xx_write_regs (dev->devnum, 0x12, dev->regs + 0x12, 2);
4483 dev->regs[0x14] = 0xf8;
4484 dev->regs[0x15] = 0x28;
4485 sanei_rts88xx_write_regs (dev->devnum, 0x14, dev->regs + 0x14, 2);
4487 sanei_rts88xx_write_control (dev->devnum, 0x00);
4488 sanei_rts88xx_write_control (dev->devnum, 0x00);
4489 sanei_rts88xx_set_status (dev->devnum, dev->regs, 0x28, 0x28);
4491 sanei_rts88xx_write_reg (dev->devnum, LAMP_REG, ®);
4493 dev->regs[0x8b] = 0xff;
4494 dev->regs[0x8c] = 0x3f;
4495 dev->regs[LAMP_REG] = 0xad;
4496 rts8891_write_all (dev->devnum, dev->regs, dev->reg_count);
4498 set_lamp_brightness (dev, 0);
4499 dev->initialized = SANE_TRUE;
4510 detect_device (struct Rts8891_Device *dev)
4533 sanei_rts88xx_read_reg (dev->devnum, 0xb0, &control);
4545 sanei_rts88xx_read_reg (dev->devnum, CONTROL_REG, &control);
4556 sanei_rts88xx_read_reg (dev->devnum, LINK_REG, &control);
4568 sanei_rts88xx_write_control (dev->devnum, control);
4569 sanei_rts88xx_write_control (dev->devnum, control);
4572 sanei_rts88xx_read_regs (dev->devnum, 0, dev->regs, dev->reg_count);
4576 for (i = 0; i < dev->reg_count; i++)
4577 sprintf (message + strlen (message), "0x%02x ", dev->regs[i]);
4583 val = dev->regs[0x44] + 256 * dev->regs[0x45];
4585 if (dev->sensor == SENSOR_TYPE_4400 && val == 0x00)
4587 dev->sensor = SENSOR_TYPE_4400_BARE;
4591 DBG (DBG_io, "detect_device: status=0x%02x 0x%02x\n", dev->regs[0x10],
4592 dev->regs[0x11]);
4593 DBG (DBG_io, "detect_device: lamp status=0x%02x\n", dev->regs[0x8e]);
4595 dev->initialized = SANE_FALSE;
4607 dark_calibration (struct Rts8891_Device *dev, int mode, int light)
4622 if (dev->sensor == SENSOR_TYPE_4400)
4630 sanei_rts88xx_set_gain (dev->regs, 0, 0, 0);
4631 sanei_rts88xx_set_scan_area (dev->regs, 1, 2, 4, 4 + CALIBRATION_WIDTH);
4633 sanei_rts88xx_set_status (dev->devnum, dev->regs, mode, light);
4635 dev->regs[0x00] = 0xe5; /* scan */
4636 dev->regs[0x32] = 0x00;
4637 dev->regs[0x33] = 0x03;
4638 dev->regs[0x35] = 0x45;
4639 dev->regs[0x36] = 0x22;
4640 dev->regs[0x3a] = 0x43;
4642 dev->regs[0x8d] = 0x00;
4643 dev->regs[0x8e] = 0x60;
4645 dev->regs[0xb2] = 0x02;
4647 dev->regs[0xc0] = 0x06;
4648 dev->regs[0xc1] = 0xe6;
4649 dev->regs[0xc2] = 0x67;
4650 dev->regs[0xc9] = 0x07;
4651 dev->regs[0xca] = 0x00;
4652 dev->regs[0xcb] = 0xfe;
4653 dev->regs[0xcc] = 0xf9;
4654 dev->regs[0xcd] = 0x19;
4655 dev->regs[0xce] = 0x98;
4656 dev->regs[0xcf] = 0xe8;
4657 dev->regs[0xd0] = 0xea;
4658 dev->regs[0xd1] = 0xf3;
4659 dev->regs[0xd2] = 0x14;
4660 dev->regs[0xd3] = 0x02;
4661 dev->regs[0xd4] = 0x04;
4662 dev->regs[0xd6] = 0x0f;
4663 dev->regs[0xd8] = 0x52;
4664 dev->regs[0xe2] = 0x1f;
4666 /*dev->regs[0xe5] = 0x28; 28=40
4667 dev->regs[0xe6] = 0x00; */
4668 SET_DOUBLE (dev->regs, EXPOSURE_REG, 40);
4670 dev->regs[0xe7] = 0x75;
4671 dev->regs[0xe8] = 0x01;
4672 dev->regs[0xe9] = 0x0b;
4673 dev->regs[0xea] = 0x54;
4674 dev->regs[0xeb] = 0x01;
4675 dev->regs[0xec] = 0x04;
4676 dev->regs[0xed] = 0xb8;
4677 dev->regs[0xef] = 0x03;
4678 dev->regs[0xf0] = 0x70;
4679 dev->regs[0xf2] = 0x01;
4682 if (dev->sensor == SENSOR_TYPE_XPA || dev->sensor == SENSOR_TYPE_4400)
4684 dev->regs[0xc0] = 0x67;
4685 dev->regs[0xc1] = 0x06;
4686 dev->regs[0xc2] = 0xe6;
4687 dev->regs[0xc3] = 0x98;
4688 dev->regs[0xc4] = 0xf9;
4689 dev->regs[0xc5] = 0x19;
4690 dev->regs[0xc6] = 0x67;
4691 dev->regs[0xc7] = 0x06;
4692 dev->regs[0xc8] = 0xe6;
4693 dev->regs[0xc9] = 0x01;
4694 dev->regs[0xca] = 0xf8;
4695 dev->regs[0xcb] = 0xff;
4696 dev->regs[0xcc] = 0x98;
4697 dev->regs[0xcd] = 0xf9;
4698 dev->regs[0xce] = 0x19;
4699 dev->regs[0xcf] = 0xe0;
4700 dev->regs[0xd0] = 0xe2;
4701 dev->regs[0xd1] = 0xeb;
4702 dev->regs[0xd2] = 0x0c;
4703 dev->regs[0xd7] = 0x10;
4704 dev->regs[0xda] = 0xa7;
4706 if (dev->sensor == SENSOR_TYPE_4400)
4708 dev->regs[0x13] = 0x39; /* 0x20 */
4709 dev->regs[0x14] = 0xf0; /* 0xf8 */
4710 dev->regs[0x15] = 0x29; /* 0x28 */
4711 dev->regs[0x16] = 0x0f; /* 0x07 */
4712 dev->regs[0x17] = 0x10; /* 0x00 */
4713 dev->regs[0x23] = 0x00; /* 0xff */
4714 dev->regs[0x35] = 0x48; /* 0x45 */
4715 dev->regs[0x39] = 0x00; /* 0x02 */
4716 dev->regs[0xe2] = 0x0f; /* 0x1f */
4717 /* dev->regs[0xe5] = 0x52; 0x28 */
4718 SET_DOUBLE (dev->regs, EXPOSURE_REG, 82); /* 2*40+2 */
4719 dev->regs[0xe7] = 0x0e; /* 0x75 */
4720 dev->regs[0xe9] = 0x0a; /* 0x0b */
4721 dev->regs[0xea] = 0xc2; /* 0x54 */
4722 dev->regs[0xed] = 0xf6; /* 0xb8 */
4723 dev->regs[0xef] = 0x02; /* 0x03 */
4724 dev->regs[0xf0] = 0xa8; /* 0x70 */
4726 if (dev->sensor == SENSOR_TYPE_4400_BARE)
4728 dev->regs[0x13] = 0x39; /* 0x20 */
4729 dev->regs[0x14] = 0xf0; /* 0xf8 */
4730 dev->regs[0x15] = 0x29; /* 0x28 */
4731 dev->regs[0x16] = 0x0f; /* 0x07 */
4732 dev->regs[0x17] = 0x10; /* 0x00 */
4733 dev->regs[0x23] = 0x00; /* 0xff */
4734 dev->regs[0x35] = 0x48; /* 0x45 */
4735 dev->regs[0x39] = 0x00; /* 0x02 */
4736 dev->regs[0xda] = 0xa7; /* 0xa0 */
4737 dev->regs[0xe2] = 0x0f; /* 0x1f */
4738 SET_DOUBLE (dev->regs, EXPOSURE_REG, 82);
4739 dev->regs[0xe7] = 0x0e; /* 0x75 */
4740 dev->regs[0xe9] = 0x0a; /* 0x0b */
4741 dev->regs[0xea] = 0xc2; /* 0x54 */
4742 dev->regs[0xed] = 0xf6; /* 0xb8 */
4743 dev->regs[0xef] = 0x02; /* 0x03 */
4744 dev->regs[0xf0] = 0xa8; /* 0x70 */
4749 sanei_rts88xx_set_status (dev->devnum, dev->regs, mode, light);
4753 sanei_rts88xx_set_offset (dev->regs, ro, go, bo);
4759 rts8891_simple_scan (dev->devnum, dev->regs, dev->reg_count, 0x02,
4847 dev->red_offset = bro;
4848 dev->green_offset = bgo;
4849 dev->blue_offset = bbo;
4862 gain_calibration (struct Rts8891_Device *dev, int mode, int light)
4880 int xstart = (dev->left_offset * 75) / dev->model->max_xdpi;
4885 sanei_rts88xx_set_scan_area (dev->regs, 1, 2, xstart, xstart + width);
4886 sanei_rts88xx_set_offset (dev->regs, dev->red_offset, dev->green_offset,
4887 dev->blue_offset);
4890 dev->regs[0x32] = 0x00;
4891 dev->regs[0x33] = 0x03;
4892 dev->regs[0x35] = 0x45;
4893 dev->regs[0x36] = 0x22;
4894 dev->regs[0x3a] = 0x43;
4896 dev->regs[0x8d] = 0x00;
4897 dev->regs[0x8e] = 0x60;
4899 dev->regs[0xb2] = 0x02;
4901 dev->regs[0xc0] = 0x06;
4902 dev->regs[0xc1] = 0xe6;
4903 dev->regs[0xc2] = 0x67;
4904 dev->regs[0xc9] = 0x07;
4905 dev->regs[0xca] = 0x00;
4906 dev->regs[0xcb] = 0xfe;
4907 dev->regs[0xcc] = 0xf9;
4908 dev->regs[0xcd] = 0x19;
4909 dev->regs[0xce] = 0x98;
4910 dev->regs[0xcf] = 0xe8;
4911 dev->regs[0xd0] = 0xea;
4912 dev->regs[0xd1] = 0xf3;
4913 dev->regs[0xd2] = 0x14;
4914 dev->regs[0xd3] = 0x02;
4915 dev->regs[0xd4] = 0x04;
4916 dev->regs[0xd6] = 0x0f;
4917 dev->regs[0xd8] = 0x52;
4918 dev->regs[0xe2] = 0x1f;
4920 /* dev->regs[0xe5] = 0x28;
4921 dev->regs[0xe6] = 0x00; 28=40 */
4922 SET_DOUBLE (dev->regs, EXPOSURE_REG, 40);
4924 dev->regs[0xe7] = 0x75;
4925 dev->regs[0xe8] = 0x01;
4926 dev->regs[0xe9] = 0x0b;
4927 dev->regs[0xea] = 0x54;
4928 dev->regs[0xeb] = 0x01;
4929 dev->regs[0xec] = 0x04;
4930 dev->regs[0xed] = 0xb8;
4931 dev->regs[0xef] = 0x03;
4932 dev->regs[0xf0] = 0x70;
4933 dev->regs[0xf2] = 0x01;
4935 dev->regs[0x72] = 0xe1;
4936 dev->regs[0x73] = 0x14;
4937 dev->regs[0x74] = 0x18;
4939 dev->regs[0xc3] = 0xff;
4940 dev->regs[0xc4] = 0xff;
4941 dev->regs[0xc7] = 0xff;
4942 dev->regs[0xc8] = 0xff;
4944 dev->regs[0xd7] = 0x30;
4946 if (dev->sensor == SENSOR_TYPE_XPA || dev->sensor == SENSOR_TYPE_4400)
4948 dev->regs[0xc0] = 0x67;
4949 dev->regs[0xc1] = 0x06;
4950 dev->regs[0xc2] = 0xe6;
4951 dev->regs[0xc3] = 0x98;
4952 dev->regs[0xc4] = 0xf9;
4953 dev->regs[0xc5] = 0x19;
4954 dev->regs[0xc6] = 0x67;
4955 dev->regs[0xc7] = 0x06;
4956 dev->regs[0xc8] = 0xe6;
4957 dev->regs[0xc9] = 0x01;
4958 dev->regs[0xca] = 0xf8;
4959 dev->regs[0xcb] = 0xff;
4960 dev->regs[0xcc] = 0x98;
4961 dev->regs[0xcd] = 0xf9;
4962 dev->regs[0xce] = 0x19;
4963 dev->regs[0xcf] = 0xe0;
4964 dev->regs[0xd0] = 0xe2;
4965 dev->regs[0xd1] = 0xeb;
4966 dev->regs[0xd2] = 0x0c;
4967 dev->regs[0xd3] = 0x02;
4968 dev->regs[0xd4] = 0x04;
4969 dev->regs[0xd6] = 0x0f;
4970 dev->regs[0xd7] = 0x10;
4971 dev->regs[0xd8] = 0x52;
4972 dev->regs[0xe2] = 0x1f;
4973 /* dev->regs[0xe5] = 0x28; 0028 -> 40
4974 dev->regs[0xe6] = 0x00; */
4975 SET_DOUBLE (dev->regs, EXPOSURE_REG, 40);
4976 dev->regs[0xe7] = 0x75;
4977 dev->regs[0xe8] = 0x01;
4978 dev->regs[0xe9] = 0x0b;
4979 dev->regs[0xea] = 0x54;
4980 dev->regs[0xeb] = 0x01;
4981 dev->regs[0xec] = 0x04;
4982 dev->regs[0xed] = 0xb8;
4983 dev->regs[0xef] = 0x03;
4984 dev->regs[0xf0] = 0x70;
4985 dev->regs[0xf2] = 0x01;
4987 if (dev->sensor == SENSOR_TYPE_4400)
4989 dev->regs[0x35] = 0x48; /* 0x45 */
4991 dev->regs[0xe2] = 0x0f; /* 0x1f */
4992 /* dev->regs[0xe5] = 0x52; */
4993 SET_DOUBLE (dev->regs, EXPOSURE_REG, 82); /* 2*40+2 */
4994 dev->regs[0xe7] = 0x0e; /* 0x75 */
4995 dev->regs[0xe9] = 0x0a; /* 0x0b */
4996 dev->regs[0xea] = 0xc2; /* 0x54 */
4997 dev->regs[0xed] = 0xf6; /* 0xb8 */
4998 dev->regs[0xef] = 0x02; /* 0x03 */
4999 dev->regs[0xf0] = 0xa8; /* 0x70 */
5001 if (dev->sensor == SENSOR_TYPE_4400_BARE)
5003 dev->regs[0x13] = 0x39;
5004 dev->regs[0x14] = 0xf0;
5005 dev->regs[0x15] = 0x29;
5006 dev->regs[0x16] = 0x0f;
5007 dev->regs[0x17] = 0x10;
5008 dev->regs[0x23] = 0x00;
5009 dev->regs[0x35] = 0x48;
5010 dev->regs[0x39] = 0x00;
5011 dev->regs[0xe2] = 0x0f;
5012 SET_DOUBLE (dev->regs, EXPOSURE_REG, 82);
5013 dev->regs[0xe7] = 0x0e;
5014 dev->regs[0xe9] = 0x0a;
5015 dev->regs[0xea] = 0xc2;
5016 dev->regs[0xed] = 0xf6;
5017 dev->regs[0xef] = 0x02;
5018 dev->regs[0xf0] = 0xa8;
5021 dev->regs[0x85] = 0x00;
5022 dev->regs[0x86] = 0x06;
5023 dev->regs[0x87] = 0x00;
5024 dev->regs[0x88] = 0x06;
5026 SET_DOUBLE (dev->regs, TIMING_REG, timing);
5027 SET_DOUBLE (dev->regs, TIMING1_REG, timing+1);
5028 SET_DOUBLE (dev->regs, TIMING2_REG, timing+2);
5059 sanei_rts88xx_set_gain (dev->regs, rg, gg, bg);
5060 sanei_rts88xx_set_status (dev->devnum, dev->regs, mode, light);
5064 rts8891_simple_scan (dev->devnum, dev->regs, dev->reg_count, 0x02,
5206 dev->red_gain = brg;
5207 dev->green_gain = bgg;
5208 dev->blue_gain = bbg;
5223 offset_calibration (struct Rts8891_Device *dev, int mode, int light)
5240 sanei_rts88xx_set_gain (dev->regs, dev->red_gain, dev->green_gain,
5241 dev->blue_gain);
5242 sanei_rts88xx_set_scan_area (dev->regs, 1, 2, 4, 4 + CALIBRATION_WIDTH);
5244 dev->regs[0x32] = 0x00;
5245 dev->regs[0x33] = 0x03;
5246 dev->regs[0x35] = 0x45;
5247 dev->regs[0x36] = 0x22;
5248 dev->regs[0x3a] = 0x43;
5250 dev->regs[0x8d] = 0x00;
5251 dev->regs[0x8e] = 0x60;
5252 dev->regs[0xb2] = 0x02;
5253 dev->regs[0xc0] = 0x06;
5254 dev->regs[0xc1] = 0xe6;
5255 dev->regs[0xc2] = 0x67;
5256 dev->regs[0xc9] = 0x07;
5257 dev->regs[0xca] = 0x00;
5258 dev->regs[0xcb] = 0xfe;
5259 dev->regs[0xcc] = 0xf9;
5260 dev->regs[0xcd] = 0x19;
5261 dev->regs[0xce] = 0x98;
5262 dev->regs[0xcf] = 0xe8;
5263 dev->regs[0xd0] = 0xea;
5264 dev->regs[0xd1] = 0xf3;
5265 dev->regs[0xd2] = 0x14;
5266 dev->regs[0xd3] = 0x02;
5267 dev->regs[0xd4] = 0x04;
5268 dev->regs[0xd6] = 0x0f;
5269 dev->regs[0xd8] = 0x52;
5270 dev->regs[0xe2] = 0x1f;
5271 /* dev->regs[0xe5] = 0x28;
5272 dev->regs[0xe6] = 0x00; 0x0028=40 */
5273 SET_DOUBLE (dev->regs, EXPOSURE_REG, 40);
5274 dev->regs[0xe7] = 0x75;
5275 dev->regs[0xe8] = 0x01;
5276 dev->regs[0xe9] = 0x0b;
5277 dev->regs[0xea] = 0x54;
5278 dev->regs[0xeb] = 0x01;
5279 dev->regs[0xec] = 0x04;
5280 dev->regs[0xed] = 0xb8;
5281 dev->regs[0xef] = 0x03;
5282 dev->regs[0xf0] = 0x70;
5283 dev->regs[0xf2] = 0x01;
5284 if (dev->sensor == SENSOR_TYPE_XPA || dev->sensor == SENSOR_TYPE_4400)
5286 dev->regs[0x72] = 0xe1;
5287 dev->regs[0x73] = 0x14;
5288 dev->regs[0x74] = 0x18;
5290 dev->regs[0xc0] = 0x67;
5291 dev->regs[0xc1] = 0x06;
5292 dev->regs[0xc2] = 0xe6;
5293 dev->regs[0xc3] = 0x98;
5294 dev->regs[0xc4] = 0xf9;
5295 dev->regs[0xc5] = 0x19;
5296 dev->regs[0xc6] = 0x67;
5297 dev->regs[0xc7] = 0x06;
5298 dev->regs[0xc8] = 0xe6;
5299 dev->regs[0xc9] = 0x01;
5300 dev->regs[0xca] = 0xf8;
5301 dev->regs[0xcb] = 0xff;
5302 dev->regs[0xcc] = 0x98;
5303 dev->regs[0xcd] = 0xf9;
5304 dev->regs[0xce] = 0x19;
5305 dev->regs[0xcf] = 0xe0;
5306 dev->regs[0xd0] = 0xe2;
5307 dev->regs[0xd1] = 0xeb;
5308 dev->regs[0xd2] = 0x0c;
5309 dev->regs[0xd7] = 0x10;
5311 if (dev->sensor == SENSOR_TYPE_4400)
5313 dev->regs[0x35] = 0x48; /* 0x45 */
5315 dev->regs[0xe2] = 0x0f; /* 0x1f */
5316 /* dev->regs[0xe5] = 0x52; 0x28 */
5317 SET_DOUBLE (dev->regs, EXPOSURE_REG, 82); /* 2*40+2 */
5318 dev->regs[0xe7] = 0x0e; /* 0x75 */
5319 dev->regs[0xe9] = 0x0a; /* 0x0b */
5320 dev->regs[0xea] = 0xc2; /* 0x54 */
5321 dev->regs[0xed] = 0xf6; /* 0xb8 */
5322 dev->regs[0xef] = 0x02; /* 0x03 */
5323 dev->regs[0xf0] = 0xa8; /* 0x70 */
5325 if (dev->sensor == SENSOR_TYPE_4400_BARE)
5327 dev->regs[0x13] = 0x39; /* 0x20 */
5328 dev->regs[0x14] = 0xf0; /* 0xf8 */
5329 dev->regs[0x15] = 0x29; /* 0x28 */
5330 dev->regs[0x16] = 0x0f; /* 0x07 */
5331 dev->regs[0x17] = 0x10; /* 0x00 */
5332 dev->regs[0x23] = 0x00; /* 0xff */
5333 dev->regs[0x35] = 0x48; /* 0x45 */
5334 dev->regs[0x39] = 0x00; /* 0x02 */
5335 dev->regs[0xe2] = 0x0f; /* 0x1f */
5336 SET_DOUBLE (dev->regs, EXPOSURE_REG, 82); /* 2*40+2 */
5337 dev->regs[0xe7] = 0x0e; /* 0x75 */
5338 dev->regs[0xe9] = 0x0a; /* 0x0b */
5339 dev->regs[0xea] = 0xc2; /* 0x54 */
5340 dev->regs[0xed] = 0xf6; /* 0xb8 */
5341 dev->regs[0xef] = 0x02; /* 0x03 */
5342 dev->regs[0xf0] = 0xa8; /* 0x70 */
5351 sanei_rts88xx_set_offset (dev->regs, ro, go, bo);
5352 sanei_rts88xx_set_status (dev->devnum, dev->regs, mode, light);
5353 rts8891_simple_scan (dev->devnum, dev->regs, dev->reg_count, 0x02,
5436 dev->red_offset = bro;
5437 dev->green_offset = bgo;
5438 dev->blue_offset = bbo;
5450 setup_shading_calibration (struct Rts8891_Device *dev, int mode, int *light, int *status1, SANE_Byte * regs)
5458 DBG (DBG_info, "setup_shading_calibration: sensor type is %s (%d)\n", sensor_name (dev->sensor), dev->sensor);
5463 if (dev->xdpi > 300)
5490 if (dev->sensor == SENSOR_TYPE_XPA || dev->sensor == SENSOR_TYPE_4400)
5515 if (dev->sensor == SENSOR_TYPE_4400)
5533 if (dev->sensor == SENSOR_TYPE_4400_BARE)
5547 switch (dev->xdpi)
5554 switch (dev->sensor)
5690 switch (dev->sensor)
5803 switch (dev->sensor)
5957 switch (dev->sensor)
6114 sanei_rts88xx_set_offset (regs, dev->red_offset, dev->green_offset, dev->blue_offset);
6115 sanei_rts88xx_set_gain (regs, dev->red_gain, dev->green_gain, dev->blue_gain);
6116 sanei_rts88xx_set_scan_area (regs, 1, 1 + lines, dev->xstart, dev->xstart + dev->pixels);
6128 shading_calibration (struct Rts8891_Device *dev, SANE_Bool color, int mode, int light)
6142 sensor_name (dev->sensor), dev->sensor);
6144 width = dev->pixels;
6145 size = lines * dev->bytes_per_line;
6154 if (dev->shading_data != NULL)
6155 free (dev->shading_data);
6156 dev->shading_data = (unsigned char *) malloc (dev->bytes_per_line);
6157 if (dev->shading_data == NULL)
6166 status=setup_shading_calibration(dev, mode, &light, &status1, dev->regs);
6170 free (dev->shading_data);
6171 dev->shading_data = NULL;
6177 sanei_rts88xx_set_status (dev->devnum, dev->regs, status1, light);
6178 format = rts8891_data_format (dev->xdpi, dev->sensor);
6179 status = rts8891_simple_scan (dev->devnum, dev->regs, dev->reg_count, format, size, image);
6183 free (dev->shading_data);
6184 dev->shading_data = NULL;
6220 dev->shading_data[x] = sum / (lines - 13);
6228 fwrite (dev->shading_data, width, 1, dbg);
6233 fwrite (dev->shading_data, width, 1, dbg);
6284 struct Rts8891_Device *dev = session->dev;
6296 data_size = (675 * dev->xdpi) / 75;
6298 width = dev->pixels;
6405 if (gamma_r[dev->shading_data[i * 3]] < 5)
6408 value = red_code / gamma_r[dev->shading_data[i * 3]];
6416 if (gamma_r[dev->shading_data[i * 3 + 1]] < 5)
6419 value = green_code / gamma_g[dev->shading_data[i * 3 + 1]];
6428 if (gamma_r[dev->shading_data[i * 3 + 2]] < 5)
6431 value = blue_code / gamma_b[dev->shading_data[i * 3 + 2]];
6447 fprintf (calib, "%02x ", dev->shading_data[i]);
6459 format = rts8891_data_format (dev->xdpi, dev->sensor);
6460 status = sanei_rts88xx_write_reg (dev->devnum, 0xd3, &format);
6467 sanei_rts88xx_write_mem (dev->devnum, RTS88XX_MAX_XFER_SIZE, 6,
6477 sanei_rts88xx_write_mem (dev->devnum, size, 0,
6488 status = sanei_rts88xx_write_mem (dev->devnum, size, 6, calibration);
6498 dev->regs[0x91] = 0x00;
6499 dev->regs[0x92] = 0x00;
6500 sanei_rts88xx_write_regs (dev->devnum, 0x91, dev->regs + 0x91, 2);
6507 /* move at dev->model->min_ydpi dpi up to the scanning area. Which speeds
6516 struct Rts8891_Device *dev = session->dev;
6522 distance = ((dev->ystart - 1) * MOVE_DPI) / dev->ydpi;
6523 dev->ystart = dev->ystart - (distance * dev->ydpi) / MOVE_DPI;
6528 dev->ystart);
6531 rts8891_move (dev, regs, distance, SANE_TRUE);
6536 sanei_rts88xx_read_reg (dev->devnum, CONTROL_REG, &control);
6555 struct Rts8891_Device *dev = session->dev;
6561 && (session->dev->model->flags & RTS8891_FLAG_EMULATED_GRAY_MODE) == 0)
6566 sanei_rts88xx_set_scan_area (regs, dev->ystart, dev->ystart + dev->lines, dev->xstart, dev->xstart + dev->pixels);
6567 DBG (DBG_info, "setup_scan_registers: xstart=%d, pixels=%d\n", dev->xstart, dev->pixels);
6568 DBG (DBG_info, "setup_scan_registers: ystart=%d, lines =%d\n", dev->ystart, dev->lines);
6574 sanei_rts88xx_set_offset (regs, dev->red_offset, dev->green_offset, dev->blue_offset);
6575 sanei_rts88xx_set_gain (regs, dev->red_gain, dev->green_gain, dev->blue_gain);
6577 switch (dev->sensor)
6834 if (dev->sensor == SENSOR_TYPE_XPA || dev->sensor == SENSOR_TYPE_4400)
6859 if (dev->sensor == SENSOR_TYPE_4400)
6891 if (dev->sensor == SENSOR_TYPE_4400_BARE)
6926 switch (dev->xdpi)
6955 switch (dev->sensor)
7049 switch (dev->sensor)
7201 switch (dev->sensor)
7398 switch (dev->sensor)
7598 regs[0xd3] = rts8891_data_format (dev->xdpi, dev->sensor);
7622 struct Rts8891_Device *dev = session->dev;
7625 status=setup_scan_registers (session, &status1, &status2, dev->regs);
7634 sanei_rts88xx_read_reg (dev->devnum, CONTROL_REG, &control);
7642 status = rts8891_write_all (dev->devnum, dev->regs, dev->reg_count);
7655 park_head (struct Rts8891_Device *dev, SANE_Bool wait)
7665 sanei_rts88xx_write_reg (dev->devnum, LAMP_REG, ®);
7667 sanei_rts88xx_write_reg (dev->devnum, LAMP_REG, ®);
7669 status = sanei_rts88xx_read_reg (dev->devnum, CONTROL_REG, &control);
7672 sanei_rts88xx_write_reg (dev->devnum, 0x23, ®);
7675 if (dev->sensor != SENSOR_TYPE_4400)
7677 dev->regs[0x16] = 0x07;
7678 dev->regs[0x17] = 0x00;
7682 dev->regs[0x16] = 0x0f;
7683 dev->regs[0x17] = 0x10;
7685 sanei_rts88xx_write_regs (dev->devnum, 0x16, dev->regs + 0x16, 2);
7688 sanei_rts88xx_write_reg (dev->devnum, LAMP_REG, ®);
7690 sanei_rts88xx_write_reg (dev->devnum, LAMP_REG, ®);
7693 sanei_rts88xx_read_reg (dev->devnum, CONTROLER_REG, ®);
7700 status = rts8891_park (dev, regs, wait);
7726 if (session->dev->conf.allowsharing == SANE_TRUE)
7728 status = sanei_usb_claim_interface (session->dev->devnum, 0);
7739 status = rts8891_read_buttons (session->dev->devnum, &mask);
7744 if (session->dev->conf.allowsharing == SANE_TRUE)
7746 sanei_usb_release_interface (session->dev->devnum, 0);
7750 for (i = 0; i < session->dev->model->buttons; i++)
7771 if (session->dev->conf.allowsharing == SANE_TRUE)
7773 status = sanei_usb_claim_interface (session->dev->devnum, 0);
7781 status = sanei_rts88xx_read_reg (session->dev->devnum, LAMP_REG, ®);
7785 reg = session->dev->regs[LAMP_REG] | 0x80;
7790 reg = session->dev->regs[LAMP_REG] & 0x7F;
7793 session->dev->last_scan.tv_sec = 0;
7796 status = sanei_rts88xx_write_reg (session->dev->devnum, LAMP_REG, ®);
7799 if (session->dev->conf.allowsharing == SANE_TRUE)
7801 sanei_usb_release_interface (session->dev->devnum, 0);