Lines Matching refs:Regs
82 void shadingtest1 (struct st_device *dev, SANE_Byte * Regs,
84 static SANE_Int Calib_test (struct st_device *dev, SANE_Byte * Regs,
88 SANE_Byte * Regs,
167 static SANE_Int RTS_Enable_CCD (struct st_device *dev, SANE_Byte * Regs,
172 static SANE_Int RTS_DMA_CheckType (struct st_device *dev, SANE_Byte * Regs);
181 static SANE_Int RTS_DMA_SetType (struct st_device *dev, SANE_Byte * Regs,
207 static SANE_Byte RTS_IsExecuting (struct st_device *dev, SANE_Byte * Regs);
211 static SANE_Int RTS_GetImage (struct st_device *dev, SANE_Byte * Regs,
239 static SANE_Int RTS_Setup (struct st_device *dev, SANE_Byte * Regs,
246 static void RTS_Setup_Channels (struct st_device *dev, SANE_Byte * Regs,
249 static void RTS_Setup_Coords (SANE_Byte * Regs, SANE_Int iLeft, SANE_Int iTop,
251 static SANE_Int RTS_Setup_Depth (SANE_Byte * Regs,
254 static void RTS_Setup_Exposure_Times (SANE_Byte * Regs,
257 static void RTS_Setup_GainOffset (SANE_Byte * Regs,
259 static void RTS_Setup_Gamma (SANE_Byte * Regs, struct st_hwdconfig *lowcfg);
261 SANE_Byte * Regs,
266 static SANE_Int RTS_Setup_Motor (struct st_device *dev, SANE_Byte * Regs,
269 static void RTS_Setup_RefVoltages (struct st_device *dev, SANE_Byte * Regs);
271 SANE_Byte * Regs);
272 static void RTS_Setup_Shading (SANE_Byte * Regs,
279 static void SetLock (USB_Handle usb_handle, SANE_Byte * Regs,
281 static SANE_Int fn3330 (struct st_device *dev, SANE_Byte * Regs,
288 SANE_Byte * Regs, USHORT * table,
324 static SANE_Int Refs_Detect (struct st_device *dev, SANE_Byte * Regs,
330 static SANE_Int Refs_Set (struct st_device *dev, SANE_Byte * Regs,
353 static SANE_Int Gamma_Apply (struct st_device *dev, SANE_Byte * Regs,
358 static SANE_Int Gamma_SendTables (struct st_device *dev, SANE_Byte * Regs,
366 static void Lamp_SetGainMode (struct st_device *dev, SANE_Byte * Regs,
380 static SANE_Int Lamp_Status_Set (struct st_device *dev, SANE_Byte * Regs,
384 static SANE_Int Lamp_Warmup (struct st_device *dev, SANE_Byte * Regs,
388 static SANE_Int Head_IsAtHome (struct st_device *dev, SANE_Byte * Regs);
400 static SANE_Int Motor_Move (struct st_device *dev, SANE_Byte * Regs,
404 static SANE_Int Motor_Setup_Steps (struct st_device *dev, SANE_Byte * Regs,
457 static SANE_Int Timing_SetLinearImageSensorClock (SANE_Byte * Regs,
511 SANE_Byte * Regs,
525 static SANE_Int Calibration (struct st_device *dev, SANE_Byte * Regs,
530 static SANE_Int WShading_Calibrate (struct st_device *dev, SANE_Byte * Regs,
537 static SANE_Int Shading_apply (struct st_device *dev, SANE_Byte * Regs,
540 static SANE_Int Shading_black_apply (struct st_device *dev, SANE_Byte * Regs,
544 static SANE_Int Shading_white_apply (struct st_device *dev, SANE_Byte * Regs,
571 static SANE_Int SetMultiExposure (struct st_device *dev, SANE_Byte * Regs);
577 static SANE_Int SetScanParams (struct st_device *dev, SANE_Byte * Regs,
765 SetLock (USB_Handle usb_handle, SANE_Byte * Regs, SANE_Byte Enable)
769 DBG (DBG_FNC, "+ SetLock(*Regs, Enable=%i):\n", Enable);
771 if (Regs == NULL)
777 lock = Regs[0x600];
784 if (Regs != NULL)
785 Regs[0x600] = lock;
1636 SetScanParams (struct st_device *dev, SANE_Byte * Regs,
1863 data_bitset (&Regs[0xc0], 0x1f,
2533 SANE_Byte *Regs;
2540 Regs = (SANE_Byte *) malloc (RT_BUFFER_LEN * sizeof (SANE_Byte));
2541 if (Regs != NULL)
2543 if (RTS_ReadRegs (dev->usb_handle, Regs) == OK)
2545 data_bitset (&Regs[0x148], 0x3f, duty_cycle);
2549 data_bitset (&Regs[0x148], 0x40, 0);
2550 Regs[0x1e0] |= ((duty_cycle >> 1) & 0x40);
2553 data_bitset (&dev->init_regs[0x148], 0x7f, Regs[0x148]);
2554 data_bitset (&dev->init_regs[0x1e0], 0x3f, Regs[0x1e0]);
2556 Write_Byte (dev->usb_handle, 0xe948, Regs[0x0148]);
2558 rst = Write_Byte (dev->usb_handle, 0xe9e0, Regs[0x01e0]);
2561 free (Regs);
2573 SANE_Byte *Regs;
2577 Regs = (SANE_Byte *) malloc (RT_BUFFER_LEN * sizeof (SANE_Byte));
2578 if (Regs != NULL)
2582 memcpy (Regs, dev->init_regs, RT_BUFFER_LEN * sizeof (SANE_Byte));
2595 if (RTS_IsExecuting (dev, Regs) == FALSE)
2604 if ((rst == OK) && (Head_IsAtHome (dev, Regs) == FALSE))
2636 Motor_Move (dev, Regs, &mymotor, &mtrpos);
2645 free (Regs);
2654 Motor_Move (struct st_device *dev, SANE_Byte * Regs,
2669 memcpy (cpRegs, Regs, RT_BUFFER_LEN * sizeof (SANE_Byte));
2745 data_lsb_set (&Regs[0xea], 0x10, 3);
2748 data_lsb_set (&Regs[0xed], 0x10, 3);
2751 data_lsb_set (&Regs[0xf0], 0x10, 3);
2754 data_lsb_set (&Regs[0xf3], 0x10, 3);
2799 switch (Regs[0x00] & 0x0f)
3011 Motor_Setup_Steps (struct st_device *dev, SANE_Byte * Regs,
3020 DBG (DBG_FNC, "+ Motor_Setup_Steps(*Regs, motorsetting=%i):\n", mysetting);
3041 last_acc_step = data_lsb_get (&Regs[0xe1], 3);
3044 data_wide_bitset (&Regs[0xf6], 0x3fff, stepbuffer_size);
3075 myvar = data_lsb_get (&Regs[0x30], 3) + 1;
3085 data_wide_bitset (&Regs[0xf8], 0x3fff, stepbuffer_size);
3090 data_lsb_set (&Regs[0xea], mycurve->step[mycurve->step_count - 1], 3);
3110 SANE_Int step_size = _B0 (Regs[0xe0]) + 1;
3140 data_wide_bitset (&Regs[0xfa], 0x3fff,
3141 data_lsb_get (&Regs[0xf6], 2));
3143 data_lsb_set (&Regs[0xe4], data_lsb_get (&Regs[0xe1], 3), 3);
3149 data_wide_bitset (&Regs[0xfa], 0x3fff, stepbuffer_size);
3156 data_lsb_set (&Regs[0xe4],
3170 data_wide_bitset (&Regs[0xfa], 0x3fff, 0);
3181 data_wide_bitset (&Regs[0x00fc], 0x3fff,
3182 data_lsb_get (&Regs[0x00f8], 2));
3184 data_lsb_set (&Regs[0x00f0], data_lsb_get (&Regs[0x00ea], 3), 3);
3191 data_wide_bitset (&Regs[0xfc], 0x3fff, stepbuffer_size);
3198 data_lsb_set (&Regs[0xf0],
3212 data_wide_bitset (&Regs[0x00fc], 0x3fff, 0);
3223 data_wide_bitset (&Regs[0xfe], 0x3fff,
3224 data_lsb_get (&Regs[0xf8], 2));
3226 data_lsb_set (&Regs[0xed], data_lsb_get (&Regs[0xea], 3), 3);
3233 data_wide_bitset (&Regs[0xfe], 0x3fff,
3234 data_lsb_get (&Regs[0xfc], 2));
3236 data_lsb_set (&Regs[0xed], data_lsb_get (&Regs[0xf0], 3), 3);
3243 data_wide_bitset (&Regs[0xfe], 0x3fff, stepbuffer_size);
3250 data_lsb_set (&Regs[0xed],
3264 data_wide_bitset (&Regs[0xfe], 0x3fff, 0);
3276 data_wide_bitset (&Regs[0x100], 0x3fff,
3277 data_lsb_get (&Regs[0xf6], 2));
3280 data_lsb_set (&Regs[0xe7], data_lsb_get (&Regs[0xe1], 3), 3);
3287 data_wide_bitset (&Regs[0x100], 0x3fff,
3288 data_lsb_get (&Regs[0xfa], 2));
3290 data_lsb_set (&Regs[0xe7], data_lsb_get (&Regs[0xe4], 3), 3);
3297 data_wide_bitset (&Regs[0x100], 0x3fff, stepbuffer_size);
3303 data_lsb_set (&Regs[0xe7],
3318 data_wide_bitset (&Regs[0x100], 0x3fff, 0);
3319 data_lsb_set (&Regs[0xe7], 16, 3);
3330 data_wide_bitset (&Regs[0x102], 0x3fff,
3331 data_lsb_get (&Regs[0xf8], 2));
3333 data_lsb_set (&Regs[0xf3], data_lsb_get (&Regs[0xe4], 3), 3);
3340 data_wide_bitset (&Regs[0x102], 0x3fff,
3341 data_lsb_get (&Regs[0xfe], 2));
3343 data_lsb_set (&Regs[0xf3], data_lsb_get (&Regs[0xf0], 3), 3);
3350 data_wide_bitset (&Regs[0x102], 0x3fff,
3351 data_lsb_get (&Regs[0xfe], 2));
3353 data_lsb_set (&Regs[0xf3], data_lsb_get (&Regs[0xed], 3), 3);
3360 data_wide_bitset (&Regs[0x102], 0x3fff, stepbuffer_size);
3366 data_lsb_set (&Regs[0xf3],
3382 data_wide_bitset (&Regs[0x102], 0x3fff, 0);
3383 data_lsb_set (&Regs[0xf3], 16, 3);
3398 data_lsb_get (&Regs[0x0f6], 2) & 0x3fff, data_lsb_get (&Regs[0x0e1],
3401 data_lsb_get (&Regs[0x0fa], 2) & 0x3fff, data_lsb_get (&Regs[0x0e4],
3404 data_lsb_get (&Regs[0x100], 2) & 0x3fff, data_lsb_get (&Regs[0x0e7],
3407 data_lsb_get (&Regs[0x0fe], 2) & 0x3fff, data_lsb_get (&Regs[0x0ed],
3410 data_lsb_get (&Regs[0x0fc], 2) & 0x3fff, data_lsb_get (&Regs[0x0f0],
3413 data_lsb_get (&Regs[0x102], 2) & 0x3fff, data_lsb_get (&Regs[0x0f3],
3416 data_lsb_get (&Regs[0x0f8], 2) & 0x3fff, data_lsb_get (&Regs[0x0ea],
3427 SetLock (dev->usb_handle, Regs, TRUE);
3433 SetLock (dev->usb_handle, Regs, FALSE);
3528 RTS_Setup_RefVoltages (struct st_device *dev, SANE_Byte * Regs)
3534 if (Regs != NULL)
3541 data_bitset (&Regs[0x14], 0xe0, vrts); /*xxx----- */
3544 data_bitset (&Regs[0x15], 0xe0, vrms); /*xxx----- */
3547 data_bitset (&Regs[0x16], 0xe0, vrbs); /*xxx----- */
3805 Head_IsAtHome (struct st_device *dev, SANE_Byte * Regs)
3814 if (Regs != NULL)
3819 Regs[0x16f] = _B0 (data);
3832 RTS_IsExecuting (struct st_device *dev, SANE_Byte * Regs)
3840 if (Regs != NULL)
3845 Regs[0x00] = data;
3884 RTS_Enable_CCD (struct st_device *dev, SANE_Byte * Regs, SANE_Int channels)
3888 DBG (DBG_FNC, "+ RTS_Enable_CCD(*Regs, arg2=%i):\n", channels);
3890 if (Read_Buffer (dev->usb_handle, 0xe810, &Regs[0x10], 4) == OK)
3892 data_bitset (&Regs[0x10], 0xe0, channels); /*xxx----- */
3893 data_bitset (&Regs[0x13], 0x80, channels >> 3); /*x------- */
3895 Write_Buffer (dev->usb_handle, 0xe810, &Regs[0x10], 4);
4359 RTS_DMA_CheckType (struct st_device *dev, SANE_Byte * Regs)
4366 DBG (DBG_FNC, "+ RTS_DMA_CheckType(*Regs):\n");
4368 if (Regs != NULL)
4400 if (RTS_DMA_SetType (dev, Regs, a) != OK)
4480 Regs[0x708] &= 0x1f;
4481 Regs[0x708] |= 0x80;
4484 Regs[0x708] &= 0x1f;
4485 Regs[0x708] |= 0x60;
4488 Regs[0x708] &= 0x1f;
4489 Regs[0x708] |= 0x40;
4492 Regs[0x708] &= 0x1f;
4493 Regs[0x708] |= 0x20;
4496 Regs[0x708] &= 0x1f;
4500 Regs[0x708] &= 0x1f;
4508 Regs[0x708] >> 5);
4510 RTS_DMA_SetType (dev, Regs, Regs[0x708] >> 5);
4533 RTS_DMA_SetType (struct st_device *dev, SANE_Byte * Regs, SANE_Byte ramtype)
4537 DBG (DBG_FNC, "+ RTS_DMA_SetType(*Regs, ramtype=%i):\n", ramtype);
4539 if (Regs != NULL)
4541 data_bitset (&Regs[0x708], 0x08, 0); /*----0---*/
4543 if (Write_Byte (dev->usb_handle, 0xef08, Regs[0x708]) == OK)
4545 data_bitset (&Regs[0x708], 0xe0, ramtype);
4547 if (Write_Byte (dev->usb_handle, 0xef08, Regs[0x708]) == OK)
4549 data_bitset (&Regs[0x708], 0x08, 1); /*----1---*/
4550 rst = Write_Byte (dev->usb_handle, 0xef08, Regs[0x708]);
4712 Gamma_Apply (struct st_device *dev, SANE_Byte * Regs,
4718 DBG (DBG_FNC, "+ Gamma_Apply(*Regs, *scancfg, *hwdcfg, *mygamma):\n");
4782 Write_Byte (dev->usb_handle, 0xee0b, Regs[0x060b] & 0xaf);
4783 rst = Gamma_SendTables (dev, Regs, gammabuffer, buffersize);
4784 Write_Byte (dev->usb_handle, 0xee0b, Regs[0x060b]);
5028 Timing_SetLinearImageSensorClock (SANE_Byte * Regs, struct st_cph *cph)
5033 "+ Timing_SetLinearImageSensorClock(SANE_Byte *Regs, struct st_cph *cph)\n");
5037 if ((Regs != NULL) && (cph != NULL))
5039 Regs[0x00] = get_byte (cph->p1);
5040 Regs[0x01] = get_byte (get_shrd (cph->p1, 0x08));
5041 Regs[0x02] = get_byte (get_shrd (cph->p1, 0x10));
5042 Regs[0x03] = get_byte (get_shrd (cph->p1, 0x18));
5044 Regs[0x04] &= 0x80;
5045 Regs[0x04] |= ((get_byte (get_shrd (cph->p1, 0x20))) & 0x0f);
5046 Regs[0x04] |= ((cph->ps & 1) << 6);
5047 Regs[0x04] |= ((cph->ge & 1) << 5);
5048 Regs[0x04] |= ((cph->go & 1) << 4);
5050 Regs[0x05] = get_byte (cph->p2);
5051 Regs[0x06] = get_byte (get_shrd (cph->p2, 0x08));
5052 Regs[0x07] = get_byte (get_shrd (cph->p2, 0x10));
5053 Regs[0x08] = get_byte (get_shrd (cph->p2, 0x18));
5054 Regs[0x09] &= 0xf0;
5055 Regs[0x09] |= ((get_byte (get_shrd (cph->p2, 0x20))) & 0x0f);
5067 SANE_Byte * Regs)
5069 DBG (DBG_FNC, "+ RTS_Setup_SensorTiming(mytiming=%i, *Regs):\n", mytiming);
5071 if ((Regs != NULL) && (mytiming < dev->timings_count))
5080 data_bitset (&Regs[0x92], 0x3f, mt->cdss[0]);
5081 data_bitset (&Regs[0x93], 0x3f, mt->cdsc[0]);
5082 data_bitset (&Regs[0x94], 0x3f, mt->cdss[1]);
5083 data_bitset (&Regs[0x95], 0x3f, mt->cdsc[1]);
5085 data_bitset (&Regs[0x96], 0x3f, mt->cnpp);
5088 data_bitset (&Regs[0x45], 0x80, mt->cvtrp[0]);
5089 data_bitset (&Regs[0x45], 0x40, mt->cvtrp[1]);
5090 data_bitset (&Regs[0x45], 0x20, mt->cvtrp[2]);
5092 data_bitset (&Regs[0x45], 0x1f, mt->cvtrfpw);
5093 data_bitset (&Regs[0x46], 0x1f, mt->cvtrbpw);
5095 data_lsb_set (&Regs[0x47], mt->cvtrw, 1);
5097 data_lsb_set (&Regs[0x84], mt->cphbp2s, 3);
5098 data_lsb_set (&Regs[0x87], mt->cphbp2e, 3);
5100 data_lsb_set (&Regs[0x8a], mt->clamps, 3);
5101 data_lsb_set (&Regs[0x8d], mt->clampe, 3);
5106 data_lsb_set (&Regs[0x8d], mt->cphbp2e, 3);
5109 Regs[0x97] = get_byte (mt->adcclkp[0]);
5110 Regs[0x98] = get_byte (get_shrd (mt->adcclkp[0], 0x08));
5111 Regs[0x99] = get_byte (get_shrd (mt->adcclkp[0], 0x10));
5112 Regs[0x9a] = get_byte (get_shrd (mt->adcclkp[0], 0x18));
5113 Regs[0x9b] &= 0xf0;
5114 Regs[0x9b] |= ((get_byte (get_shrd (mt->adcclkp[0], 0x20))) & 0x0f);
5116 Regs[0xc1] = get_byte (mt->adcclkp[1]);
5117 Regs[0xc2] = get_byte (get_shrd (mt->adcclkp[1], 0x08));
5118 Regs[0xc3] = get_byte (get_shrd (mt->adcclkp[1], 0x10));
5119 Regs[0xc4] = get_byte (get_shrd (mt->adcclkp[1], 0x18));
5120 Regs[0xc5] &= 0xe0;
5121 Regs[0xc5] |= ((get_byte (get_shrd (mt->adcclkp[1], 0x20))) & 0x0f);
5124 Regs[0xc5] |= ((mt->adcclkp2e & 1) << 4);
5126 Timing_SetLinearImageSensorClock (&Regs[0x48], &mt->cph[0]);
5127 Timing_SetLinearImageSensorClock (&Regs[0x52], &mt->cph[1]);
5128 Timing_SetLinearImageSensorClock (&Regs[0x5c], &mt->cph[2]);
5129 Timing_SetLinearImageSensorClock (&Regs[0x66], &mt->cph[3]);
5130 Timing_SetLinearImageSensorClock (&Regs[0x70], &mt->cph[4]);
5131 Timing_SetLinearImageSensorClock (&Regs[0x7a], &mt->cph[5]);
5163 SetMultiExposure (struct st_device *dev, SANE_Byte * Regs)
5170 data_bitset (&Regs[0xdf], 0x10, 0); /*---0----*/
5173 switch (Regs[0x00] & 0x0f)
5214 iValue /= ((Regs[0x96] & 0x3f) + 1);
5218 myctpc = data_lsb_get (&Regs[0x30], 3) + 1;
5223 if (data_lsb_get (&Regs[0xe1], 3) < iValue)
5226 SANE_Int step_size = _B0 (Regs[0xe0]) + 1;
5229 if (data_lsb_get (&Regs[0x36], 3) == 0)
5230 data_lsb_set (&Regs[0x36], myctpc - 1, 3);
5233 if (data_lsb_get (&Regs[0x3c], 3) == 0)
5234 data_lsb_set (&Regs[0x3c], myctpc - 1, 3);
5237 if (data_lsb_get (&Regs[0x42], 3) == 0)
5238 data_lsb_set (&Regs[0x42], myctpc - 1, 3);
5244 data_lsb_set (&Regs[0x30], traget - 1, 3);
5247 data_lsb_set (&Regs[0x00e1], traget, 3);
5416 Lamp_SetGainMode (struct st_device *dev, SANE_Byte * Regs,
5419 DBG (DBG_FNC, "> Lamp_SetGainMode(*Regs, resolution=%i, gainmode=%i):\n",
5427 data1 = data_lsb_get (&Regs[0x154], 2) & 0xfe7f;
5428 data2 = data_lsb_get (&Regs[0x156], 2);
5448 data_lsb_set (&Regs[0x154], data1, 2);
5449 data_lsb_set (&Regs[0x156], data2, 2);
5456 data = data_lsb_get (&Regs[0x154], 2) & 0xfe7f;
5478 data_lsb_set (&Regs[0x0154], data, 2);
6196 Gamma_SendTables (struct st_device *dev, SANE_Byte * Regs,
6201 DBG (DBG_FNC, "+ Gamma_SendTables(*Regs, *gammatable, size=%i):\n", size);
6212 SetLock (dev->usb_handle, Regs, TRUE);
6214 first_table = (data_lsb_get (&Regs[0x1b4], 2) & 0x3fff) >> 4;
6267 SetLock (dev->usb_handle, Regs, FALSE);
7957 Lamp_Warmup (struct st_device *dev, SANE_Byte * Regs, SANE_Int lamp,
7962 DBG (DBG_FNC, "+ Lamp_Warmup(*Regs, lamp=%i, resolution=%i)\n", lamp,
7965 if (Regs != NULL)
7980 Lamp_Status_Set (dev, Regs, TRUE, FLB_LAMP);
7994 Lamp_Status_Set (dev, Regs, FALSE, TMA_LAMP);
8061 SANE_Byte Regs[RT_BUFFER_LEN], mlock;
8068 memcpy (&Regs, dev->init_regs, RT_BUFFER_LEN * sizeof (SANE_Byte));
8080 while ((Head_IsAtHome (dev, Regs) == FALSE)
8094 Refs_Set (dev, Regs, &scancfg);
8104 (dev, Regs, (scancfg.scantype == ST_NORMAL) ? FLB_LAMP : TMA_LAMP,
8117 if (Calib_BlackShading_jkd(dev, Regs, &myCalib, &scancfg) == OK)
8122 if (Calib_test(dev, Regs, &myCalib, &scancfg) == OK )
8128 if (WShading_Calibrate (dev, Regs, &myCalib, &scancfg) == OK)
8146 memcpy (&Regs, dev->init_regs,
8149 if (Calibration (dev, Regs, &scancfg, &myCalib, 0) != OK)
8356 RTS_Setup (dev, Regs, &scancfg, &hwdcfg, &calibdata->gain_offset);
8368 RTS_WriteRegs (dev->usb_handle, Regs);
8371 Gamma_Apply (dev, Regs, &scancfg, &hwdcfg, hp_gamma);
8373 Shading_apply (dev, Regs, &scancfg, &myCalib);
8380 RTS_Setup (dev, Regs, &scancfg, &hwdcfg, default_gain_offset);
8390 data_lsb_set (&Regs[0x1a0], binarythresholdh, 2);
8393 data_lsb_set (&Regs[0x19e], binarythresholdl, 2);
8396 if ((Regs[0xdf] & 0x10) != 0)
8397 data_bitset (&Regs[0x01], 0x02, 1);
8401 data_bitset (&Regs[0x00], 0x10, mlock); /*---x----*/
8404 Motor_Change (dev, Regs,
8408 Lamp_SetGainMode (dev, Regs, scancfg.resolution_x,
8421 /* prueba(Regs);
8422 dbg_registers(Regs);*/
8423 /*WShading_Calibrate(dev, Regs, &myCalib, &scancfg); */
8424 /*shadingtest1(dev, Regs, &myCalib); */
8429 RTS_WriteRegs (dev->usb_handle, Regs);
8452 RTS_Setup_Motor (struct st_device *dev, SANE_Byte * Regs,
8457 DBG (DBG_FNC, "+ RTS_Setup_Motor(*Regs, *scancfg, somevalue=%i):\n",
8461 if ((Regs != NULL) && (scancfg != NULL))
8479 data_bitset (&Regs[0xd9], 0x70, sm->scanmotorsteptype); /*-xxx----*/
8482 data_bitset (&Regs[0xd9], 0x80, somevalue >> 3); /*e------- */
8485 data_bitset (&Regs[0xd9], 0x0f, somevalue); /*----efgh*/
8488 data_bitset (&Regs[0xdd], 0x80, somevalue >> 4); /*d------- */
8491 data_bitset (&Regs[0xdd], 0x40, somevalue >> 4); /*-d------*/
8514 data_bitset (&Regs[0xd6], 0xf0, dummyline); /*xxxx---- */
8517 data_bitset (&Regs[0xdf], 0x10, ((sm->motorcurve != -1) ? 1 : 0)); /*---x----*/
8520 data_lsb_set (&Regs[0xea], 0x10, 3);
8523 data_lsb_set (&Regs[0xed], 0x10, 3);
8526 data_lsb_set (&Regs[0xf0], 0x10, 3);
8529 data_lsb_set (&Regs[0xf3], 0x10, 3);
8535 data_lsb_set (&Regs[0xe0], step_size - 1, 1);
8538 myvalue = data_lsb_get (&Regs[0x30], 3);
8540 data_lsb_set (&Regs[0x30], myvalue, 3);
8544 data_lsb_set (&Regs[0xe1], myvalue, 3);
8558 lf02c = Motor_Setup_Steps (dev, Regs, sm->motorcurve);
8578 data_lsb_set (&Regs[0xe4], myvalue, 3);
8581 data_lsb_set (&Regs[0xe7], myvalue, 3);
8594 data_bitset (&Regs[0xda], 0xff, _B0 (sm->msi)); /*xxxxxxxx */
8595 data_bitset (&Regs[0xdd], 0x03, _B1 (sm->msi)); /*------xx*/
8598 data_bitset (&Regs[0xdb], 0xff, _B0 (mbs[0])); /*xxxxxxxx */
8599 data_bitset (&Regs[0xdd], 0x0c, _B1 (mbs[0])); /*----xx--*/
8602 data_bitset (&Regs[0xdc], 0xff, _B0 (mbs[1])); /*xxxxxxxx */
8603 data_bitset (&Regs[0xdd], 0x30, _B1 (mbs[1])); /*--xx----*/
8608 dummyline = data_bitget (&Regs[0xd6], 0xf0);
8627 RTS_Setup_Exposure_Times (SANE_Byte * Regs, struct st_scanparams *scancfg,
8632 if ((sm != NULL) && (Regs != NULL) && (scancfg != NULL))
8658 data_lsb_set (&Regs[0x36], sm->expt[CL_RED], 3);
8659 data_lsb_set (&Regs[0x3c], sm->expt[CL_GREEN], 3);
8660 data_lsb_set (&Regs[0x42], sm->expt[CL_BLUE], 3);
8665 data_lsb_set (&Regs[0x33], sm->mexpt[CL_RED], 3);
8666 data_lsb_set (&Regs[0x39], sm->mexpt[CL_GREEN], 3);
8667 data_lsb_set (&Regs[0x3f], sm->mexpt[CL_BLUE], 3);
8670 data_lsb_set (&Regs[0x30], linexpt, 3);
8678 RTS_Setup_Line_Distances (struct st_device *dev, SANE_Byte * Regs,
8701 data_bitset (&Regs[0x149], 0x3f, myevenodddist);
8702 data_bitset (&Regs[0x14a], 0x3f, mylinedistance);
8703 data_bitset (&Regs[0x14b], 0x3f, mylinedistance + myevenodddist);
8704 data_bitset (&Regs[0x14c], 0x3f, mylinedistance * 2);
8705 data_bitset (&Regs[0x14d], 0x3f, (mylinedistance * 2) + myevenodddist);
8710 data_bitset (&Regs[0x149], 0x3f, 0);
8711 data_bitset (&Regs[0x14a], 0x3f, 0);
8712 data_bitset (&Regs[0x14b], 0x3f, 0);
8713 data_bitset (&Regs[0x14c], 0x3f, 0);
8714 data_bitset (&Regs[0x14d], 0x3f, 0);
8755 "> RTS_Setup_Line_Distances(*Regs, *scancfg, *hwdcfg, mycolormode=%i, arrangeline=%i): %i\n",
8762 RTS_Setup_Depth (SANE_Byte * Regs, struct st_scanparams *scancfg,
8771 if ((scancfg != NULL) && (Regs != NULL))
8774 data_bitget (&Regs[0x12], 0xc0) * scancfg->coord.width;
8783 data_bitset (&Regs[0x1cf], 0x30, 3); /*--11----*/
8793 data_bitset (&Regs[0x1cf], 0x30, 2); /*--10----*/
8798 data_bitset (&Regs[0x1cf], 0x30, 1); /*--01----*/
8802 data_bitset (&Regs[0x1cf], 0x30, 0); /*--00----*/
8812 RTS_Setup_Shading (SANE_Byte * Regs, struct st_scanparams *scancfg,
8816 "> RTS_Setup_Shading(*Regs, *scancfg, *hwdcfg, bytes_per_line=%i)\n",
8819 if ((Regs != NULL) && (hwdcfg != NULL))
8825 resolution_ratio = Regs[0x0c0] & 0x1f;
8828 data_bitset (&Regs[0x1bf], 0x18, hwdcfg->unk3); /*---xx---*/
8831 data_bitset (&Regs[0x1cf], 0x08, hwdcfg->black_shading); /*----x---*/
8834 data_bitset (&Regs[0x1cf], 0x04, hwdcfg->white_shading); /*-----x--*/
8838 data_bitset (&Regs[0x1cf], 0x04, 0); /*-----x--*/
8843 if ((Regs[0x1cf] & 8) != 0)
8847 if ((Regs[0x1cf] & 4) != 0)
8850 /* Regs 0x1ba, 0x1bb, 0x1bd, 0x1c0 seem to be 4 pointers
8853 Regs[0x1ba] = 0x00;
8857 Regs[0x1bf] &= 0xfe;
8858 Regs[0x1bb] = _B0 (table_size);
8859 Regs[0x1bc] = _B1 (table_size);
8860 Regs[0x1bf] |= _B2 (table_size) & 1; /*-------x*/
8862 Regs[0x1bf] &= 0xf9;
8863 Regs[0x1bd] = _B0 (table_size * 2);
8864 Regs[0x1be] = _B1 (table_size * 2);
8865 Regs[0x1bf] |= (_B2 (table_size * 2) & 3) << 1; /*-----xx-*/
8867 data_wide_bitset (&Regs[0x1c0], 0xfffff, table_size * 3);
8870 sensor_line_distance = Regs[0x14a] & 0x3f;
8873 channels = data_lsb_get (&Regs[0x12], 1) >> 6;
8889 data_bitset (&Regs[0x1c2], 0xf0, _B2 ((myvalue / 16) + 1)); /* 4 higher bits xxxx---- */
8890 data_wide_bitset (&Regs[0x1c3], 0xffff, (myvalue / 16) + 1); /* 16 lower bits */
8893 data_wide_bitset (&Regs[0x1c5], 0xfffff, (myvalue / 16) + 1);
8903 data_bitset (&Regs[0x1c2], 0xf0, _B2 (myvalue)); /* 4 higher bits xxxx---- */
8904 data_wide_bitset (&Regs[0x1c3], 0xffff, myvalue); /* 16 lower bits */
8911 Regs[0x01c7] &= 0x0f;
8912 Regs[0x01c8] = _B0 ((mem_total - 1) / 16);
8913 Regs[0x01c9] = _B1 ((mem_total - 1) / 16);
8914 Regs[0x01c7] |= (_B2 ((mem_total - 1) / 16) & 0x0f) << 4;
8918 Regs[0x0712] &= 0x0f;
8919 Regs[0x0710] = _B0 (mem_available);
8920 Regs[0x0711] = _B1 (mem_available);
8921 Regs[0x0712] |= _B0 (_B2 (mem_available) << 4); /*xxxx---- */
8923 Regs[0x0713] = 0x00;
8924 Regs[0x0714] = 0x10;
8925 Regs[0x0715] &= 0xf0;
8948 RTS_Setup_Channels (struct st_device *dev, SANE_Byte * Regs,
8953 if ((scancfg != NULL) && (Regs != NULL))
8961 data_bitset (&Regs[0x12], 0xc0, 1); /*01------ */
8964 data_bitset (&Regs[0x12], 0x03, dev->sensorcfg->rgb_order[scancfg->channel]); /*------xx*/
8967 data_bitset (&Regs[0x60a], 0x3f, 6); /*--xxxxxx*/
8970 data_bitset (&Regs[0x1cf], 0x40, PIXEL_RATE); /*-x------*/
8973 data_bitset (&Regs[0x1cf], 0x80, 1); /*x------- */
8978 data_lsb_set (&Regs[0x33], data_lsb_get (&Regs[0x39], 3),
8982 data_lsb_set (&Regs[0x36], data_lsb_get (&Regs[0x3c], 3),
8988 data_lsb_set (&Regs[0x33], data_lsb_get (&Regs[0x3f], 3),
8992 data_lsb_set (&Regs[0x36], data_lsb_get (&Regs[0x42], 3),
9000 data_bitset (&Regs[0x12], 0xc0, 2);
9003 data_bitset (&Regs[0x12], 0x03, dev->sensorcfg->channel_gray[0]); /*------xx*/
9004 data_bitset (&Regs[0x12], 0x0c, dev->sensorcfg->channel_gray[1]); /*----xx--*/
9007 data_bitset (&Regs[0x1cf], 0x40, LINE_RATE);
9010 data_bitset (&Regs[0x1cf], 0x80, 1);
9019 data_bitset (&Regs[0x12], 0xc0, 3);
9022 data_bitset (&Regs[0x1cf], 0x40, scancfg->samplerate);
9025 data_bitset (&Regs[0x1cf], 0x80, 0);
9028 data_bitset (&Regs[0x60a], 0x03, dev->sensorcfg->channel_color[2]); /*------xx*/
9029 data_bitset (&Regs[0x60a], 0x0c, dev->sensorcfg->channel_color[1]); /*----xx--*/
9030 data_bitset (&Regs[0x60a], 0x30, dev->sensorcfg->channel_color[0]); /*--xx----*/
9033 data_bitset (&Regs[0x12], 0x03, dev->sensorcfg->rgb_order[0]); /*------xx*/
9034 data_bitset (&Regs[0x12], 0x0c, dev->sensorcfg->rgb_order[1]); /*----xx--*/
9035 data_bitset (&Regs[0x12], 0x30, dev->sensorcfg->rgb_order[2]); /*--xx----*/
9041 RTS_Setup (struct st_device *dev, SANE_Byte * Regs,
9095 data_bitset (&Regs[0x00], 0x0f, sm->systemclock);
9098 RTS_Setup_Exposure_Times (Regs, scancfg, sm);
9105 RTS_Setup_Line_Distances (dev, Regs, scancfg, hwdcfg, mycolormode,
9111 RTS_Setup_Channels (dev, Regs, scancfg, mycolormode);
9114 bytes_per_line = RTS_Setup_Depth (Regs, scancfg, mycolormode);
9121 data_bitset (&Regs[0xc0], 0x1f, resolution_ratio);
9124 RTS_Setup_SensorTiming (dev, scancfg->timing, Regs);
9126 data_bitset (&Regs[0xd8], 0x40, ((scantype == ST_NORMAL) ? 0 : 1)); /*-x------*/
9129 data_bitset (&Regs[0xd8], 0x80, ((hwdcfg->static_head == FALSE) ? 1 : 0)); /*x------- */
9132 RTS_Setup_Gamma (Regs, hwdcfg);
9135 RTS_Setup_Shading (Regs, scancfg, hwdcfg, bytes_per_line);
9139 RTS_Setup_Motor (dev, Regs, scancfg,
9143 dummyline = data_bitget (&Regs[0xd6], 0xf0);
9154 ((Regs[0x14d] & 0x3f) + scancfg->coord.height +
9160 RTS_Setup_Coords (Regs, rts_coords.left, rts_coords.top,
9163 data_bitset (&Regs[0x01], 0x06, 0); /*-----xx-*/
9166 data_bitset (&Regs[0x01], 0x10, hwdcfg->dummy_scan); /*---x----*/
9168 data_bitset (&Regs[0x163], 0xc0, 1); /*xx------ */
9172 Regs[0x60b] &= 0x8f;
9173 data_bitset (&Regs[0x60b], 0x10, 1); /*-001----*/
9176 data_bitset (&Regs[0x60b], 0x7f, 0); /*-0000000*/
9184 data_bitget (&Regs[0x12], 0xc0) * scancfg->coord.width;
9185 data_wide_bitset (&Regs[0x060c], 0x3ffff, channels_per_line);
9188 data_bitset (&Regs[0x1cf], 0x30, 2); /*--10----*/
9190 Regs[0x60b] |= 0x40;
9194 data_bitset (&Regs[0x60b], 0x10, 0); /*---0----*/
9201 Regs[0x060b] &= 0xf3;
9204 Regs[0x060b] = (Regs[0x060b] & 0xfb) | 0x08;
9209 data_bitset (&Regs[0x60b], 0x0c, 0);
9212 data_bitset (&Regs[0x1d0], 0x40, 0);
9217 RTS_Setup_GainOffset (Regs, gain_offset);
9229 RTS_Setup_Coords (SANE_Byte * Regs, SANE_Int iLeft, SANE_Int iTop,
9233 "> RTS_Setup_Coords(*Regs, iLeft=%i, iTop=%i, width=%i, height=%i)\n",
9236 if (Regs != NULL)
9239 data_lsb_set (&Regs[0xb0], iLeft, 2);
9242 data_lsb_set (&Regs[0xb2], iLeft + width, 2);
9245 data_lsb_set (&Regs[0xd0], iTop, 2);
9246 data_bitset (&Regs[0xd4], 0x0f, _B2 (iTop));
9249 data_lsb_set (&Regs[0xd2], iTop + height, 2);
9250 data_bitset (&Regs[0xd4], 0xf0, _B2 (iTop + height));
9255 RTS_Setup_GainOffset (SANE_Byte * Regs, struct st_gain_offset *gain_offset)
9262 DBG (DBG_FNC, "> RTS_Setup_GainOffset(*Regs, *gain_offset)\n");
9265 if ((Regs != NULL) && (gain_offset != NULL))
9269 data_bitset (&Regs[0x13], 0x03, gain_offset->pag[CL_RED]); /*------xx*/
9270 data_bitset (&Regs[0x13], 0x0c, gain_offset->pag[CL_GREEN]); /*----xx--*/
9271 data_bitset (&Regs[0x13], 0x30, gain_offset->pag[CL_BLUE]); /*--xx----*/
9273 memcpy (&Regs[0x14], &fake, 18);
9282 Regs[0x1a + (a * 4)] = _B0 (gain_offset->edcg1[a]);
9283 Regs[0x1b + (a * 4)] =
9286 Regs[0x1c + (a * 4)] = _B0 (gain_offset->odcg1[a]);
9287 Regs[0x1d + (a * 4)] =
9292 data_bitset (&Regs[0x14 + a], 0x1f, gain_offset->vgag1[a]);
9293 data_bitset (&Regs[0x17 + a], 0x1f, gain_offset->vgag2[a]);
9296 data_bitset (&Regs[0x13], 0x03, gain_offset->pag[CL_RED]); /*------xx*/
9297 data_bitset (&Regs[0x13], 0x0c, gain_offset->pag[CL_GREEN]); /*----xx--*/
9298 data_bitset (&Regs[0x13], 0x30, gain_offset->pag[CL_BLUE]); /*--xx----*/
9334 Calibrate_Malloc (struct st_cal2 *calbuffers, SANE_Byte * Regs,
9340 if ((calbuffers != NULL) && (Regs != NULL) && (myCalib != NULL))
9342 if ((Regs[0x1bf] & 0x18) == 0)
9344 if ((((Regs[0x1cf] >> 1) & Regs[0x1cf]) & 0x04) != 0)
9403 "> Calibrate_Malloc(*calbuffers, *Regs, *myCalib, somelength=%i): %i\n",
9536 fn3330 (struct st_device *dev, SANE_Byte * Regs, struct st_cal2 *calbuffers,
9539 /*05EEF968 04F0F7F8 |Regs = 04F0F7F8
9562 "+ fn3330(*Regs, *calbuffers, sensorchannelcolor=%i, *tablepos, data=%i):\n",
9640 (((Regs[0x1bf] >> 1) & 3) << 0x10) | (Regs[0x1be] << 0x08) |
9641 Regs[0x1bd];
9646 ((Regs[0x1bf] & 1) << 0x10) | (Regs[0x1bc] << 0x08) |
9647 Regs[0x1bb];
9651 size = _B0 (Regs[0x1ba]);
9680 fn3730 (struct st_device *dev, struct st_cal2 *calbuffers, SANE_Byte * Regs,
9684 05FEF9B0 |Regs = 04EFF7F8
9694 "+ fn3730(*calbuffers, *Regs, *table, sensorchannelcolor=%i, data=%i):\n",
9698 rst = fn3330 (dev, Regs, calbuffers, sensorchannelcolor, pos, data);
9706 Shading_white_apply (struct st_device *dev, SANE_Byte * Regs,
9715 Calibrate_Malloc (calbuffers, Regs, myCalib,
9747 (dev, calbuffers, Regs,
9768 Shading_black_apply (struct st_device *dev, SANE_Byte * Regs,
9777 Calibrate_Malloc (calbuffers, Regs, myCalib,
9810 (dev, calbuffers, Regs,
9832 Shading_apply (struct st_device *dev, SANE_Byte * Regs,
9836 Regs f1bc
9852 DBG (DBG_FNC, "+ Shading_apply(*Regs, *myvar, *mygamma, *myCalib):\n");
9855 lf9d0 = (Regs[0x60b] >> 6) & 1;
9856 lf9d1 = (Regs[0x60b] >> 4) & 1;
9857 Regs[0x060b] &= 0xaf;
9858 rst = Write_Byte (dev->usb_handle, 0xee0b, Regs[0x060b]);
9928 myShadingBase = ((Regs[0x1cf] & 2) != 0) ? 0x2000 : 0x4000;
10014 if ((Regs[0x1cf] & 8) != 0)
10015 Shading_black_apply (dev, Regs, channels, myCalib, &calbuffers);
10020 if ((Regs[0x1cf] & 4) != 0)
10021 Shading_white_apply (dev, Regs, channels, myCalib, &calbuffers);
10026 data_bitset (&Regs[0x60b], 0x40, lf9d0); /*-x------*/
10027 data_bitset (&Regs[0x60b], 0x10, lf9d1); /*---x----*/
10029 rst = Write_Byte (dev->usb_handle, 0xee0b, Regs[0x060b]);
10306 RTS_GetImage (struct st_device *dev, SANE_Byte * Regs,
10317 "+ RTS_GetImage(*Regs, *scancfg, *gain_offset, *buffer, myCalib, options=0x%08x, gaincontrol=%i):\n",
10322 if ((Regs != NULL) && (scancfg != NULL))
10347 data_bitset (&Regs[0x146], 0x40, 0);
10349 Write_Byte (dev->usb_handle, 0xe946, Regs[0x146]);
10390 RTS_Setup (dev, Regs, myscancfg, hwdcfg, gain_offset);
10412 data_lsb_set (&Regs[0x30], iValue, 3);
10414 /*Copy myregisters mexpts to Regs mexpts */
10416 data_lsb_set (&Regs[0x33], iValue, 3);
10419 data_lsb_set (&Regs[0x39], iValue, 3);
10422 data_lsb_set (&Regs[0x3f], iValue, 3);
10433 data_lsb_set (&Regs[0x30], myscancfg->expt, 3);
10434 data_lsb_set (&Regs[0x33], myscancfg->expt, 3);
10435 data_lsb_set (&Regs[0x39], myscancfg->expt, 3);
10436 data_lsb_set (&Regs[0x3f], myscancfg->expt, 3);
10438 data_lsb_set (&Regs[0x36], 0, 3);
10439 data_lsb_set (&Regs[0x3c], 0, 3);
10440 data_lsb_set (&Regs[0x42], 0, 3);
10444 1) / (data_lsb_get (&Regs[0xe0], 1) + 1)) - 1;
10445 data_lsb_set (&Regs[0xe1], myvalue, 3);
10455 SetMultiExposure (dev, Regs);
10460 SetMultiExposure (dev, Regs);
10463 RTS_WriteRegs (dev->usb_handle, Regs);
10465 Shading_apply (dev, Regs, myscancfg, myCalib);
10468 Motor_Change (dev, Regs,
10473 data_bitset (&Regs[0x00], 0x10, 0);
10475 data_wide_bitset (&Regs[0xde], 0xfff, 0);
10484 SetLock (dev->usb_handle, Regs,
10488 Lamp_SetGainMode (dev, Regs, myscancfg->resolution_x,
10492 if (RTS_WriteRegs (dev->usb_handle, Regs) == OK)
10500 SetLock (dev->usb_handle, Regs, FALSE);
10505 data_bitset (&Regs[0x146], 0x40, 1);
10507 Write_Byte (dev->usb_handle, 0xe946, Regs[0x146]);
10533 Refs_Detect (struct st_device *dev, SANE_Byte * Regs, SANE_Int resolution_x,
10538 DBG (DBG_FNC, "+ Refs_Detect(*Regs, resolution_x=%i, resolution_y=%i):\n",
10599 Lamp_Warmup (dev, Regs, FLB_LAMP, resolution_x);
10603 (dev, Regs, &scancfg, &gain_offset, image, 0, 0x20000000,
10647 Refs_Set (struct st_device *dev, SANE_Byte * Regs,
10654 DBG (DBG_FNC, "+ Refs_Set(*Regs, *scancfg):\n");
10684 (dev, Regs, refcfg.resolution, refcfg.resolution, &x, &y) == OK)
10697 (dev, Regs, refcfg.resolution, refcfg.resolution, &x,
10738 Lamp_Status_Set (struct st_device *dev, SANE_Byte * Regs, SANE_Int turn_on,
10744 DBG (DBG_FNC, "+ Lamp_Status_Set(*Regs, turn_on=%i->%s, lamp=%s)\n",
10749 if (Regs == NULL)
10751 Regs = (SANE_Byte *) malloc (RT_BUFFER_LEN * sizeof (SANE_Byte));
10753 if (Regs != NULL)
10757 if (Regs != NULL)
10759 RTS_ReadRegs (dev->usb_handle, Regs);
10768 data_bitset (&Regs[0x146], 0x20, ((lamp == TMA_LAMP) && (turn_on == TRUE)) ? 1 : 0); /* TMA */
10769 data_bitset (&Regs[0x146], 0x40, ((lamp == FLB_LAMP) && (turn_on == TRUE)) ? 1 : 0); /* FLB */
10771 data_bitset (&Regs[0x155], 0x10, (lamp != FLB_LAMP) ? 1 : 0);
10778 data_bitset (&Regs[0x146], 0x40, ((lamp - 1) | turn_on));
10780 if ((Regs[0x146] & 0x40) != 0)
10781 data_bitset (&Regs[0x155], 0x10, (lamp != FLB_LAMP) ? 1 : 0);
10787 /*dev->init_regs[0x0146] = (dev->init_regs[0x146] & 0xbf) | (Regs[0x146] & 0x40); */
10788 dev->init_regs[0x0146] = (dev->init_regs[0x146] & 0x9f) | (Regs[0x146] & 0x60); /*-xx-----*/
10791 dev->init_regs[0x0155] = Regs[0x0155];
10792 Write_Byte (dev->usb_handle, 0xe946, Regs[0x0146]);
10794 Write_Buffer (dev->usb_handle, 0xe954, &Regs[0x0154], 2);
10799 free (Regs);
10800 Regs = NULL;
10976 SANE_Byte *Regs, *image;
10981 Regs = (SANE_Byte *) malloc (RT_BUFFER_LEN * sizeof (SANE_Byte));
10982 if (Regs != NULL)
10985 memcpy (Regs, dev->init_regs, RT_BUFFER_LEN * sizeof (SANE_Byte));
10989 Regs[a] = 0;
11028 (dev, Regs, &scancfg, &gain_offset, image, 0,
11128 free (Regs);
11279 SANE_Byte *Regs;
11286 Regs = (SANE_Byte *) malloc (RT_BUFFER_LEN * sizeof (SANE_Byte));
11287 if (Regs != NULL)
11293 memcpy (Regs, dev->init_regs, RT_BUFFER_LEN * sizeof (SANE_Byte));
11307 Motor_Move (dev, Regs, &mymotor, &mtrpos);
11312 free (Regs);
11610 memcpy (myRegs, &calibdata->Regs, sizeof (SANE_Byte) * RT_BUFFER_LEN);
11905 SANE_Byte *Regs;
11917 Regs = (SANE_Byte *) malloc (RT_BUFFER_LEN * sizeof (SANE_Byte));
11918 if (Regs != NULL)
11924 memcpy (Regs, &calibdata->Regs, RT_BUFFER_LEN * sizeof (SANE_Byte));
11980 RTS_GetImage (dev, Regs, scancfg, &calibdata->gain_offset,
12051 free (Regs);
12161 SANE_Byte Regs[RT_BUFFER_LEN]; /*f1c4 */
12185 memcpy (&Regs, &calibdata->Regs, RT_BUFFER_LEN * sizeof (SANE_Byte));
12258 (dev, Regs, &scancfg, &calibdata->gain_offset, scanbuffer, 0,
12650 memcpy (myRegs, &calibdata->Regs, RT_BUFFER_LEN * sizeof (SANE_Byte));
13169 memcpy (myRegs, &calibdata->Regs, RT_BUFFER_LEN * sizeof (SANE_Byte));
13293 memcpy (&calibdata->Regs, myRegs, RT_BUFFER_LEN * sizeof (SANE_Byte));
13612 Calibration (struct st_device *dev, SANE_Byte * Regs,
13616 /*//SANE_Int Calibration([fa20]char *Regs, [fa24]struct st_scanparams *scancfg, [fa28]struct st_calibration myCalib, [fa2c]SANE_Int value)
13629 memcpy (&calibdata->Regs, Regs, sizeof (SANE_Byte) * RT_BUFFER_LEN);
14032 RTS_Setup_Gamma (SANE_Byte * Regs, struct st_hwdconfig *hwdcfg)
14034 DBG (DBG_FNC, "> RTS_Setup_Gamma(*Regs, *hwdcfg)\n");
14036 if ((hwdcfg != NULL) && (Regs != NULL))
14043 data_bitset (&Regs[0x1d0], 0x0f, hwdcfg->gamma_tablesize);
14046 data_bitset (&Regs[0x1d0], 0x40, 1);
14049 switch (Regs[0x1d0] & 0x0c)
14052 table_size = (Regs[0x1d0] & 1) | 0x0100;
14055 table_size = (Regs[0x1d0] & 1) | 0x0400;
14058 table_size = (Regs[0x1d0] & 1) | 0x1000;
14067 data_wide_bitset (&Regs[0x1b4], 0x3fff, 0);
14070 data_wide_bitset (&Regs[0x1b6], 0x3fff, table_size);
14073 data_wide_bitset (&Regs[0x1b8], 0x3fff, table_size * 2);
14080 data_bitset (&Regs[0x1d0], 0x40, 0);
14451 WShading_Calibrate (struct st_device *dev, SANE_Byte * Regs,
14486 memcpy (myRegs, Regs, RT_BUFFER_LEN * sizeof (SANE_Byte));
14674 motor_pos (struct st_device *dev, SANE_Byte * Regs,
14700 memcpy (myRegs, Regs, RT_BUFFER_LEN * sizeof (SANE_Byte));
14806 Calib_BlackShading_jkd (struct st_device *dev, SANE_Byte * Regs,
14840 memcpy (myRegs, Regs, RT_BUFFER_LEN * sizeof (SANE_Byte));
14942 Calib_test (struct st_device *dev, SANE_Byte * Regs,
14968 memcpy (myRegs, Regs, RT_BUFFER_LEN * sizeof (SANE_Byte));
15070 shadingtest1 (struct st_device *dev, SANE_Byte * Regs,
15077 DBG (DBG_FNC, "+ shadingtest1(*Regs, *myCalib):\n");
15079 if ((Regs == NULL) || (myCalib == NULL))
15084 bit[0] = (Regs[0x60b] >> 6) & 1;
15085 bit[1] = (Regs[0x60b] >> 4) & 1;
15086 Regs[0x060b] &= 0xaf;
15088 Write_Byte (dev->usb_handle, 0xee0b, Regs[0x060b]);
15090 Regs[0x1cf] = 0; /* reset config. By default black shading disabled and pixel-rate */
15091 /*Regs[0x1cf] |= 2; shadingbase 0x2000 */
15092 Regs[0x1cf] |= 4; /* White shading enabled */
15093 Regs[0x1cf] |= 0x20; /* 16 bits per channel */
15095 Write_Byte (dev->usb_handle, 0xe9cf, Regs[0x01cf]);
15112 data_bitset (&Regs[0x60b], 0x40, bit[0]); /*-x------*/
15113 data_bitset (&Regs[0x60b], 0x10, bit[1]); /*---x----*/
15115 Write_Byte (dev->usb_handle, 0xee0b, Regs[0x060b]);