1 /* sane - Scanner Access Now Easy.
2
3 Copyright (C) 2005 Mustek.
4 Originally maintained by Mustek
5 Author:Roy 2005.5.24
6
7 This file is part of the SANE package.
8
9 This program is free software; you can redistribute it and/or
10 modify it under the terms of the GNU General Public License as
11 published by the Free Software Foundation; either version 2 of the
12 License, or (at your option) any later version.
13
14 This program is distributed in the hope that it will be useful, but
15 WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
17 General Public License for more details.
18
19 You should have received a copy of the GNU General Public License
20 along with this program. If not, see <https://www.gnu.org/licenses/>.
21
22 As a special exception, the authors of SANE give permission for
23 additional uses of the libraries contained in this release of SANE.
24
25 The exception is that, if you link a SANE library with other files
26 to produce an executable, this does not by itself cause the
27 resulting executable to be covered by the GNU General Public
28 License. Your use of that executable is in no way restricted on
29 account of linking the SANE library code into it.
30
31 This exception does not, however, invalidate any other reasons why
32 the executable file might be covered by the GNU General Public
33 License.
34
35 If you submit changes to SANE to the maintainers to be included in
36 a subsequent release, you agree by submitting the changes that
37 those changes may be distributed with this exception intact.
38
39 If you write modifications of your own for SANE, it is your choice
40 whether to permit this exception to apply to your modifications.
41 If you do not wish that, delete this exception notice.
42
43 This file implements a SANE backend for the Mustek BearPaw 2448 TA Pro
44 and similar USB2 scanners. */
45
46 #include "mustek_usb2_asic.h"
47
48 /* ---------------------- low level asic functions -------------------------- */
49
50 static SANE_Byte RegisterBankStatus = -1;
51
52 static SANE_Status
WriteIOControl(PAsic chip, unsigned short wValue, unsigned short wIndex, unsigned short wLength, SANE_Byte * lpbuf)53 WriteIOControl (PAsic chip, unsigned short wValue, unsigned short wIndex, unsigned short wLength,
54 SANE_Byte * lpbuf)
55 {
56 SANE_Status status = SANE_STATUS_GOOD;
57
58 status =
59 sanei_usb_control_msg (chip->fd, 0x40, 0x01, wValue, wIndex, wLength,
60 lpbuf);
61 if (status != SANE_STATUS_GOOD)
62 {
63 DBG (DBG_ERR, "WriteIOControl Error!\n");
64 return status;
65 }
66
67 return SANE_STATUS_GOOD;
68 }
69
70 static SANE_Status
ReadIOControl(PAsic chip, unsigned short wValue, unsigned short wIndex, unsigned short wLength, SANE_Byte * lpbuf)71 ReadIOControl (PAsic chip, unsigned short wValue, unsigned short wIndex, unsigned short wLength,
72 SANE_Byte * lpbuf)
73 {
74 SANE_Status status = SANE_STATUS_GOOD;
75
76 status =
77 sanei_usb_control_msg (chip->fd, 0xc0, 0x01, wValue, wIndex, wLength,
78 lpbuf);
79 if (status != SANE_STATUS_GOOD)
80 {
81 DBG (DBG_ERR, "WriteIOControl Error!\n");
82 return status;
83 }
84
85 return status;
86 }
87
88 static SANE_Status
Mustek_ClearFIFO(PAsic chip)89 Mustek_ClearFIFO (PAsic chip)
90 {
91 SANE_Status status = SANE_STATUS_GOOD;
92 SANE_Byte buf[4];
93 DBG (DBG_ASIC, "Mustek_ClearFIFO:Enter\n");
94
95 buf[0] = 0;
96 buf[1] = 0;
97 buf[2] = 0;
98 buf[3] = 0;
99 status = WriteIOControl (chip, 0x05, 0, 4, (SANE_Byte *) (buf));
100 if (status != SANE_STATUS_GOOD)
101 return status;
102
103 status = WriteIOControl (chip, 0xc0, 0, 4, (SANE_Byte *) (buf));
104 if (status != SANE_STATUS_GOOD)
105 return status;
106
107
108 DBG (DBG_ASIC, "Mustek_ClearFIFO:Exit\n");
109 return SANE_STATUS_GOOD;
110 }
111
112
113 static SANE_Status
Mustek_SendData(PAsic chip, unsigned short reg, SANE_Byte data)114 Mustek_SendData (PAsic chip, unsigned short reg, SANE_Byte data)
115 {
116 SANE_Byte buf[4];
117 SANE_Status status = SANE_STATUS_GOOD;
118 DBG (DBG_ASIC, "Mustek_SendData: Enter. reg=%x,data=%x\n", reg, data);
119
120
121 if (reg <= 0xFF)
122 {
123 if (RegisterBankStatus != 0)
124 {
125 DBG (DBG_ASIC, "RegisterBankStatus=%d\n", RegisterBankStatus);
126 buf[0] = ES01_5F_REGISTER_BANK_SELECT;
127 buf[1] = SELECT_REGISTER_BANK0;
128 buf[2] = ES01_5F_REGISTER_BANK_SELECT;
129 buf[3] = SELECT_REGISTER_BANK0;
130 WriteIOControl (chip, 0xb0, 0, 4, buf);
131 RegisterBankStatus = 0;
132 DBG (DBG_ASIC, "RegisterBankStatus=%d\n", RegisterBankStatus);
133 }
134
135 }
136 else if (reg <= 0x1FF)
137 {
138 if (RegisterBankStatus != 1)
139 {
140 DBG (DBG_ASIC, "RegisterBankStatus=%d\n", RegisterBankStatus);
141 buf[0] = ES01_5F_REGISTER_BANK_SELECT;
142 buf[1] = SELECT_REGISTER_BANK1;
143 buf[2] = ES01_5F_REGISTER_BANK_SELECT;
144 buf[3] = SELECT_REGISTER_BANK1;
145
146 WriteIOControl (chip, 0xb0, 0, 4, buf);
147 RegisterBankStatus = 1;
148 }
149 }
150 else if (reg <= 0x2FF)
151 {
152 if (RegisterBankStatus != 2)
153 {
154 DBG (DBG_ASIC, "RegisterBankStatus=%d\n", RegisterBankStatus);
155 buf[0] = ES01_5F_REGISTER_BANK_SELECT;
156 buf[1] = SELECT_REGISTER_BANK2;
157 buf[2] = ES01_5F_REGISTER_BANK_SELECT;
158 buf[3] = SELECT_REGISTER_BANK2;
159
160 WriteIOControl (chip, 0xb0, 0, 4, buf);
161 RegisterBankStatus = 2;
162 }
163 }
164
165 buf[0] = LOBYTE (reg);
166 buf[1] = data;
167 buf[2] = LOBYTE (reg);
168 buf[3] = data;
169 status = WriteIOControl (chip, 0xb0, 0, 4, buf);
170 if (status != SANE_STATUS_GOOD)
171 DBG (DBG_ERR, ("Mustek_SendData: write error\n"));
172
173 return status;
174 }
175
176 static SANE_Status
Mustek_ReceiveData(PAsic chip, SANE_Byte * reg)177 Mustek_ReceiveData (PAsic chip, SANE_Byte * reg)
178 {
179 SANE_Status status = SANE_STATUS_GOOD;
180 SANE_Byte buf[4];
181
182 DBG (DBG_ASIC, "Mustek_ReceiveData\n");
183
184 status = ReadIOControl (chip, 0x07, 0, 4, buf);
185
186 *reg = buf[0];
187 return status;
188 }
189
190 static SANE_Status
Mustek_WriteAddressLineForRegister(PAsic chip, SANE_Byte x)191 Mustek_WriteAddressLineForRegister (PAsic chip, SANE_Byte x)
192 {
193 SANE_Status status = SANE_STATUS_GOOD;
194 SANE_Byte buf[4];
195
196 DBG (DBG_ASIC, "Mustek_WriteAddressLineForRegister: Enter\n");
197
198 buf[0] = x;
199 buf[1] = x;
200 buf[2] = x;
201 buf[3] = x;
202 status = WriteIOControl (chip, 0x04, x, 4, buf);
203
204 DBG (DBG_ASIC, "Mustek_WriteAddressLineForRegister: Exit\n");
205 return status;
206 }
207
208
209 static SANE_Status
SetRWSize(PAsic chip, SANE_Byte ReadWrite, unsigned int size)210 SetRWSize (PAsic chip, SANE_Byte ReadWrite, unsigned int size)
211 {
212 SANE_Status status = SANE_STATUS_GOOD;
213 DBG (DBG_ASIC, "SetRWSize: Enter\n");
214
215 if (ReadWrite == 0)
216 { /*write */
217 status = Mustek_SendData (chip, 0x7C, (SANE_Byte) (size));
218 if (status != SANE_STATUS_GOOD)
219 return status;
220 status = Mustek_SendData (chip, 0x7D, (SANE_Byte) (size >> 8));
221 if (status != SANE_STATUS_GOOD)
222 return status;
223 status = Mustek_SendData (chip, 0x7E, (SANE_Byte) (size >> 16));
224 if (status != SANE_STATUS_GOOD)
225 return status;
226 status = Mustek_SendData (chip, 0x7F, (SANE_Byte) (size >> 24));
227 if (status != SANE_STATUS_GOOD)
228 return status;
229 }
230 else
231 { /* read */
232 status = Mustek_SendData (chip, 0x7C, (SANE_Byte) (size >> 1));
233 if (status != SANE_STATUS_GOOD)
234 return status;
235 status = Mustek_SendData (chip, 0x7D, (SANE_Byte) (size >> 9));
236 if (status != SANE_STATUS_GOOD)
237 return status;
238 status = Mustek_SendData (chip, 0x7E, (SANE_Byte) (size >> 17));
239 if (status != SANE_STATUS_GOOD)
240 return status;
241 status = Mustek_SendData (chip, 0x7F, (SANE_Byte) (size >> 25));
242 if (status != SANE_STATUS_GOOD)
243 return status;
244 }
245
246 DBG (DBG_ASIC, "SetRWSize: Exit\n");
247 return SANE_STATUS_GOOD;
248 }
249
250 static SANE_Status
Mustek_DMARead(PAsic chip, unsigned int size, SANE_Byte * lpdata)251 Mustek_DMARead (PAsic chip, unsigned int size, SANE_Byte * lpdata)
252 {
253 SANE_Status status = SANE_STATUS_GOOD;
254 unsigned int i, buf[1];
255 unsigned int read_size;
256 size_t read_size_usb;
257
258 DBG (DBG_ASIC, "Mustek_DMARead: Enter\n");
259
260 status = Mustek_ClearFIFO (chip);
261 if (status != SANE_STATUS_GOOD)
262 return status;
263
264 buf[0] = read_size = 32 * 1024;
265 for (i = 0; i < size / (read_size); i++)
266 {
267 SetRWSize (chip, 1, buf[0]);
268 status = WriteIOControl (chip, 0x03, 0, 4, (SANE_Byte *) (buf));
269
270 read_size_usb = buf[0];
271 status =
272 sanei_usb_read_bulk (chip->fd, lpdata + i * read_size,
273 &read_size_usb);
274 buf[0] = read_size_usb;
275 if (status != SANE_STATUS_GOOD)
276 {
277 DBG (DBG_ERR, "Mustek_DMARead: read error\n");
278 return status;
279 }
280 }
281
282 buf[0] = size - i * read_size;
283 if (buf[0] > 0)
284 {
285 SetRWSize (chip, 1, buf[0]);
286 status = WriteIOControl (chip, 0x03, 0, 4, (SANE_Byte *) (buf));
287
288 read_size_usb = buf[0];
289 status =
290 sanei_usb_read_bulk (chip->fd, lpdata + i * read_size,
291 &read_size_usb);
292 buf[0] = read_size_usb;
293 if (status != SANE_STATUS_GOOD)
294 {
295 DBG (DBG_ERR, "Mustek_DMARead: read error\n");
296 return status;
297 }
298
299 usleep (20000);
300 }
301
302 DBG (DBG_ASIC, "Mustek_DMARead: Exit\n");
303 return SANE_STATUS_GOOD;
304 }
305
306 static SANE_Status
Mustek_DMAWrite(PAsic chip, unsigned int size, SANE_Byte * lpdata)307 Mustek_DMAWrite (PAsic chip, unsigned int size, SANE_Byte * lpdata)
308 {
309 SANE_Status status = SANE_STATUS_GOOD;
310 unsigned int buf[1];
311 unsigned int i;
312 unsigned int write_size;
313 size_t write_size_usb;
314
315 DBG (DBG_ASIC, "Mustek_DMAWrite: Enter:size=%d\n", size);
316
317 status = Mustek_ClearFIFO (chip);
318 if (status != SANE_STATUS_GOOD)
319 return status;
320
321 buf[0] = write_size = 32 * 1024;
322 for (i = 0; i < size / (write_size); i++)
323 {
324 SetRWSize (chip, 0, buf[0]);
325 WriteIOControl (chip, 0x02, 0, 4, (SANE_Byte *) buf);
326
327 write_size_usb = buf[0];
328 status =
329 sanei_usb_write_bulk (chip->fd, lpdata + i * write_size,
330 &write_size_usb);
331 buf[0] = write_size_usb;
332 if (status != SANE_STATUS_GOOD)
333 {
334 DBG (DBG_ERR, "Mustek_DMAWrite: write error\n");
335 return status;
336 }
337 }
338
339
340 buf[0] = size - i * write_size;
341 if (buf[0] > 0)
342 {
343 SetRWSize (chip, 0, buf[0]);
344 WriteIOControl (chip, 0x02, 0, 4, (SANE_Byte *) buf);
345
346 write_size_usb = buf[0];
347 status =
348 sanei_usb_write_bulk (chip->fd, lpdata + i * write_size,
349 &write_size_usb);
350 buf[0] = write_size_usb;
351 if (status != SANE_STATUS_GOOD)
352 {
353 DBG (DBG_ERR, "Mustek_DMAWrite: write error\n");
354 return status;
355 }
356 }
357
358 Mustek_ClearFIFO (chip);
359
360 DBG (DBG_ASIC, "Mustek_DMAWrite: Exit\n");
361 return SANE_STATUS_GOOD;
362 }
363
364
365 static SANE_Status
Mustek_SendData2Byte(PAsic chip, unsigned short reg, SANE_Byte data)366 Mustek_SendData2Byte (PAsic chip, unsigned short reg, SANE_Byte data)
367 {
368 static SANE_Bool isTransfer = FALSE;
369 static SANE_Byte BankBuf[4];
370 static SANE_Byte DataBuf[4];
371
372 if (reg <= 0xFF)
373 {
374 if (RegisterBankStatus != 0)
375 {
376 DBG (DBG_ASIC, "RegisterBankStatus=%d\n", RegisterBankStatus);
377 BankBuf[0] = ES01_5F_REGISTER_BANK_SELECT;
378 BankBuf[1] = SELECT_REGISTER_BANK0;
379 BankBuf[2] = ES01_5F_REGISTER_BANK_SELECT;
380 BankBuf[3] = SELECT_REGISTER_BANK0;
381 WriteIOControl (chip, 0xb0, 0, 4, BankBuf);
382
383 RegisterBankStatus = 0;
384 }
385 }
386 else if (reg <= 0x1FF)
387 {
388 if (RegisterBankStatus != 1)
389 {
390 DBG (DBG_ASIC, "RegisterBankStatus=%d\n", RegisterBankStatus);
391 BankBuf[0] = ES01_5F_REGISTER_BANK_SELECT;
392 BankBuf[1] = SELECT_REGISTER_BANK1;
393 BankBuf[2] = ES01_5F_REGISTER_BANK_SELECT;
394
395 BankBuf[3] = SELECT_REGISTER_BANK1;
396 WriteIOControl (chip, 0xb0, 0, 4, BankBuf);
397 RegisterBankStatus = 1;
398 }
399 }
400 else if (reg <= 0x2FF)
401 {
402 if (RegisterBankStatus != 2)
403 {
404 DBG (DBG_ASIC, "RegisterBankStatus=%d\n", RegisterBankStatus);
405 BankBuf[0] = ES01_5F_REGISTER_BANK_SELECT;
406 BankBuf[1] = SELECT_REGISTER_BANK2;
407 BankBuf[2] = ES01_5F_REGISTER_BANK_SELECT;
408 BankBuf[3] = SELECT_REGISTER_BANK2;
409 WriteIOControl (chip, 0xb0, 0, 4, BankBuf);
410 RegisterBankStatus = 2;
411 }
412 }
413
414 if (isTransfer == FALSE)
415 {
416 DataBuf[0] = LOBYTE (reg);
417 DataBuf[1] = data;
418 isTransfer = TRUE;
419 }
420 else
421 {
422 DataBuf[2] = LOBYTE (reg);
423 DataBuf[3] = data;
424 WriteIOControl (chip, 0xb0, 0, 4, DataBuf);
425 isTransfer = FALSE;
426 }
427
428 return SANE_STATUS_GOOD;
429 }
430
431
432
433 /* ---------------------- asic motor functions ----------------------------- */
434
435 static SANE_Status
LLFRamAccess(PAsic chip, LLF_RAMACCESS * RamAccess)436 LLFRamAccess (PAsic chip, LLF_RAMACCESS * RamAccess)
437 {
438 SANE_Status status = SANE_STATUS_GOOD;
439 SANE_Byte a[2];
440
441 DBG (DBG_ASIC, "LLFRamAccess:Enter\n");
442
443 /*Set start address. Unit is a word. */
444 Mustek_SendData (chip, ES01_A0_HostStartAddr0_7,
445 LOBYTE (RamAccess->LoStartAddress));
446
447 if (RamAccess->IsOnChipGamma == ON_CHIP_FINAL_GAMMA)
448 { /* final gamma */
449 Mustek_SendData (chip, ES01_A1_HostStartAddr8_15,
450 HIBYTE (RamAccess->LoStartAddress));
451 Mustek_SendData (chip, ES01_A2_HostStartAddr16_21,
452 LOBYTE (RamAccess->HiStartAddress) | ACCESS_GAMMA_RAM);
453 }
454 else if (RamAccess->IsOnChipGamma == ON_CHIP_PRE_GAMMA)
455 { /* pre gamma */
456 Mustek_SendData (chip, ES01_A1_HostStartAddr8_15,
457 HIBYTE (RamAccess->
458 LoStartAddress) | ES01_ACCESS_PRE_GAMMA);
459 Mustek_SendData (chip, ES01_A2_HostStartAddr16_21,
460 LOBYTE (RamAccess->HiStartAddress) | ACCESS_GAMMA_RAM);
461 }
462 else
463 { /* dram */
464 Mustek_SendData (chip, ES01_A1_HostStartAddr8_15,
465 HIBYTE (RamAccess->LoStartAddress));
466 Mustek_SendData (chip, ES01_A2_HostStartAddr16_21,
467 LOBYTE (RamAccess->HiStartAddress) | ACCESS_DRAM);
468 }
469
470 /* set SDRAM delay time */
471 Mustek_SendData (chip, ES01_79_AFEMCLK_SDRAMCLK_DELAY_CONTROL,
472 SDRAMCLK_DELAY_12_ns);
473
474 /*Set end address. Unit is a word. */
475 Mustek_SendData (chip, ES01_A3_HostEndAddr0_7, 0xff);
476 Mustek_SendData (chip, ES01_A4_HostEndAddr8_15, 0xff);
477 Mustek_SendData (chip, ES01_A5_HostEndAddr16_21, 0xff);
478 Mustek_ClearFIFO (chip);
479
480 if (RamAccess->ReadWrite == WRITE_RAM)
481 { /*Write RAM */
482 Mustek_DMAWrite (chip, RamAccess->RwSize, RamAccess->BufferPtr); /* read-write size must be even */
483
484 /*steal read 2byte */
485 usleep (20000);
486 RamAccess->RwSize = 2;
487 RamAccess->BufferPtr = (SANE_Byte *) a;
488 RamAccess->ReadWrite = READ_RAM;
489 LLFRamAccess (chip, RamAccess);
490 DBG (DBG_ASIC, "end steal 2 byte!\n");
491 }
492 else
493 { /* Read RAM */
494 Mustek_DMARead (chip, RamAccess->RwSize, RamAccess->BufferPtr); /* read-write size must be even */
495 }
496
497 DBG (DBG_ASIC, "LLFRamAccess:Exit\n");
498 return status;
499 }
500
501
502 static SANE_Status
LLFSetMotorCurrentAndPhase(PAsic chip, LLF_MOTOR_CURRENT_AND_PHASE * MotorCurrentAndPhase)503 LLFSetMotorCurrentAndPhase (PAsic chip,
504 LLF_MOTOR_CURRENT_AND_PHASE *
505 MotorCurrentAndPhase)
506 {
507 SANE_Status status = SANE_STATUS_GOOD;
508 SANE_Byte MotorPhase;
509
510 DBG (DBG_ASIC, "LLFSetMotorCurrentAndPhase:Enter\n");
511
512 if (MotorCurrentAndPhase->MotorDriverIs3967 == 1)
513 {
514 MotorPhase = 0xFE;
515 }
516 else
517 {
518 MotorPhase = 0xFF;
519 }
520
521 DBG (DBG_ASIC, "MotorPhase=0x%x\n", MotorPhase);
522 Mustek_SendData (chip, ES02_50_MOTOR_CURRENT_CONTORL, 0x01);
523
524 if (MotorCurrentAndPhase->FillPhase == 0)
525 {
526 Mustek_SendData (chip, ES01_AB_PWM_CURRENT_CONTROL, 0x00);
527
528 Mustek_SendData2Byte (chip, ES02_52_MOTOR_CURRENT_TABLE_A,
529 MotorCurrentAndPhase->MotorCurrentTableA[0]);
530 Mustek_SendData2Byte (chip, ES02_53_MOTOR_CURRENT_TABLE_B,
531 MotorCurrentAndPhase->MotorCurrentTableB[0]);
532 Mustek_SendData2Byte (chip, ES02_51_MOTOR_PHASE_TABLE_1,
533 0x08 & MotorPhase);
534
535 /*2 */
536 Mustek_SendData2Byte (chip, ES02_52_MOTOR_CURRENT_TABLE_A,
537 MotorCurrentAndPhase->MotorCurrentTableA[0]);
538 Mustek_SendData2Byte (chip, ES02_53_MOTOR_CURRENT_TABLE_B,
539 MotorCurrentAndPhase->MotorCurrentTableB[0]);
540 Mustek_SendData2Byte (chip, ES02_51_MOTOR_PHASE_TABLE_1,
541 0x09 & MotorPhase);
542
543 /*3 */
544 Mustek_SendData2Byte (chip, ES02_52_MOTOR_CURRENT_TABLE_A,
545 MotorCurrentAndPhase->MotorCurrentTableA[0]);
546 Mustek_SendData2Byte (chip, ES02_53_MOTOR_CURRENT_TABLE_B,
547 MotorCurrentAndPhase->MotorCurrentTableB[0]);
548 Mustek_SendData2Byte (chip, ES02_51_MOTOR_PHASE_TABLE_1,
549 0x01 & MotorPhase);
550
551 /*4 */
552 Mustek_SendData2Byte (chip, ES02_52_MOTOR_CURRENT_TABLE_A,
553 MotorCurrentAndPhase->MotorCurrentTableA[0]);
554 Mustek_SendData2Byte (chip, ES02_53_MOTOR_CURRENT_TABLE_B,
555 MotorCurrentAndPhase->MotorCurrentTableB[0]);
556 Mustek_SendData2Byte (chip, ES02_51_MOTOR_PHASE_TABLE_1,
557 0x00 & MotorPhase);
558 }
559 else
560 {
561 if (MotorCurrentAndPhase->MoveType == _4_TABLE_SPACE_FOR_FULL_STEP)
562 { /* Full Step */
563 Mustek_SendData (chip, ES01_AB_PWM_CURRENT_CONTROL, 0x00);
564
565 /*1 */
566 Mustek_SendData2Byte (chip, ES02_52_MOTOR_CURRENT_TABLE_A,
567 MotorCurrentAndPhase->MotorCurrentTableA[0]);
568 Mustek_SendData2Byte (chip, ES02_53_MOTOR_CURRENT_TABLE_B,
569 MotorCurrentAndPhase->MotorCurrentTableB[0]);
570 Mustek_SendData2Byte (chip, ES02_51_MOTOR_PHASE_TABLE_1,
571 0x08 & MotorPhase);
572
573 /*2 */
574 Mustek_SendData2Byte (chip, ES02_52_MOTOR_CURRENT_TABLE_A,
575 MotorCurrentAndPhase->MotorCurrentTableA[0]);
576 Mustek_SendData2Byte (chip, ES02_53_MOTOR_CURRENT_TABLE_B,
577 MotorCurrentAndPhase->MotorCurrentTableB[0]);
578 Mustek_SendData2Byte (chip, ES02_51_MOTOR_PHASE_TABLE_1,
579 0x09 & MotorPhase);
580
581 /*3 */
582 Mustek_SendData2Byte (chip, ES02_52_MOTOR_CURRENT_TABLE_A,
583 MotorCurrentAndPhase->MotorCurrentTableA[0]);
584 Mustek_SendData2Byte (chip, ES02_53_MOTOR_CURRENT_TABLE_B,
585 MotorCurrentAndPhase->MotorCurrentTableB[0]);
586 Mustek_SendData2Byte (chip, ES02_51_MOTOR_PHASE_TABLE_1,
587 0x01 & MotorPhase);
588
589 /*4 */
590 Mustek_SendData2Byte (chip, ES02_52_MOTOR_CURRENT_TABLE_A,
591 MotorCurrentAndPhase->MotorCurrentTableA[0]);
592 Mustek_SendData2Byte (chip, ES02_53_MOTOR_CURRENT_TABLE_B,
593 MotorCurrentAndPhase->MotorCurrentTableB[0]);
594 Mustek_SendData2Byte (chip, ES02_51_MOTOR_PHASE_TABLE_1,
595 0x00 & MotorPhase);
596 }
597 else if (MotorCurrentAndPhase->MoveType ==
598 _8_TABLE_SPACE_FOR_1_DIV_2_STEP)
599 { /* Half Step */
600 Mustek_SendData (chip, ES01_AB_PWM_CURRENT_CONTROL, 0x01);
601
602 /*1 */
603 Mustek_SendData2Byte (chip, ES02_52_MOTOR_CURRENT_TABLE_A,
604 MotorCurrentAndPhase->MotorCurrentTableA[0]);
605 Mustek_SendData2Byte (chip, ES02_53_MOTOR_CURRENT_TABLE_B,
606 MotorCurrentAndPhase->MotorCurrentTableB[0]);
607 Mustek_SendData2Byte (chip, ES02_51_MOTOR_PHASE_TABLE_1,
608 0x25 & MotorPhase);
609
610 /*2 */
611 Mustek_SendData2Byte (chip, ES02_52_MOTOR_CURRENT_TABLE_A,
612 MotorCurrentAndPhase->MotorCurrentTableA[0]);
613 Mustek_SendData2Byte (chip, ES02_53_MOTOR_CURRENT_TABLE_B,
614 MotorCurrentAndPhase->MotorCurrentTableB[0]);
615 Mustek_SendData2Byte (chip, ES02_51_MOTOR_PHASE_TABLE_1,
616 0x07 & MotorPhase);
617
618 /*3 */
619 Mustek_SendData2Byte (chip, ES02_52_MOTOR_CURRENT_TABLE_A,
620 MotorCurrentAndPhase->MotorCurrentTableA[0]);
621 Mustek_SendData2Byte (chip, ES02_53_MOTOR_CURRENT_TABLE_B,
622 MotorCurrentAndPhase->MotorCurrentTableB[0]);
623 Mustek_SendData2Byte (chip, ES02_51_MOTOR_PHASE_TABLE_1,
624 0x24 & MotorPhase);
625
626 /*4 */
627 Mustek_SendData2Byte (chip, ES02_52_MOTOR_CURRENT_TABLE_A,
628 MotorCurrentAndPhase->MotorCurrentTableA[0]);
629 Mustek_SendData2Byte (chip, ES02_53_MOTOR_CURRENT_TABLE_B,
630 MotorCurrentAndPhase->MotorCurrentTableB[0]);
631 Mustek_SendData2Byte (chip, ES02_51_MOTOR_PHASE_TABLE_1,
632 0x30 & MotorPhase);
633
634 /*5 */
635 Mustek_SendData2Byte (chip, ES02_52_MOTOR_CURRENT_TABLE_A,
636 MotorCurrentAndPhase->MotorCurrentTableA[0]);
637 Mustek_SendData2Byte (chip, ES02_53_MOTOR_CURRENT_TABLE_B,
638 MotorCurrentAndPhase->MotorCurrentTableB[0]);
639 Mustek_SendData2Byte (chip, ES02_51_MOTOR_PHASE_TABLE_1,
640 0x2c & MotorPhase);
641
642 /*6 */
643 Mustek_SendData2Byte (chip, ES02_52_MOTOR_CURRENT_TABLE_A,
644 MotorCurrentAndPhase->MotorCurrentTableA[0]);
645 Mustek_SendData2Byte (chip, ES02_53_MOTOR_CURRENT_TABLE_B,
646 MotorCurrentAndPhase->MotorCurrentTableB[0]);
647 Mustek_SendData2Byte (chip, ES02_51_MOTOR_PHASE_TABLE_1,
648 0x0e & MotorPhase);
649
650 /*7 */
651 Mustek_SendData2Byte (chip, ES02_52_MOTOR_CURRENT_TABLE_A,
652 MotorCurrentAndPhase->MotorCurrentTableA[0]);
653 Mustek_SendData2Byte (chip, ES02_53_MOTOR_CURRENT_TABLE_B,
654 MotorCurrentAndPhase->MotorCurrentTableB[0]);
655 Mustek_SendData2Byte (chip, ES02_51_MOTOR_PHASE_TABLE_1,
656 0x2d & MotorPhase);
657
658 /*8 */
659 Mustek_SendData2Byte (chip, ES02_52_MOTOR_CURRENT_TABLE_A,
660 MotorCurrentAndPhase->MotorCurrentTableA[0]);
661 Mustek_SendData2Byte (chip, ES02_53_MOTOR_CURRENT_TABLE_B,
662 MotorCurrentAndPhase->MotorCurrentTableB[0]);
663 Mustek_SendData2Byte (chip, ES02_51_MOTOR_PHASE_TABLE_1,
664 0x39 & MotorPhase);
665 }
666 else if (MotorCurrentAndPhase->MoveType ==
667 _16_TABLE_SPACE_FOR_1_DIV_4_STEP)
668 { /* 1/4 step */
669 Mustek_SendData (chip, ES01_AB_PWM_CURRENT_CONTROL, 0x02);
670
671 /*1 */
672 Mustek_SendData2Byte (chip, ES02_52_MOTOR_CURRENT_TABLE_A,
673 (SANE_Byte) (MotorCurrentAndPhase->
674 MotorCurrentTableA[0] * sin (0 *
675 3.141592654
676 * 90 /
677 4 /
678 180)));
679 Mustek_SendData2Byte (chip, ES02_53_MOTOR_CURRENT_TABLE_B,
680 (SANE_Byte) (MotorCurrentAndPhase->
681 MotorCurrentTableB[0] * cos (0 *
682 3.141592654
683 * 90 /
684 4 /
685 180)));
686 Mustek_SendData2Byte (chip, ES02_51_MOTOR_PHASE_TABLE_1,
687 0x08 & MotorPhase);
688
689 /*2 */
690 Mustek_SendData2Byte (chip, ES02_52_MOTOR_CURRENT_TABLE_A,
691 (SANE_Byte) (MotorCurrentAndPhase->
692 MotorCurrentTableA[0] * sin (1 *
693 3.141592654
694 * 90 /
695 4 /
696 180)));
697 Mustek_SendData2Byte (chip, ES02_53_MOTOR_CURRENT_TABLE_B,
698 (SANE_Byte) (MotorCurrentAndPhase->
699 MotorCurrentTableB[0] * cos (1 *
700 3.141592654
701 * 90 /
702 4 /
703 180)));
704 Mustek_SendData2Byte (chip, ES02_51_MOTOR_PHASE_TABLE_1,
705 0x08 & MotorPhase);
706
707 /*3 */
708 Mustek_SendData2Byte (chip, ES02_52_MOTOR_CURRENT_TABLE_A,
709 (SANE_Byte) (MotorCurrentAndPhase->
710 MotorCurrentTableA[0] * sin (2 *
711 3.141592654
712 * 90 /
713 4 /
714 180)));
715 Mustek_SendData2Byte (chip, ES02_53_MOTOR_CURRENT_TABLE_B,
716 (SANE_Byte) (MotorCurrentAndPhase->
717 MotorCurrentTableB[0] * cos (2 *
718 3.141592654
719 * 90 /
720 4 /
721 180)));
722 Mustek_SendData2Byte (chip, ES02_51_MOTOR_PHASE_TABLE_1,
723 0x08 & MotorPhase);
724
725 /*4 */
726 Mustek_SendData2Byte (chip, ES02_52_MOTOR_CURRENT_TABLE_A,
727 (SANE_Byte) (MotorCurrentAndPhase->
728 MotorCurrentTableA[0] * sin (3 *
729 3.141592654
730 * 90 /
731 4 /
732 180)));
733 Mustek_SendData2Byte (chip, ES02_53_MOTOR_CURRENT_TABLE_B,
734 (SANE_Byte) (MotorCurrentAndPhase->
735 MotorCurrentTableB[0] * cos (3 *
736 3.141592654
737 * 90 /
738 4 /
739 180)));
740 Mustek_SendData2Byte (chip, ES02_51_MOTOR_PHASE_TABLE_1,
741 0x08 & MotorPhase);
742
743 /*5 */
744 Mustek_SendData2Byte (chip, ES02_52_MOTOR_CURRENT_TABLE_A,
745 (SANE_Byte) (MotorCurrentAndPhase->
746 MotorCurrentTableA[0] * cos (0 *
747 3.141592654
748 * 90 /
749 4 /
750 180)));
751 Mustek_SendData2Byte (chip, ES02_53_MOTOR_CURRENT_TABLE_B,
752 (SANE_Byte) (MotorCurrentAndPhase->
753 MotorCurrentTableB[0] * sin (0 *
754 3.141592654
755 * 90 /
756 4 /
757 180)));
758 Mustek_SendData2Byte (chip, ES02_51_MOTOR_PHASE_TABLE_1,
759 0x09 & MotorPhase);
760
761 /*6 */
762 Mustek_SendData2Byte (chip, ES02_52_MOTOR_CURRENT_TABLE_A,
763 (SANE_Byte) (MotorCurrentAndPhase->
764 MotorCurrentTableA[0] * cos (1 *
765 3.141592654
766 * 90 /
767 4 /
768 180)));
769 Mustek_SendData2Byte (chip, ES02_53_MOTOR_CURRENT_TABLE_B,
770 (SANE_Byte) (MotorCurrentAndPhase->
771 MotorCurrentTableB[0] * sin (1 *
772 3.141592654
773 * 90 /
774 4 /
775 180)));
776 Mustek_SendData2Byte (chip, ES02_51_MOTOR_PHASE_TABLE_1,
777 0x09 & MotorPhase);
778
779 /*7 */
780 Mustek_SendData2Byte (chip, ES02_52_MOTOR_CURRENT_TABLE_A,
781 (SANE_Byte) (MotorCurrentAndPhase->
782 MotorCurrentTableA[0] * cos (2 *
783 3.141592654
784 * 90 /
785 4 /
786 180)));
787 Mustek_SendData2Byte (chip, ES02_53_MOTOR_CURRENT_TABLE_B,
788 (SANE_Byte) (MotorCurrentAndPhase->
789 MotorCurrentTableB[0] * sin (2 *
790 3.141592654
791 * 90 /
792 4 /
793 180)));
794 Mustek_SendData2Byte (chip, ES02_51_MOTOR_PHASE_TABLE_1,
795 0x09 & MotorPhase);
796
797 /*8 */
798 Mustek_SendData2Byte (chip, ES02_52_MOTOR_CURRENT_TABLE_A,
799 (SANE_Byte) (MotorCurrentAndPhase->
800 MotorCurrentTableA[0] * cos (3 *
801 3.141592654
802 * 90 /
803 4 /
804 180)));
805 Mustek_SendData2Byte (chip, ES02_53_MOTOR_CURRENT_TABLE_B,
806 (SANE_Byte) (MotorCurrentAndPhase->
807 MotorCurrentTableB[0] * sin (3 *
808 3.141592654
809 * 90 /
810 4 /
811 180)));
812 Mustek_SendData2Byte (chip, ES02_51_MOTOR_PHASE_TABLE_1,
813 0x09 & MotorPhase);
814
815 /*9 */
816 Mustek_SendData2Byte (chip, ES02_52_MOTOR_CURRENT_TABLE_A,
817 (SANE_Byte) (MotorCurrentAndPhase->
818 MotorCurrentTableA[0] * sin (0 *
819 3.141592654
820 * 90 /
821 4 /
822 180)));
823 Mustek_SendData2Byte (chip, ES02_53_MOTOR_CURRENT_TABLE_B,
824 (SANE_Byte) (MotorCurrentAndPhase->
825 MotorCurrentTableB[0] * cos (0 *
826 3.141592654
827 * 90 /
828 4 /
829 180)));
830 Mustek_SendData2Byte (chip, ES02_51_MOTOR_PHASE_TABLE_1,
831 0x01 & MotorPhase);
832
833 /*10 */
834 Mustek_SendData2Byte (chip, ES02_52_MOTOR_CURRENT_TABLE_A,
835 (SANE_Byte) (MotorCurrentAndPhase->
836 MotorCurrentTableA[0] * sin (1 *
837 3.141592654
838 * 90 /
839 4 /
840 180)));
841 Mustek_SendData2Byte (chip, ES02_53_MOTOR_CURRENT_TABLE_B,
842 (SANE_Byte) (MotorCurrentAndPhase->
843 MotorCurrentTableB[0] * cos (1 *
844 3.141592654
845 * 90 /
846 4 /
847 180)));
848 Mustek_SendData2Byte (chip, ES02_51_MOTOR_PHASE_TABLE_1,
849 0x01 & MotorPhase);
850
851 /*11 */
852 Mustek_SendData2Byte (chip, ES02_52_MOTOR_CURRENT_TABLE_A,
853 (SANE_Byte) (MotorCurrentAndPhase->
854 MotorCurrentTableA[0] * sin (2 *
855 3.141592654
856 * 90 /
857 4 /
858 180)));
859 Mustek_SendData2Byte (chip, ES02_53_MOTOR_CURRENT_TABLE_B,
860 (SANE_Byte) (MotorCurrentAndPhase->
861 MotorCurrentTableB[0] * cos (2 *
862 3.141592654
863 * 90 /
864 4 /
865 180)));
866 Mustek_SendData2Byte (chip, ES02_51_MOTOR_PHASE_TABLE_1,
867 0x01 & MotorPhase);
868
869 /*12 */
870 Mustek_SendData2Byte (chip, ES02_52_MOTOR_CURRENT_TABLE_A,
871 (SANE_Byte) (MotorCurrentAndPhase->
872 MotorCurrentTableA[0] * sin (3 *
873 3.141592654
874 * 90 /
875 4 /
876 180)));
877 Mustek_SendData2Byte (chip, ES02_53_MOTOR_CURRENT_TABLE_B,
878 (SANE_Byte) (MotorCurrentAndPhase->
879 MotorCurrentTableB[0] * cos (3 *
880 3.141592654
881 * 90 /
882 4 /
883 180)));
884 Mustek_SendData2Byte (chip, ES02_51_MOTOR_PHASE_TABLE_1,
885 0x01 & MotorPhase);
886
887 /*13 */
888 Mustek_SendData2Byte (chip, ES02_52_MOTOR_CURRENT_TABLE_A,
889 (SANE_Byte) (MotorCurrentAndPhase->
890 MotorCurrentTableA[0] * cos (0 *
891 3.141592654
892 * 90 /
893 4 /
894 180)));
895 Mustek_SendData2Byte (chip, ES02_53_MOTOR_CURRENT_TABLE_B,
896 (SANE_Byte) (MotorCurrentAndPhase->
897 MotorCurrentTableB[0] * sin (0 *
898 3.141592654
899 * 90 /
900 4 /
901 180)));
902 Mustek_SendData2Byte (chip, ES02_51_MOTOR_PHASE_TABLE_1,
903 0x00 & MotorPhase);
904
905 /*14 */
906 Mustek_SendData2Byte (chip, ES02_52_MOTOR_CURRENT_TABLE_A,
907 (SANE_Byte) (MotorCurrentAndPhase->
908 MotorCurrentTableA[0] * cos (1 *
909 3.141592654
910 * 90 /
911 4 /
912 180)));
913 Mustek_SendData2Byte (chip, ES02_53_MOTOR_CURRENT_TABLE_B,
914 (SANE_Byte) (MotorCurrentAndPhase->
915 MotorCurrentTableB[0] * sin (1 *
916 3.141592654
917 * 90 /
918 4 /
919 180)));
920 Mustek_SendData2Byte (chip, ES02_51_MOTOR_PHASE_TABLE_1,
921 0x00 & MotorPhase);
922
923 /*15 */
924 Mustek_SendData2Byte (chip, ES02_52_MOTOR_CURRENT_TABLE_A,
925 (SANE_Byte) (MotorCurrentAndPhase->
926 MotorCurrentTableA[0] * cos (2 *
927 3.141592654
928 * 90 /
929 4 /
930 180)));
931 Mustek_SendData2Byte (chip, ES02_53_MOTOR_CURRENT_TABLE_B,
932 (SANE_Byte) (MotorCurrentAndPhase->
933 MotorCurrentTableB[0] * sin (2 *
934 3.141592654
935 * 90 /
936 4 /
937 180)));
938 Mustek_SendData2Byte (chip, ES02_51_MOTOR_PHASE_TABLE_1,
939 0x00 & MotorPhase);
940
941 /*16 */
942 Mustek_SendData2Byte (chip, ES02_52_MOTOR_CURRENT_TABLE_A,
943 (SANE_Byte) (MotorCurrentAndPhase->
944 MotorCurrentTableA[0] * cos (3 *
945 3.141592654
946 * 90 /
947 4 /
948 180)));
949 Mustek_SendData2Byte (chip, ES02_53_MOTOR_CURRENT_TABLE_B,
950 (SANE_Byte) (MotorCurrentAndPhase->
951 MotorCurrentTableB[0] * sin (3 *
952 3.141592654
953 * 90 /
954 4 /
955 180)));
956 Mustek_SendData2Byte (chip, ES02_51_MOTOR_PHASE_TABLE_1,
957 0x00 & MotorPhase);
958
959 }
960 else if (MotorCurrentAndPhase->MoveType ==
961 _32_TABLE_SPACE_FOR_1_DIV_8_STEP)
962 {
963 Mustek_SendData (chip, ES01_AB_PWM_CURRENT_CONTROL, 0x03);
964
965 /*1 */
966 Mustek_SendData2Byte (chip, ES02_52_MOTOR_CURRENT_TABLE_A,
967 (SANE_Byte) (MotorCurrentAndPhase->
968 MotorCurrentTableA[0] * sin (0 *
969 3.141592654
970 * 90 /
971 8 /
972 180)));
973 Mustek_SendData2Byte (chip, ES02_53_MOTOR_CURRENT_TABLE_B,
974 (SANE_Byte) (MotorCurrentAndPhase->
975 MotorCurrentTableB[0] * cos (0 *
976 3.141592654
977 * 90 /
978 8 /
979 180)));
980 Mustek_SendData2Byte (chip, ES02_51_MOTOR_PHASE_TABLE_1,
981 0x00 & MotorPhase);
982
983 /*2 */
984 Mustek_SendData2Byte (chip, ES02_52_MOTOR_CURRENT_TABLE_A,
985 (SANE_Byte) (MotorCurrentAndPhase->
986 MotorCurrentTableA[0] * sin (1 *
987 3.141592654
988 * 90 /
989 8 /
990 180)));
991 Mustek_SendData2Byte (chip, ES02_53_MOTOR_CURRENT_TABLE_B,
992 (SANE_Byte) (MotorCurrentAndPhase->
993 MotorCurrentTableB[0] * cos (1 *
994 3.141592654
995 * 90 /
996 8 /
997 180)));
998 Mustek_SendData2Byte (chip, ES02_51_MOTOR_PHASE_TABLE_1,
999 0x00 & MotorPhase);
1000
1001 /*3 */
1002 Mustek_SendData2Byte (chip, ES02_52_MOTOR_CURRENT_TABLE_A,
1003 (SANE_Byte) (MotorCurrentAndPhase->
1004 MotorCurrentTableA[0] * sin (2 *
1005 3.141592654
1006 * 90 /
1007 8 /
1008 180)));
1009 Mustek_SendData2Byte (chip, ES02_53_MOTOR_CURRENT_TABLE_B,
1010 (SANE_Byte) (MotorCurrentAndPhase->
1011 MotorCurrentTableB[0] * cos (2 *
1012 3.141592654
1013 * 90 /
1014 8 /
1015 180)));
1016 Mustek_SendData2Byte (chip, ES02_51_MOTOR_PHASE_TABLE_1,
1017 0x00 & MotorPhase);
1018
1019 /*4 */
1020 Mustek_SendData2Byte (chip, ES02_52_MOTOR_CURRENT_TABLE_A,
1021 (SANE_Byte) (MotorCurrentAndPhase->
1022 MotorCurrentTableA[0] * sin (3 *
1023 3.141592654
1024 * 90 /
1025 8 /
1026 180)));
1027 Mustek_SendData2Byte (chip, ES02_53_MOTOR_CURRENT_TABLE_B,
1028 (SANE_Byte) (MotorCurrentAndPhase->
1029 MotorCurrentTableB[0] * cos (3 *
1030 3.141592654
1031 * 90 /
1032 8 /
1033 180)));
1034 Mustek_SendData2Byte (chip, ES02_51_MOTOR_PHASE_TABLE_1,
1035 0x00 & MotorPhase);
1036
1037 /*5 */
1038 Mustek_SendData2Byte (chip, ES02_52_MOTOR_CURRENT_TABLE_A,
1039 (SANE_Byte) (MotorCurrentAndPhase->
1040 MotorCurrentTableA[0] * sin (4 *
1041 3.141592654
1042 * 90 /
1043 8 /
1044 180)));
1045 Mustek_SendData2Byte (chip, ES02_53_MOTOR_CURRENT_TABLE_B,
1046 (SANE_Byte) (MotorCurrentAndPhase->
1047 MotorCurrentTableB[0] * cos (4 *
1048 3.141592654
1049 * 90 /
1050 8 /
1051 180)));
1052 Mustek_SendData2Byte (chip, ES02_51_MOTOR_PHASE_TABLE_1,
1053 0x00 & MotorPhase);
1054
1055 /*6 */
1056 Mustek_SendData2Byte (chip, ES02_52_MOTOR_CURRENT_TABLE_A,
1057 (SANE_Byte) (MotorCurrentAndPhase->
1058 MotorCurrentTableA[0] * sin (5 *
1059 3.141592654
1060 * 90 /
1061 8 /
1062 180)));
1063 Mustek_SendData2Byte (chip, ES02_53_MOTOR_CURRENT_TABLE_B,
1064 (SANE_Byte) (MotorCurrentAndPhase->
1065 MotorCurrentTableB[0] * cos (5 *
1066 3.141592654
1067 * 90 /
1068 8 /
1069 180)));
1070 Mustek_SendData2Byte (chip, ES02_51_MOTOR_PHASE_TABLE_1,
1071 0x00 & MotorPhase);
1072
1073 /*7 */
1074 Mustek_SendData2Byte (chip, ES02_52_MOTOR_CURRENT_TABLE_A,
1075 (SANE_Byte) (MotorCurrentAndPhase->
1076 MotorCurrentTableA[0] * sin (6 *
1077 3.141592654
1078 * 90 /
1079 8 /
1080 180)));
1081 Mustek_SendData2Byte (chip, ES02_53_MOTOR_CURRENT_TABLE_B,
1082 (SANE_Byte) (MotorCurrentAndPhase->
1083 MotorCurrentTableB[0] * cos (6 *
1084 3.141592654
1085 * 90 /
1086 8 /
1087 180)));
1088 Mustek_SendData2Byte (chip, ES02_51_MOTOR_PHASE_TABLE_1,
1089 0x00 & MotorPhase);
1090
1091 /*8 */
1092 Mustek_SendData2Byte (chip, ES02_52_MOTOR_CURRENT_TABLE_A,
1093 (SANE_Byte) (MotorCurrentAndPhase->
1094 MotorCurrentTableA[0] * sin (7 *
1095 3.141592654
1096 * 90 /
1097 8 /
1098 180)));
1099
1100 Mustek_SendData2Byte (chip, ES02_53_MOTOR_CURRENT_TABLE_B,
1101 (SANE_Byte) (MotorCurrentAndPhase->
1102 MotorCurrentTableB[0] * cos (7 *
1103 3.141592654
1104 * 90 /
1105 8 /
1106 180)));
1107 Mustek_SendData2Byte (chip, ES02_51_MOTOR_PHASE_TABLE_1,
1108 0x00 & MotorPhase);
1109
1110 /*9 */
1111 Mustek_SendData2Byte (chip, ES02_52_MOTOR_CURRENT_TABLE_A,
1112 (SANE_Byte) (MotorCurrentAndPhase->
1113 MotorCurrentTableA[0] * sin (0 *
1114 3.141592654
1115 * 90 /
1116 8 /
1117 180)));
1118 Mustek_SendData2Byte (chip, ES02_53_MOTOR_CURRENT_TABLE_B,
1119 (SANE_Byte) (MotorCurrentAndPhase->
1120 MotorCurrentTableB[0] * cos (0 *
1121 3.141592654
1122 * 90 /
1123 8 /
1124 180)));
1125 Mustek_SendData2Byte (chip, ES02_51_MOTOR_PHASE_TABLE_1,
1126 0x08 & MotorPhase);
1127
1128 /*10 */
1129 Mustek_SendData2Byte (chip, ES02_52_MOTOR_CURRENT_TABLE_A,
1130 (SANE_Byte) (MotorCurrentAndPhase->
1131 MotorCurrentTableA[0] * sin (1 *
1132 3.141592654
1133 * 90 /
1134 8 /
1135 180)));
1136 Mustek_SendData2Byte (chip, ES02_53_MOTOR_CURRENT_TABLE_B,
1137 (SANE_Byte) (MotorCurrentAndPhase->
1138 MotorCurrentTableB[0] * cos (1 *
1139 3.141592654
1140 * 90 /
1141 8 /
1142 180)));
1143 Mustek_SendData2Byte (chip, ES02_51_MOTOR_PHASE_TABLE_1,
1144 0x08 & MotorPhase);
1145
1146 /*11 */
1147 Mustek_SendData2Byte (chip, ES02_52_MOTOR_CURRENT_TABLE_A,
1148 (SANE_Byte) (MotorCurrentAndPhase->
1149 MotorCurrentTableA[0] * sin (2 *
1150 3.141592654
1151 * 90 /
1152 8 /
1153 180)));
1154 Mustek_SendData2Byte (chip, ES02_53_MOTOR_CURRENT_TABLE_B,
1155 (SANE_Byte) (MotorCurrentAndPhase->
1156 MotorCurrentTableB[0] * cos (2 *
1157 3.141592654
1158 * 90 /
1159 8 /
1160 180)));
1161 Mustek_SendData2Byte (chip, ES02_51_MOTOR_PHASE_TABLE_1,
1162 0x08 & MotorPhase);
1163
1164 /*12 */
1165 Mustek_SendData2Byte (chip, ES02_52_MOTOR_CURRENT_TABLE_A,
1166 (SANE_Byte) (MotorCurrentAndPhase->
1167 MotorCurrentTableA[0] * sin (3 *
1168 3.141592654
1169 * 90 /
1170 8 /
1171 180)));
1172 Mustek_SendData2Byte (chip, ES02_53_MOTOR_CURRENT_TABLE_B,
1173 (SANE_Byte) (MotorCurrentAndPhase->
1174 MotorCurrentTableB[0] * cos (3 *
1175 3.141592654
1176 * 90 /
1177 8 /
1178 180)));
1179 Mustek_SendData2Byte (chip, ES02_51_MOTOR_PHASE_TABLE_1,
1180 0x08 & MotorPhase);
1181
1182 /*13 */
1183 Mustek_SendData2Byte (chip, ES02_52_MOTOR_CURRENT_TABLE_A,
1184 (SANE_Byte) (MotorCurrentAndPhase->
1185 MotorCurrentTableA[0] * sin (4 *
1186 3.141592654
1187 * 90 /
1188 8 /
1189 180)));
1190 Mustek_SendData2Byte (chip, ES02_53_MOTOR_CURRENT_TABLE_B,
1191 (SANE_Byte) (MotorCurrentAndPhase->
1192 MotorCurrentTableB[0] * cos (4 *
1193 3.141592654
1194 * 90 /
1195 8 /
1196 180)));
1197 Mustek_SendData2Byte (chip, ES02_51_MOTOR_PHASE_TABLE_1,
1198 0x08 & MotorPhase);
1199
1200 /*14 */
1201 Mustek_SendData2Byte (chip, ES02_52_MOTOR_CURRENT_TABLE_A,
1202 (SANE_Byte) (MotorCurrentAndPhase->
1203 MotorCurrentTableA[0] * sin (5 *
1204 3.141592654
1205 * 90 /
1206 8 /
1207 180)));
1208 Mustek_SendData2Byte (chip, ES02_53_MOTOR_CURRENT_TABLE_B,
1209 (SANE_Byte) (MotorCurrentAndPhase->
1210 MotorCurrentTableB[0] * cos (5 *
1211 3.141592654
1212 * 90 /
1213 8 /
1214 180)));
1215 Mustek_SendData2Byte (chip, ES02_51_MOTOR_PHASE_TABLE_1,
1216 0x08 & MotorPhase);
1217
1218 /*15 */
1219 Mustek_SendData2Byte (chip, ES02_52_MOTOR_CURRENT_TABLE_A,
1220 (SANE_Byte) (MotorCurrentAndPhase->
1221 MotorCurrentTableA[0] * sin (6 *
1222 3.141592654
1223 * 90 /
1224 8 /
1225 180)));
1226 Mustek_SendData2Byte (chip, ES02_53_MOTOR_CURRENT_TABLE_B,
1227 (SANE_Byte) (MotorCurrentAndPhase->
1228 MotorCurrentTableB[0] * cos (6 *
1229 3.141592654
1230 * 90 /
1231 8 /
1232 180)));
1233 Mustek_SendData2Byte (chip, ES02_51_MOTOR_PHASE_TABLE_1,
1234 0x08 & MotorPhase);
1235
1236 /*16 */
1237 Mustek_SendData2Byte (chip, ES02_52_MOTOR_CURRENT_TABLE_A,
1238 (SANE_Byte) (MotorCurrentAndPhase->
1239 MotorCurrentTableA[0] * sin (7 *
1240 3.141592654
1241 * 90 /
1242 8 /
1243 180)));
1244 Mustek_SendData2Byte (chip, ES02_53_MOTOR_CURRENT_TABLE_B,
1245 (SANE_Byte) (MotorCurrentAndPhase->
1246 MotorCurrentTableB[0] * cos (7 *
1247 3.141592654
1248 * 90 /
1249 8 /
1250 180)));
1251 Mustek_SendData2Byte (chip, ES02_51_MOTOR_PHASE_TABLE_1,
1252 0x08 & MotorPhase);
1253
1254 /*17 */
1255 Mustek_SendData2Byte (chip, ES02_52_MOTOR_CURRENT_TABLE_A,
1256 (SANE_Byte) (MotorCurrentAndPhase->
1257 MotorCurrentTableA[0] * sin (0 *
1258 3.141592654
1259 * 90 /
1260 8 /
1261 180)));
1262 Mustek_SendData2Byte (chip, ES02_53_MOTOR_CURRENT_TABLE_B,
1263 (SANE_Byte) (MotorCurrentAndPhase->
1264 MotorCurrentTableB[0] * cos (0 *
1265 3.141592654
1266 * 90 /
1267 8 /
1268 180)));
1269 Mustek_SendData2Byte (chip, ES02_51_MOTOR_PHASE_TABLE_1,
1270 0x09 & MotorPhase);
1271
1272 /*18 */
1273 Mustek_SendData2Byte (chip, ES02_52_MOTOR_CURRENT_TABLE_A,
1274 (SANE_Byte) (MotorCurrentAndPhase->
1275 MotorCurrentTableA[0] * sin (1 *
1276 3.141592654
1277 * 90 /
1278 8 /
1279 180)));
1280 Mustek_SendData2Byte (chip, ES02_53_MOTOR_CURRENT_TABLE_B,
1281 (SANE_Byte) (MotorCurrentAndPhase->
1282 MotorCurrentTableB[0] * cos (1 *
1283 3.141592654
1284 * 90 /
1285 8 /
1286 180)));
1287 Mustek_SendData2Byte (chip, ES02_51_MOTOR_PHASE_TABLE_1,
1288 0x09 & MotorPhase);
1289
1290 /*19 */
1291 Mustek_SendData2Byte (chip, ES02_52_MOTOR_CURRENT_TABLE_A,
1292 (SANE_Byte) (MotorCurrentAndPhase->
1293 MotorCurrentTableA[0] * sin (2 *
1294 3.141592654
1295 * 90 /
1296 8 /
1297 180)));
1298 Mustek_SendData2Byte (chip, ES02_53_MOTOR_CURRENT_TABLE_B,
1299 (SANE_Byte) (MotorCurrentAndPhase->
1300 MotorCurrentTableB[0] * cos (2 *
1301 3.141592654
1302 * 90 /
1303 8 /
1304 180)));
1305 Mustek_SendData2Byte (chip, ES02_51_MOTOR_PHASE_TABLE_1,
1306 0x09 & MotorPhase);
1307
1308 /*20 */
1309 Mustek_SendData2Byte (chip, ES02_52_MOTOR_CURRENT_TABLE_A,
1310 (SANE_Byte) (MotorCurrentAndPhase->
1311 MotorCurrentTableA[0] * sin (3 *
1312 3.141592654
1313 * 90 /
1314 8 /
1315 180)));
1316 Mustek_SendData2Byte (chip, ES02_53_MOTOR_CURRENT_TABLE_B,
1317 (SANE_Byte) (MotorCurrentAndPhase->
1318 MotorCurrentTableB[0] * cos (3 *
1319 3.141592654
1320 * 90 /
1321 8 /
1322 180)));
1323 Mustek_SendData2Byte (chip, ES02_51_MOTOR_PHASE_TABLE_1,
1324 0x09 & MotorPhase);
1325
1326 /*21 */
1327 Mustek_SendData2Byte (chip, ES02_52_MOTOR_CURRENT_TABLE_A,
1328 (SANE_Byte) (MotorCurrentAndPhase->
1329 MotorCurrentTableA[0] * sin (4 *
1330 3.141592654
1331 * 90 /
1332 8 /
1333 180)));
1334 Mustek_SendData2Byte (chip, ES02_53_MOTOR_CURRENT_TABLE_B,
1335 (SANE_Byte) (MotorCurrentAndPhase->
1336 MotorCurrentTableB[0] * cos (4 *
1337 3.141592654
1338 * 90 /
1339 8 /
1340 180)));
1341 Mustek_SendData2Byte (chip, ES02_51_MOTOR_PHASE_TABLE_1,
1342 0x09 & MotorPhase);
1343
1344 /*22 */
1345 Mustek_SendData2Byte (chip, ES02_52_MOTOR_CURRENT_TABLE_A,
1346 (SANE_Byte) (MotorCurrentAndPhase->
1347 MotorCurrentTableA[0] * sin (5 *
1348 3.141592654
1349 * 90 /
1350 8 /
1351 180)));
1352 Mustek_SendData2Byte (chip, ES02_53_MOTOR_CURRENT_TABLE_B,
1353 (SANE_Byte) (MotorCurrentAndPhase->
1354 MotorCurrentTableB[0] * cos (5 *
1355 3.141592654
1356 * 90 /
1357 8 /
1358 180)));
1359 Mustek_SendData2Byte (chip, ES02_51_MOTOR_PHASE_TABLE_1,
1360 0x09 & MotorPhase);
1361
1362 /*23 */
1363 Mustek_SendData2Byte (chip, ES02_52_MOTOR_CURRENT_TABLE_A,
1364 (SANE_Byte) (MotorCurrentAndPhase->
1365 MotorCurrentTableA[0] * sin (6 *
1366 3.141592654
1367 * 90 /
1368 8 /
1369 180)));
1370 Mustek_SendData2Byte (chip, ES02_53_MOTOR_CURRENT_TABLE_B,
1371 (SANE_Byte) (MotorCurrentAndPhase->
1372 MotorCurrentTableB[0] * cos (6 *
1373 3.141592654
1374 * 90 /
1375 8 /
1376 180)));
1377 Mustek_SendData2Byte (chip, ES02_51_MOTOR_PHASE_TABLE_1,
1378 0x09 & MotorPhase);
1379
1380 /*24 */
1381 Mustek_SendData2Byte (chip, ES02_52_MOTOR_CURRENT_TABLE_A,
1382 (SANE_Byte) (MotorCurrentAndPhase->
1383 MotorCurrentTableA[0] * sin (7 *
1384 3.141592654
1385 * 90 /
1386 8 /
1387 180)));
1388 Mustek_SendData2Byte (chip, ES02_53_MOTOR_CURRENT_TABLE_B,
1389 (SANE_Byte) (MotorCurrentAndPhase->
1390 MotorCurrentTableB[0] * cos (7 *
1391 3.141592654
1392 * 90 /
1393 8 /
1394 180)));
1395 Mustek_SendData2Byte (chip, ES02_51_MOTOR_PHASE_TABLE_1,
1396 0x09 & MotorPhase);
1397
1398 /*25 */
1399 Mustek_SendData2Byte (chip, ES02_52_MOTOR_CURRENT_TABLE_A,
1400 (SANE_Byte) (MotorCurrentAndPhase->
1401 MotorCurrentTableA[0] * sin (0 *
1402 3.141592654
1403 * 90 /
1404 8 /
1405 180)));
1406 Mustek_SendData2Byte (chip, ES02_53_MOTOR_CURRENT_TABLE_B,
1407 (SANE_Byte) (MotorCurrentAndPhase->
1408 MotorCurrentTableB[0] * cos (0 *
1409 3.141592654
1410 * 90 /
1411 8 /
1412 180)));
1413 Mustek_SendData2Byte (chip, ES02_51_MOTOR_PHASE_TABLE_1,
1414 0x01 & MotorPhase);
1415
1416 /*26 */
1417 Mustek_SendData2Byte (chip, ES02_52_MOTOR_CURRENT_TABLE_A,
1418 (SANE_Byte) (MotorCurrentAndPhase->
1419 MotorCurrentTableA[0] * sin (1 *
1420 3.141592654
1421 * 90 /
1422 8 /
1423 180)));
1424 Mustek_SendData2Byte (chip, ES02_53_MOTOR_CURRENT_TABLE_B,
1425 (SANE_Byte) (MotorCurrentAndPhase->
1426 MotorCurrentTableB[0] * cos (1 *
1427 3.141592654
1428 * 90 /
1429 8 /
1430 180)));
1431 Mustek_SendData2Byte (chip, ES02_51_MOTOR_PHASE_TABLE_1,
1432 0x01 & MotorPhase);
1433
1434 /*27 */
1435 Mustek_SendData2Byte (chip, ES02_52_MOTOR_CURRENT_TABLE_A,
1436 (SANE_Byte) (MotorCurrentAndPhase->
1437 MotorCurrentTableA[0] * sin (2 *
1438 3.141592654
1439 * 90 /
1440 8 /
1441 180)));
1442 Mustek_SendData2Byte (chip, ES02_53_MOTOR_CURRENT_TABLE_B,
1443 (SANE_Byte) (MotorCurrentAndPhase->
1444 MotorCurrentTableB[0] * cos (2 *
1445 3.141592654
1446 * 90 /
1447 8 /
1448 180)));
1449 Mustek_SendData2Byte (chip, ES02_51_MOTOR_PHASE_TABLE_1,
1450 0x01 & MotorPhase);
1451
1452 /*28 */
1453 Mustek_SendData2Byte (chip, ES02_52_MOTOR_CURRENT_TABLE_A,
1454 (SANE_Byte) (MotorCurrentAndPhase->
1455 MotorCurrentTableA[0] * sin (3 *
1456 3.141592654
1457 * 90 /
1458 8 /
1459 180)));
1460 Mustek_SendData2Byte (chip, ES02_53_MOTOR_CURRENT_TABLE_B,
1461 (SANE_Byte) (MotorCurrentAndPhase->
1462 MotorCurrentTableB[0] * cos (3 *
1463 3.141592654
1464 * 90 /
1465 8 /
1466 180)));
1467 Mustek_SendData2Byte (chip, ES02_51_MOTOR_PHASE_TABLE_1,
1468 0x01 & MotorPhase);
1469
1470 /*29 */
1471 Mustek_SendData2Byte (chip, ES02_52_MOTOR_CURRENT_TABLE_A,
1472 (SANE_Byte) (MotorCurrentAndPhase->
1473 MotorCurrentTableA[0] * sin (4 *
1474 3.141592654
1475 * 90 /
1476 8 /
1477 180)));
1478 Mustek_SendData2Byte (chip, ES02_53_MOTOR_CURRENT_TABLE_B,
1479 (SANE_Byte) (MotorCurrentAndPhase->
1480 MotorCurrentTableB[0] * cos (4 *
1481 3.141592654
1482 * 90 /
1483 8 /
1484 180)));
1485 Mustek_SendData2Byte (chip, ES02_51_MOTOR_PHASE_TABLE_1,
1486 0x01 & MotorPhase);
1487
1488 /*30 */
1489 Mustek_SendData2Byte (chip, ES02_52_MOTOR_CURRENT_TABLE_A,
1490 (SANE_Byte) (MotorCurrentAndPhase->
1491 MotorCurrentTableA[0] * sin (5 *
1492 3.141592654
1493 * 90 /
1494 8 /
1495 180)));
1496 Mustek_SendData2Byte (chip, ES02_53_MOTOR_CURRENT_TABLE_B,
1497 (SANE_Byte) (MotorCurrentAndPhase->
1498 MotorCurrentTableB[0] * cos (5 *
1499 3.141592654
1500 * 90 /
1501 8 /
1502 180)));
1503 Mustek_SendData2Byte (chip, ES02_51_MOTOR_PHASE_TABLE_1,
1504 0x01 & MotorPhase);
1505
1506 /*31 */
1507 Mustek_SendData2Byte (chip, ES02_52_MOTOR_CURRENT_TABLE_A,
1508 (SANE_Byte) (MotorCurrentAndPhase->
1509 MotorCurrentTableA[0] * sin (6 *
1510 3.141592654
1511 * 90 /
1512 8 /
1513 180)));
1514 Mustek_SendData2Byte (chip, ES02_53_MOTOR_CURRENT_TABLE_B,
1515 (SANE_Byte) (MotorCurrentAndPhase->
1516 MotorCurrentTableB[0] * cos (6 *
1517 3.141592654
1518 * 90 /
1519 8 /
1520 180)));
1521 Mustek_SendData2Byte (chip, ES02_51_MOTOR_PHASE_TABLE_1,
1522 0x01 & MotorPhase);
1523
1524 /*32 */
1525 Mustek_SendData2Byte (chip, ES02_52_MOTOR_CURRENT_TABLE_A,
1526 (SANE_Byte) (MotorCurrentAndPhase->
1527 MotorCurrentTableA[0] * sin (7 *
1528 3.141592654
1529 * 90 /
1530 8 /
1531 180)));
1532 Mustek_SendData2Byte (chip, ES02_53_MOTOR_CURRENT_TABLE_B,
1533 (SANE_Byte) (MotorCurrentAndPhase->
1534 MotorCurrentTableB[0] * cos (7 *
1535 3.141592654
1536 * 90 /
1537 8 /
1538 180)));
1539 Mustek_SendData2Byte (chip, ES02_51_MOTOR_PHASE_TABLE_1,
1540 0x01 & MotorPhase);
1541
1542 }
1543 }
1544
1545 if (MotorCurrentAndPhase->FillPhase != 0)
1546 {
1547 Mustek_SendData (chip, ES02_50_MOTOR_CURRENT_CONTORL,
1548 0x00 | MotorCurrentAndPhase->MoveType);
1549 }
1550 else
1551 {
1552 Mustek_SendData (chip, ES02_50_MOTOR_CURRENT_CONTORL, 0x00);
1553 }
1554
1555 DBG (DBG_ASIC, "LLFSetMotorCurrentAndPhase:Exit\n");
1556 return status;
1557 }
1558
1559
1560 #if SANE_UNUSED
1561 static SANE_Status
LLFStopMotorMove(PAsic chip)1562 LLFStopMotorMove (PAsic chip)
1563 {
1564 SANE_Status status = SANE_STATUS_GOOD;
1565 DBG (DBG_ASIC, "LLFStopMotorMove:Enter\n");
1566
1567 Mustek_SendData (chip, ES01_F4_ActiveTriger, ACTION_TRIGER_DISABLE);
1568
1569 Asic_WaitUnitReady (chip);
1570
1571 DBG (DBG_ASIC, "LLFStopMotorMove:Exit\n");
1572 return status;
1573 }
1574 #endif
1575
1576 static SANE_Status
LLFSetMotorTable(PAsic chip, LLF_SETMOTORTABLE * LLF_SetMotorTable)1577 LLFSetMotorTable (PAsic chip, LLF_SETMOTORTABLE * LLF_SetMotorTable)
1578 {
1579 SANE_Status status = SANE_STATUS_GOOD;
1580 LLF_RAMACCESS RamAccess;
1581
1582 DBG (DBG_ASIC, "LLFSetMotorTable:Enter\n");
1583 if (LLF_SetMotorTable->MotorTablePtr != NULL)
1584 {
1585 RamAccess.ReadWrite = WRITE_RAM;
1586 RamAccess.IsOnChipGamma = EXTERNAL_RAM;
1587 RamAccess.DramDelayTime = SDRAMCLK_DELAY_12_ns;
1588
1589 RamAccess.LoStartAddress = 0;
1590 RamAccess.LoStartAddress |= LLF_SetMotorTable->MotorTableAddress;
1591 RamAccess.LoStartAddress <<= TABLE_OFFSET_BASE;
1592 RamAccess.LoStartAddress |= 0x3000;
1593
1594 RamAccess.HiStartAddress = 0;
1595 RamAccess.HiStartAddress |= LLF_SetMotorTable->MotorTableAddress;
1596 RamAccess.HiStartAddress >>= (16 - TABLE_OFFSET_BASE);
1597
1598 RamAccess.RwSize = 512 * 2 * 8; /* BYTE */
1599 RamAccess.BufferPtr = (SANE_Byte *) LLF_SetMotorTable->MotorTablePtr;
1600
1601 LLFRamAccess (chip, &RamAccess);
1602
1603 /* tell scan chip the motor table address, unit is 2^14 words */
1604 Mustek_SendData (chip, ES01_9D_MotorTableAddrA14_A21,
1605 LLF_SetMotorTable->MotorTableAddress);
1606 }
1607
1608 DBG (DBG_ASIC, "LLFSetMotorTable:Exit\n");
1609 return status;
1610 }
1611
1612 static SANE_Status
LLFMotorMove(PAsic chip, LLF_MOTORMOVE * LLF_MotorMove)1613 LLFMotorMove (PAsic chip, LLF_MOTORMOVE * LLF_MotorMove)
1614 {
1615 SANE_Status status = SANE_STATUS_GOOD;
1616 unsigned int motor_steps;
1617 SANE_Byte temp_motor_action;
1618
1619 DBG (DBG_ASIC, "LLFMotorMove:Enter\n");
1620
1621 Mustek_SendData (chip, ES01_F4_ActiveTriger, ACTION_TRIGER_DISABLE);
1622
1623 status = Asic_WaitUnitReady (chip);
1624
1625 DBG (DBG_ASIC, "Set start/end pixel\n");
1626
1627 Mustek_SendData (chip, ES01_B8_ChannelRedExpStartPixelLSB, LOBYTE (100));
1628 Mustek_SendData (chip, ES01_B9_ChannelRedExpStartPixelMSB, HIBYTE (100));
1629 Mustek_SendData (chip, ES01_BA_ChannelRedExpEndPixelLSB, LOBYTE (101));
1630 Mustek_SendData (chip, ES01_BB_ChannelRedExpEndPixelMSB, HIBYTE (101));
1631
1632 Mustek_SendData (chip, ES01_BC_ChannelGreenExpStartPixelLSB, LOBYTE (100));
1633 Mustek_SendData (chip, ES01_BD_ChannelGreenExpStartPixelMSB, HIBYTE (100));
1634 Mustek_SendData (chip, ES01_BE_ChannelGreenExpEndPixelLSB, LOBYTE (101));
1635 Mustek_SendData (chip, ES01_BF_ChannelGreenExpEndPixelMSB, HIBYTE (101));
1636
1637 Mustek_SendData (chip, ES01_C0_ChannelBlueExpStartPixelLSB, LOBYTE (100));
1638 Mustek_SendData (chip, ES01_C1_ChannelBlueExpStartPixelMSB, HIBYTE (100));
1639 Mustek_SendData (chip, ES01_C2_ChannelBlueExpEndPixelLSB, LOBYTE (101));
1640 Mustek_SendData (chip, ES01_C3_ChannelBlueExpEndPixelMSB, HIBYTE (101));
1641
1642 /*set motor accelerate steps MAX 511 steps */
1643 Mustek_SendData (chip, ES01_E0_MotorAccStep0_7,
1644 LOBYTE (LLF_MotorMove->AccStep));
1645 Mustek_SendData (chip, ES01_E1_MotorAccStep8_8,
1646 HIBYTE (LLF_MotorMove->AccStep));
1647 DBG (DBG_ASIC, "AccStep=%d\n", LLF_MotorMove->AccStep);
1648
1649 Mustek_SendData (chip, ES01_E2_MotorStepOfMaxSpeed0_7,
1650 LOBYTE (LLF_MotorMove->FixMoveSteps));
1651 Mustek_SendData (chip, ES01_E3_MotorStepOfMaxSpeed8_15,
1652 HIBYTE (LLF_MotorMove->FixMoveSteps));
1653 Mustek_SendData (chip, ES01_E4_MotorStepOfMaxSpeed16_19, 0);
1654 DBG (DBG_ASIC, "FixMoveSteps=%d\n", LLF_MotorMove->FixMoveSteps);
1655
1656 /*set motor decelerate steps MAX 255 steps */
1657 Mustek_SendData (chip, ES01_E5_MotorDecStep, LLF_MotorMove->DecStep);
1658 DBG (DBG_ASIC, "DecStep=%d\n", LLF_MotorMove->DecStep);
1659
1660 /*set motor uniform speed only for uniform speed
1661 //only used for UNIFORM_MOTOR_AND_SCAN_SPEED_ENABLE
1662 //If you use acc mode, this two reg are not used. */
1663 Mustek_SendData (chip, ES01_FD_MotorFixedspeedLSB,
1664 LOBYTE (LLF_MotorMove->FixMoveSpeed));
1665 Mustek_SendData (chip, ES01_FE_MotorFixedspeedMSB,
1666 HIBYTE (LLF_MotorMove->FixMoveSpeed));
1667 DBG (DBG_ASIC, "FixMoveSpeed=%d\n", LLF_MotorMove->FixMoveSpeed);
1668
1669 /*Set motor type */
1670 Mustek_SendData (chip, ES01_A6_MotorOption, LLF_MotorMove->MotorSelect |
1671 LLF_MotorMove->HomeSensorSelect | LLF_MotorMove->
1672 MotorMoveUnit);
1673
1674 /*Set motor speed unit, for all motor mode,
1675 //include uniform, acc, motor speed of scan */
1676 Mustek_SendData (chip, ES01_F6_MorotControl1,
1677 LLF_MotorMove->MotorSpeedUnit | LLF_MotorMove->
1678 MotorSyncUnit);
1679
1680 /* below is setting action register */
1681 if (LLF_MotorMove->ActionType == ACTION_TYPE_BACKTOHOME)
1682 {
1683 DBG (DBG_ASIC, "ACTION_TYPE_BACKTOHOME\n");
1684
1685 temp_motor_action = MOTOR_BACK_HOME_AFTER_SCAN_ENABLE;
1686 motor_steps = 30000 * 2;
1687 }
1688 else
1689 {
1690 DBG (DBG_ASIC, "Forward or Backward\n");
1691 temp_motor_action = MOTOR_MOVE_TO_FIRST_LINE_ENABLE;
1692 motor_steps = LLF_MotorMove->FixMoveSteps;
1693
1694 if (LLF_MotorMove->ActionType == ACTION_TYPE_BACKWARD)
1695 {
1696 DBG (DBG_ASIC, "ACTION_TYPE_BACKWARD\n");
1697 temp_motor_action =
1698 temp_motor_action | INVERT_MOTOR_DIRECTION_ENABLE;
1699 }
1700 }
1701
1702 if (LLF_MotorMove->ActionType == ACTION_TYPE_TEST_MODE)
1703 {
1704 DBG (DBG_ASIC, "ACTION_TYPE_TEST_MODE\n");
1705 temp_motor_action = temp_motor_action |
1706 MOTOR_MOVE_TO_FIRST_LINE_ENABLE |
1707 MOTOR_BACK_HOME_AFTER_SCAN_ENABLE | MOTOR_TEST_LOOP_ENABLE;
1708 }
1709
1710 Mustek_SendData (chip, ES01_94_PowerSaveControl,
1711 0x27 | LLF_MotorMove->Lamp0PwmFreq | LLF_MotorMove->
1712 Lamp1PwmFreq);
1713
1714 /* fix speed move steps */
1715 Mustek_SendData (chip, ES01_E2_MotorStepOfMaxSpeed0_7,
1716 LOBYTE (motor_steps));
1717 Mustek_SendData (chip, ES01_E3_MotorStepOfMaxSpeed8_15,
1718 HIBYTE (motor_steps));
1719 Mustek_SendData (chip, ES01_E4_MotorStepOfMaxSpeed16_19,
1720 (SANE_Byte) ((motor_steps & 0x00ff0000) >> 16));
1721 DBG (DBG_ASIC, "motor_steps=%d\n", motor_steps);
1722 DBG (DBG_ASIC, "LOBYTE(motor_steps)=%d\n", LOBYTE (motor_steps));
1723 DBG (DBG_ASIC, "HIBYTE(motor_steps)=%d\n", HIBYTE (motor_steps));
1724 DBG (DBG_ASIC, "(SANE_Byte)((motor_steps & 0x00ff0000) >> 16)=%d\n",
1725 (SANE_Byte) ((motor_steps & 0x00ff0000) >> 16));
1726
1727 if (LLF_MotorMove->ActionMode == ACTION_MODE_UNIFORM_SPEED_MOVE)
1728 {
1729 temp_motor_action =
1730 temp_motor_action | UNIFORM_MOTOR_AND_SCAN_SPEED_ENABLE;
1731 }
1732
1733 Mustek_SendData (chip, ES01_F3_ActionOption, SCAN_DISABLE |
1734 SCAN_BACK_TRACKING_DISABLE | temp_motor_action);
1735 Mustek_SendData (chip, ES01_F4_ActiveTriger, ACTION_TRIGER_ENABLE);
1736
1737 if (LLF_MotorMove->WaitOrNoWait == 1)
1738 {
1739 if (LLF_MotorMove->ActionType == ACTION_TYPE_BACKTOHOME)
1740 {
1741 DBG (DBG_ASIC, "ACTION_TYPE_BACKTOHOME\n");
1742 Asic_WaitCarriageHome (chip, FALSE);
1743 }
1744 else
1745 {
1746 Asic_WaitUnitReady (chip);
1747 }
1748 }
1749
1750 DBG (DBG_ASIC, "LLFMotorMove:Exit\n");
1751 return status;
1752 }
1753
1754 static SANE_Status
SetMotorStepTable(PAsic chip, LLF_MOTORMOVE * MotorStepsTable, unsigned short wStartY, unsigned int dwScanImageSteps, unsigned short wYResolution)1755 SetMotorStepTable (PAsic chip, LLF_MOTORMOVE * MotorStepsTable, unsigned short wStartY,
1756 unsigned int dwScanImageSteps, unsigned short wYResolution)
1757 {
1758 SANE_Status status = SANE_STATUS_GOOD;
1759 unsigned short wAccSteps = 511;
1760 unsigned short wForwardSteps = 20;
1761 SANE_Byte bDecSteps = 255;
1762 unsigned short wMotorSycnPixelNumber = 0;
1763 unsigned short wScanAccSteps = 511;
1764 SANE_Byte bScanDecSteps = 255;
1765 unsigned short wFixScanSteps = 20;
1766 unsigned short wScanBackTrackingSteps = 40;
1767 unsigned short wScanRestartSteps = 40;
1768 unsigned short wScanBackHomeExtSteps = 100;
1769 unsigned int dwTotalMotorSteps;
1770
1771 DBG (DBG_ASIC, "SetMotorStepTable:Enter\n");
1772
1773 dwTotalMotorSteps = dwScanImageSteps;
1774
1775 switch (wYResolution)
1776 {
1777 case 2400:
1778 case 1200:
1779 wScanAccSteps = 100;
1780 bScanDecSteps = 10;
1781 wScanBackTrackingSteps = 10;
1782 wScanRestartSteps = 10;
1783 break;
1784 case 600:
1785 case 300:
1786 wScanAccSteps = 300;
1787 bScanDecSteps = 40;
1788 break;
1789 case 150:
1790 wScanAccSteps = 300;
1791 bScanDecSteps = 40;
1792 break;
1793 case 100:
1794 case 75:
1795 case 50:
1796 wScanAccSteps = 300;
1797 bScanDecSteps = 40;
1798 break;
1799 }
1800
1801 if (wStartY < (wAccSteps + wForwardSteps + bDecSteps + wScanAccSteps)) /*not including T0,T1 steps */
1802 {
1803 wAccSteps = 1;
1804 bDecSteps = 1;
1805 wFixScanSteps = (wStartY - wScanAccSteps) > 0 ?
1806 (wStartY - wScanAccSteps) : 0;
1807 wForwardSteps = 0;
1808
1809 chip->isMotorGoToFirstLine = MOTOR_MOVE_TO_FIRST_LINE_DISABLE;
1810 }
1811 else
1812 {
1813 wForwardSteps =
1814 (wStartY - wAccSteps - (unsigned short) bDecSteps - wScanAccSteps -
1815 wFixScanSteps) >
1816 0 ? (wStartY - wAccSteps - (unsigned short) bDecSteps - wScanAccSteps -
1817 wFixScanSteps) : 0;
1818
1819 chip->isMotorGoToFirstLine = MOTOR_MOVE_TO_FIRST_LINE_ENABLE;
1820 }
1821
1822 dwTotalMotorSteps += wAccSteps;
1823 dwTotalMotorSteps += wForwardSteps;
1824 dwTotalMotorSteps += bDecSteps;
1825 dwTotalMotorSteps += wScanAccSteps;
1826 dwTotalMotorSteps += wFixScanSteps;
1827 dwTotalMotorSteps += bScanDecSteps;
1828 dwTotalMotorSteps += 2;
1829
1830
1831 MotorStepsTable->AccStep = wAccSteps;
1832 MotorStepsTable->DecStep = bDecSteps;
1833 MotorStepsTable->wForwardSteps = wForwardSteps;
1834 MotorStepsTable->wScanAccSteps = wScanAccSteps;
1835 MotorStepsTable->bScanDecSteps = bScanDecSteps;
1836 MotorStepsTable->wFixScanSteps = wFixScanSteps;
1837 MotorStepsTable->MotorSyncUnit = (SANE_Byte) wMotorSycnPixelNumber;
1838 MotorStepsTable->wScanBackHomeExtSteps = wScanBackHomeExtSteps;
1839 MotorStepsTable->wScanRestartSteps = wScanRestartSteps;
1840 MotorStepsTable->wScanBackTrackingSteps = wScanBackTrackingSteps;
1841
1842 /*state 1 */
1843 Mustek_SendData (chip, ES01_E0_MotorAccStep0_7, LOBYTE (wAccSteps));
1844 Mustek_SendData (chip, ES01_E1_MotorAccStep8_8, HIBYTE (wAccSteps));
1845 /*state 2 */
1846 Mustek_SendData (chip, ES01_E2_MotorStepOfMaxSpeed0_7,
1847 LOBYTE (wForwardSteps));
1848 Mustek_SendData (chip, ES01_E3_MotorStepOfMaxSpeed8_15,
1849 HIBYTE (wForwardSteps));
1850 Mustek_SendData (chip, ES01_E4_MotorStepOfMaxSpeed16_19, 0);
1851 /*state 3 */
1852 Mustek_SendData (chip, ES01_E5_MotorDecStep, bDecSteps);
1853 /*state 4 */
1854 Mustek_SendData (chip, ES01_AE_MotorSyncPixelNumberM16LSB,
1855 LOBYTE (wMotorSycnPixelNumber));
1856 Mustek_SendData (chip, ES01_AF_MotorSyncPixelNumberM16MSB,
1857 HIBYTE (wMotorSycnPixelNumber));
1858 /*state 5 */
1859 Mustek_SendData (chip, ES01_EC_ScanAccStep0_7, LOBYTE (wScanAccSteps));
1860 Mustek_SendData (chip, ES01_ED_ScanAccStep8_8, HIBYTE (wScanAccSteps));
1861 /*state 6 */
1862 Mustek_SendData (chip, ES01_EE_FixScanStepLSB, LOBYTE (wFixScanSteps));
1863 Mustek_SendData (chip, ES01_8A_FixScanStepMSB, HIBYTE (wFixScanSteps));
1864 /*state 8 */
1865 Mustek_SendData (chip, ES01_EF_ScanDecStep, bScanDecSteps);
1866 /*state 10 */
1867 Mustek_SendData (chip, ES01_E6_ScanBackTrackingStepLSB,
1868 LOBYTE (wScanBackTrackingSteps));
1869 Mustek_SendData (chip, ES01_E7_ScanBackTrackingStepMSB,
1870 HIBYTE (wScanBackTrackingSteps));
1871 /*state 15 */
1872 Mustek_SendData (chip, ES01_E8_ScanRestartStepLSB,
1873 LOBYTE (wScanRestartSteps));
1874 Mustek_SendData (chip, ES01_E9_ScanRestartStepMSB,
1875 HIBYTE (wScanRestartSteps));
1876 /*state 19 */
1877 Mustek_SendData (chip, ES01_EA_ScanBackHomeExtStepLSB,
1878 LOBYTE (wScanBackHomeExtSteps));
1879 Mustek_SendData (chip, ES01_EB_ScanBackHomeExtStepMSB,
1880 HIBYTE (wScanBackHomeExtSteps));
1881
1882 /*total motor steps */
1883 Mustek_SendData (chip, ES01_F0_ScanImageStep0_7,
1884 LOBYTE (dwTotalMotorSteps));
1885 Mustek_SendData (chip, ES01_F1_ScanImageStep8_15,
1886 HIBYTE (dwTotalMotorSteps));
1887 Mustek_SendData (chip, ES01_F2_ScanImageStep16_19,
1888 (SANE_Byte) ((dwTotalMotorSteps & 0x00ff0000) >> 16));
1889
1890 DBG (DBG_ASIC, "SetMotorStepTable:Exit\n");
1891 return status;
1892 }
1893
1894 static SANE_Status
CalculateMotorTable(LLF_CALCULATEMOTORTABLE * lpCalculateMotorTable, unsigned short wYResolution)1895 CalculateMotorTable (LLF_CALCULATEMOTORTABLE * lpCalculateMotorTable,
1896 unsigned short wYResolution)
1897 {
1898 SANE_Status status = SANE_STATUS_GOOD;
1899 unsigned short i;
1900 unsigned short wEndSpeed, wStartSpeed;
1901 unsigned short wScanAccSteps;
1902 SANE_Byte bScanDecSteps;
1903 double PI = 3.1415926;
1904 double x = PI / 2;
1905 long double y;
1906 unsigned short *lpMotorTable;
1907
1908 DBG (DBG_ASIC, "CalculateMotorTable:Enter\n");
1909
1910 wStartSpeed = lpCalculateMotorTable->StartSpeed;
1911 wEndSpeed = lpCalculateMotorTable->EndSpeed;
1912 wScanAccSteps = lpCalculateMotorTable->AccStepBeforeScan;
1913 bScanDecSteps = lpCalculateMotorTable->DecStepAfterScan;
1914 lpMotorTable = lpCalculateMotorTable->lpMotorTable;
1915
1916 /*Motor T0 & T6 Acc Table */
1917 for (i = 0; i < 512; i++)
1918 {
1919 y = (6000 - 3500);
1920 y *= (pow (0.09, (x * i) / 512) - pow (0.09, (x * 511) / 512));
1921 y += 4500;
1922 *((unsigned short *) lpMotorTable + i) = (unsigned short) y; /*T0 */
1923 *((unsigned short *) lpMotorTable + i + 512 * 6) = (unsigned short) y; /*T6 */
1924 }
1925
1926 /*Motor T1 & T7 Dec Table */
1927 for (i = 0; i < 256; i++)
1928 {
1929 y = (6000 - 3500);
1930 y *= pow (0.3, (x * i) / 256);
1931 y = 6000 - y;
1932 *((unsigned short *) lpMotorTable + i + 512) = (unsigned short) y; /*T1 */
1933 *((unsigned short *) lpMotorTable + i + 512 * 7) = (unsigned short) y; /*T7 */
1934 }
1935
1936 switch (wYResolution)
1937 {
1938 case 2400:
1939 case 1200:
1940 case 600:
1941 case 300:
1942 case 150:
1943 case 100:
1944 case 75:
1945 case 50:
1946 for (i = 0; i < wScanAccSteps; i++)
1947 {
1948 y = (wStartSpeed - wEndSpeed);
1949 y *=
1950 (pow (0.09, (x * i) / wScanAccSteps) -
1951 pow (0.09, (x * (wScanAccSteps - 1)) / wScanAccSteps));
1952 y += wEndSpeed;
1953 *((unsigned short *) lpMotorTable + i + 512 * 2) = (unsigned short) y; /*T2 */
1954 *((unsigned short *) lpMotorTable + i + 512 * 4) = (unsigned short) y; /*T4 */
1955 }
1956 for (i = wScanAccSteps; i < 512; i++)
1957 {
1958 *((unsigned short *) lpMotorTable + i + 512 * 2) = (unsigned short) wEndSpeed; /*T2 */
1959 *((unsigned short *) lpMotorTable + i + 512 * 4) = (unsigned short) wEndSpeed; /*T4 */
1960 }
1961
1962
1963 for (i = 0; i < (unsigned short) bScanDecSteps; i++)
1964 {
1965 y = (wStartSpeed - wEndSpeed);
1966 y *= pow (0.3, (x * i) / bScanDecSteps);
1967 y = wStartSpeed - y;
1968 *((unsigned short *) lpMotorTable + i + 512 * 3) = (unsigned short) (y); /*T3 */
1969 *((unsigned short *) lpMotorTable + i + 512 * 5) = (unsigned short) (y); /*T5 */
1970 }
1971 for (i = bScanDecSteps; i < 256; i++)
1972 {
1973 *((unsigned short *) lpMotorTable + i + 512 * 3) = (unsigned short) wStartSpeed; /*T3 */
1974 *((unsigned short *) lpMotorTable + i + 512 * 5) = (unsigned short) wStartSpeed; /*T5 */
1975 }
1976 break;
1977 }
1978
1979 DBG (DBG_ASIC, "CalculateMotorTable:Exit\n");
1980 return status;
1981 }
1982
1983 static SANE_Status
LLFCalculateMotorTable(LLF_CALCULATEMOTORTABLE * LLF_CalculateMotorTable)1984 LLFCalculateMotorTable (LLF_CALCULATEMOTORTABLE * LLF_CalculateMotorTable)
1985 {
1986 SANE_Status status = SANE_STATUS_GOOD;
1987 unsigned short i;
1988 double PI = 3.1415926535;
1989 double x;
1990
1991 DBG (DBG_ASIC, "LLF_CALCULATEMOTORTABLE:Enter\n");
1992
1993 x = PI / 2;
1994
1995 for (i = 0; i < 512; i++)
1996 {
1997 /* before scan acc table */
1998 *(LLF_CalculateMotorTable->lpMotorTable + i) =
1999 (unsigned short) ((LLF_CalculateMotorTable->StartSpeed -
2000 LLF_CalculateMotorTable->EndSpeed) * pow (0.09,
2001 (x * i) / 512) +
2002 LLF_CalculateMotorTable->EndSpeed);
2003 *(LLF_CalculateMotorTable->lpMotorTable + i + 512 * 2) =
2004 (unsigned short) ((LLF_CalculateMotorTable->StartSpeed -
2005 LLF_CalculateMotorTable->EndSpeed) * pow (0.09,
2006 (x * i) / 512) +
2007 LLF_CalculateMotorTable->EndSpeed);
2008 *(LLF_CalculateMotorTable->lpMotorTable + i + 512 * 4) =
2009 (unsigned short) ((LLF_CalculateMotorTable->StartSpeed -
2010 LLF_CalculateMotorTable->EndSpeed) * pow (0.09,
2011 (x * i) / 512) +
2012 LLF_CalculateMotorTable->EndSpeed);
2013 *(LLF_CalculateMotorTable->lpMotorTable + i + 512 * 6) =
2014 (unsigned short) ((LLF_CalculateMotorTable->StartSpeed -
2015 LLF_CalculateMotorTable->EndSpeed) * pow (0.09,
2016 (x * i) / 512) +
2017 LLF_CalculateMotorTable->EndSpeed);
2018 }
2019
2020 for (i = 0; i < 255; i++)
2021 {
2022 *(LLF_CalculateMotorTable->lpMotorTable + i + 512) =
2023 (unsigned short) (LLF_CalculateMotorTable->StartSpeed -
2024 (LLF_CalculateMotorTable->StartSpeed -
2025 LLF_CalculateMotorTable->EndSpeed) * pow (0.3,
2026 (x * i) / 256));
2027 *(LLF_CalculateMotorTable->lpMotorTable + i + 512 * 3) =
2028 (unsigned short) (LLF_CalculateMotorTable->StartSpeed -
2029 (LLF_CalculateMotorTable->StartSpeed -
2030 LLF_CalculateMotorTable->EndSpeed) * pow (0.3,
2031 (x * i) / 256));
2032 *(LLF_CalculateMotorTable->lpMotorTable + i + 512 * 5) =
2033 (unsigned short) (LLF_CalculateMotorTable->StartSpeed -
2034 (LLF_CalculateMotorTable->StartSpeed -
2035 LLF_CalculateMotorTable->EndSpeed) * pow (0.3,
2036 (x * i) / 256));
2037 *(LLF_CalculateMotorTable->lpMotorTable + i + 512 * 7) =
2038 (unsigned short) (LLF_CalculateMotorTable->StartSpeed -
2039 (LLF_CalculateMotorTable->StartSpeed -
2040 LLF_CalculateMotorTable->EndSpeed) * pow (0.3,
2041 (x * i) / 256));
2042 }
2043
2044 for (i = 0; i < 512; i++)
2045 { /* back acc table */
2046 *(LLF_CalculateMotorTable->lpMotorTable + i) =
2047 (unsigned short) ((LLF_CalculateMotorTable->StartSpeed -
2048 LLF_CalculateMotorTable->EndSpeed) * pow (0.09,
2049 (x * i) / 512) +
2050 LLF_CalculateMotorTable->EndSpeed);
2051 *(LLF_CalculateMotorTable->lpMotorTable + i + 512 * 6) =
2052 (unsigned short) ((LLF_CalculateMotorTable->StartSpeed -
2053 LLF_CalculateMotorTable->EndSpeed) * pow (0.09,
2054 (x * i) / 512) +
2055 LLF_CalculateMotorTable->EndSpeed);
2056 }
2057
2058 if (LLF_CalculateMotorTable->AccStepBeforeScan == 0)
2059 {
2060 }
2061 else
2062 {
2063 for (i = 0; i < LLF_CalculateMotorTable->AccStepBeforeScan; i++)
2064 {
2065 *(LLF_CalculateMotorTable->lpMotorTable + i + 512 * 2) =
2066 (unsigned short) ((LLF_CalculateMotorTable->StartSpeed -
2067 LLF_CalculateMotorTable->EndSpeed) * (pow (0.09,
2068 (x * i) /
2069 LLF_CalculateMotorTable->
2070 AccStepBeforeScan)
2071 - pow (0.09,
2072 (x *
2073 (LLF_CalculateMotorTable->
2074 AccStepBeforeScan
2075 -
2076 1)) /
2077 LLF_CalculateMotorTable->
2078 AccStepBeforeScan))
2079 + LLF_CalculateMotorTable->EndSpeed);
2080 }
2081 }
2082
2083 DBG (DBG_ASIC, "LLF_CALCULATEMOTORTABLE:Exit\n");
2084 return status;
2085 }
2086
2087
2088 static SANE_Status
SetMotorCurrent(PAsic chip, unsigned short dwMotorSpeed, LLF_MOTOR_CURRENT_AND_PHASE * CurrentPhase)2089 SetMotorCurrent (PAsic chip, unsigned short dwMotorSpeed,
2090 LLF_MOTOR_CURRENT_AND_PHASE * CurrentPhase)
2091 {
2092 SANE_Status status = SANE_STATUS_GOOD;
2093 DBG (DBG_ASIC, "SetMotorCurrent:Enter\n");
2094
2095 (void) chip;
2096
2097 if (dwMotorSpeed < 2000)
2098 {
2099 CurrentPhase->MotorCurrentTableA[0] = 255;
2100 CurrentPhase->MotorCurrentTableB[0] = 255;
2101 }
2102 else if (dwMotorSpeed < 3500)
2103 {
2104 CurrentPhase->MotorCurrentTableA[0] = 200;
2105 CurrentPhase->MotorCurrentTableB[0] = 200;
2106 }
2107 else if (dwMotorSpeed < 5000)
2108 {
2109 CurrentPhase->MotorCurrentTableA[0] = 160;
2110 CurrentPhase->MotorCurrentTableB[0] = 160;
2111 }
2112 else if (dwMotorSpeed < 10000)
2113 {
2114 CurrentPhase->MotorCurrentTableA[0] = 70;
2115 CurrentPhase->MotorCurrentTableB[0] = 70;
2116 }
2117 else if (dwMotorSpeed < 17000)
2118 {
2119 CurrentPhase->MotorCurrentTableA[0] = 60;
2120 CurrentPhase->MotorCurrentTableB[0] = 60;
2121 }
2122 else if (dwMotorSpeed < 25000)
2123 {
2124 CurrentPhase->MotorCurrentTableA[0] = 50;
2125 CurrentPhase->MotorCurrentTableB[0] = 50;
2126 }
2127 else
2128 {
2129 CurrentPhase->MotorCurrentTableA[0] = 50;
2130 CurrentPhase->MotorCurrentTableB[0] = 50;
2131 }
2132
2133 DBG (DBG_ASIC, "SetMotorCurrent:Exit\n");
2134 return status;
2135 }
2136
2137
2138 static SANE_Status
MotorBackHome(PAsic chip, SANE_Byte WaitOrNoWait)2139 MotorBackHome (PAsic chip, SANE_Byte WaitOrNoWait)
2140 {
2141 SANE_Status status = SANE_STATUS_GOOD;
2142 unsigned short BackHomeMotorTable[512 * 8];
2143 LLF_CALCULATEMOTORTABLE CalMotorTable;
2144 LLF_MOTOR_CURRENT_AND_PHASE CurrentPhase;
2145 LLF_SETMOTORTABLE LLF_SetMotorTable;
2146 LLF_MOTORMOVE MotorMove;
2147
2148 DBG (DBG_ASIC, "MotorBackHome:Enter\n");
2149
2150 CalMotorTable.StartSpeed = 5000;
2151 CalMotorTable.EndSpeed = 1200;
2152 CalMotorTable.AccStepBeforeScan = 511;
2153 CalMotorTable.DecStepAfterScan = 255;
2154 CalMotorTable.lpMotorTable = BackHomeMotorTable;
2155 LLFCalculateMotorTable (&CalMotorTable);
2156
2157
2158 CurrentPhase.MotorCurrentTableA[0] = 220;
2159 CurrentPhase.MotorCurrentTableB[0] = 220;
2160 CurrentPhase.MoveType = _4_TABLE_SPACE_FOR_FULL_STEP;
2161 LLFSetMotorCurrentAndPhase (chip, &CurrentPhase);
2162
2163 LLF_SetMotorTable.MotorTableAddress = 0;
2164 LLF_SetMotorTable.MotorTablePtr = BackHomeMotorTable;
2165 LLFSetMotorTable (chip, &LLF_SetMotorTable);
2166
2167 MotorMove.MotorSelect = MOTOR_0_ENABLE | MOTOR_1_DISABLE;
2168 MotorMove.MotorMoveUnit = ES03_TABLE_DEFINE;
2169 MotorMove.MotorSpeedUnit = SPEED_UNIT_1_PIXEL_TIME;
2170 MotorMove.MotorSyncUnit = MOTOR_SYNC_UNIT_1_PIXEL_TIME;
2171 MotorMove.HomeSensorSelect = HOME_SENSOR_0_ENABLE;
2172 MotorMove.ActionMode = ACTION_MODE_ACCDEC_MOVE;
2173 MotorMove.ActionType = ACTION_TYPE_BACKTOHOME;
2174
2175 MotorMove.AccStep = 511;
2176 MotorMove.DecStep = 255;
2177 MotorMove.FixMoveSteps = 0;
2178 MotorMove.FixMoveSpeed = 3000;
2179 MotorMove.WaitOrNoWait = WaitOrNoWait;
2180 LLFMotorMove (chip, &MotorMove);
2181
2182 DBG (DBG_ASIC, "MotorBackHome:Exit\n");
2183 return status;
2184 }
2185
2186
2187 static SANE_Status
LLFSetRamAddress(PAsic chip, unsigned int dwStartAddr, unsigned int dwEndAddr, SANE_Byte byAccessTarget)2188 LLFSetRamAddress (PAsic chip, unsigned int dwStartAddr, unsigned int dwEndAddr,
2189 SANE_Byte byAccessTarget)
2190 {
2191 SANE_Status status = SANE_STATUS_GOOD;
2192 SANE_Byte * pStartAddr = (SANE_Byte *) & dwStartAddr;
2193 SANE_Byte * pEndAddr = (SANE_Byte *) & dwEndAddr;
2194
2195 DBG (DBG_ASIC, "LLFSetRamAddress:Enter\n");
2196
2197 /*Set start address. */
2198 Mustek_SendData (chip, ES01_A0_HostStartAddr0_7, *(pStartAddr));
2199 Mustek_SendData (chip, ES01_A1_HostStartAddr8_15, *(pStartAddr + 1));
2200 if (byAccessTarget == ACCESS_DRAM)
2201 Mustek_SendData (chip, ES01_A2_HostStartAddr16_21,
2202 *(pStartAddr + 2) | ACCESS_DRAM);
2203 else
2204 Mustek_SendData (chip, ES01_A2_HostStartAddr16_21,
2205 *(pStartAddr + 2) | ACCESS_GAMMA_RAM);
2206
2207 /*Set end address. */
2208 Mustek_SendData (chip, ES01_A3_HostEndAddr0_7, *(pEndAddr));
2209 Mustek_SendData (chip, ES01_A4_HostEndAddr8_15, *(pEndAddr + 1));
2210 Mustek_SendData (chip, ES01_A5_HostEndAddr16_21, *(pEndAddr + 2));
2211
2212 Mustek_ClearFIFO (chip);
2213
2214 DBG (DBG_ASIC, "LLFSetRamAddress:Exit\n");
2215 return status;
2216 }
2217
2218
2219
2220 /* ---------------------- medium level asic functions ---------------------- */
2221
2222 static SANE_Status
InitTiming(PAsic chip)2223 InitTiming (PAsic chip)
2224 {
2225 SANE_Status status = SANE_STATUS_GOOD;
2226 DBG (DBG_ASIC, "InitTiming:Enter\n");
2227
2228 chip->Timing.AFE_ADCCLK_Timing = 1010580480;
2229 chip->Timing.AFE_ADCVS_Timing = 12582912;
2230 chip->Timing.AFE_ADCRS_Timing = 3072;
2231 chip->Timing.AFE_ChannelA_LatchPos = 3080;
2232 chip->Timing.AFE_ChannelB_LatchPos = 3602;
2233 chip->Timing.AFE_ChannelC_LatchPos = 5634;
2234 chip->Timing.AFE_ChannelD_LatchPos = 1546;
2235 chip->Timing.AFE_Secondary_FF_LatchPos = 12;
2236
2237 /* Sensor */
2238 chip->Timing.CCD_DummyCycleTiming = 0;
2239 chip->Timing.PHTG_PluseWidth = 12;
2240 chip->Timing.PHTG_WaitWidth = 1;
2241 chip->Timing.PHTG_TimingAdj = 1;
2242 chip->Timing.PHTG_TimingSetup = 0;
2243 chip->Timing.ChannelR_StartPixel = 100;
2244 chip->Timing.ChannelR_EndPixel = 200;
2245 chip->Timing.ChannelG_StartPixel = 100;
2246 chip->Timing.ChannelG_EndPixel = 200;
2247 chip->Timing.ChannelB_StartPixel = 100;
2248 chip->Timing.ChannelB_EndPixel = 200;
2249
2250 /*1200dpi Timing */
2251 chip->Timing.CCD_PH2_Timing_1200 = 1048320;
2252 chip->Timing.CCD_PHRS_Timing_1200 = 983040;
2253 chip->Timing.CCD_PHCP_Timing_1200 = 61440;
2254 chip->Timing.CCD_PH1_Timing_1200 = 4293918720u;
2255 chip->Timing.DE_CCD_SETUP_REGISTER_1200 = 32;
2256 chip->Timing.wCCDPixelNumber_1200 = 11250;
2257
2258 /*600dpi Timing */
2259 chip->Timing.CCD_PH2_Timing_600 = 1048320;
2260 chip->Timing.CCD_PHRS_Timing_600 = 983040;
2261 chip->Timing.CCD_PHCP_Timing_600 = 61440;
2262 chip->Timing.CCD_PH1_Timing_600 = 4293918720u;
2263 chip->Timing.DE_CCD_SETUP_REGISTER_600 = 0;
2264 chip->Timing.wCCDPixelNumber_600 = 7500;
2265
2266 DBG (DBG_ASIC, "InitTiming:Exit\n");
2267 return status;
2268 }
2269
2270 static SANE_Status
OpenScanChip(PAsic chip)2271 OpenScanChip (PAsic chip)
2272 {
2273 SANE_Status status = SANE_STATUS_GOOD;
2274 SANE_Byte x[4];
2275
2276 DBG (DBG_ASIC, "OpenScanChip:Enter\n");
2277
2278 x[0] = 0x64;
2279 x[1] = 0x64;
2280 x[2] = 0x64;
2281 x[3] = 0x64;
2282 status = WriteIOControl (chip, 0x90, 0, 4, x);
2283 if (status != SANE_STATUS_GOOD)
2284 return status;
2285
2286 x[0] = 0x65;
2287 x[1] = 0x65;
2288 x[2] = 0x65;
2289 x[3] = 0x65;
2290 status = WriteIOControl (chip, 0x90, 0, 4, x);
2291 if (status != SANE_STATUS_GOOD)
2292 return status;
2293
2294 x[0] = 0x44;
2295 x[1] = 0x44;
2296 x[2] = 0x44;
2297 x[3] = 0x44;
2298 status = WriteIOControl (chip, 0x90, 0, 4, x);
2299 if (status != SANE_STATUS_GOOD)
2300 return status;
2301
2302 x[0] = 0x45;
2303 x[1] = 0x45;
2304 x[2] = 0x45;
2305 x[3] = 0x45;
2306 status = WriteIOControl (chip, 0x90, 0, 4, x);
2307
2308 DBG (DBG_ASIC, "OpenScanChip: Exit\n");
2309 return status;
2310 }
2311
2312
2313 static SANE_Status
CloseScanChip(PAsic chip)2314 CloseScanChip (PAsic chip)
2315 {
2316 SANE_Status status = SANE_STATUS_GOOD;
2317 SANE_Byte x[4];
2318
2319 DBG (DBG_ASIC, "CloseScanChip:Enter\n");
2320
2321 x[0] = 0x64;
2322 x[1] = 0x64;
2323 x[2] = 0x64;
2324 x[3] = 0x64;
2325 status = WriteIOControl (chip, 0x90, 0, 4, x);
2326 if (status != SANE_STATUS_GOOD)
2327 return status;
2328
2329 x[0] = 0x65;
2330 x[1] = 0x65;
2331 x[2] = 0x65;
2332 x[3] = 0x65;
2333 status = WriteIOControl (chip, 0x90, 0, 4, x);
2334 if (status != SANE_STATUS_GOOD)
2335 return status;
2336
2337 x[0] = 0x16;
2338 x[1] = 0x16;
2339 x[2] = 0x16;
2340 x[3] = 0x16;
2341 status = WriteIOControl (chip, 0x90, 0, 4, x);
2342 if (status != SANE_STATUS_GOOD)
2343 return status;
2344
2345 x[0] = 0x17;
2346 x[1] = 0x17;
2347 x[2] = 0x17;
2348 x[3] = 0x17;
2349 status = WriteIOControl (chip, 0x90, 0, 4, x);
2350
2351 DBG (DBG_ASIC, "CloseScanChip: Exit\n");
2352 return status;
2353 }
2354
2355
2356 static SANE_Status
SafeInitialChip(PAsic chip)2357 SafeInitialChip (PAsic chip)
2358 {
2359 SANE_Status status = SANE_STATUS_GOOD;
2360
2361 DBG (DBG_ASIC, "SafeInitialChip:Enter\n");
2362
2363 Mustek_SendData (chip, ES01_F3_ActionOption, 0);
2364 Mustek_SendData (chip, ES01_86_DisableAllClockWhenIdle,
2365 CLOSE_ALL_CLOCK_DISABLE);
2366 Mustek_SendData (chip, ES01_F4_ActiveTriger, ACTION_TRIGER_DISABLE);
2367
2368 status = Asic_WaitUnitReady (chip);
2369
2370 DBG (DBG_ASIC, "isFirstOpenChip=%d\n", chip->isFirstOpenChip);
2371 if (chip->isFirstOpenChip)
2372 {
2373 DBG (DBG_ASIC, "isFirstOpenChip=%d\n", chip->isFirstOpenChip);
2374 status = DRAM_Test (chip);
2375 if (status != SANE_STATUS_GOOD)
2376 {
2377 DBG (DBG_ASIC, "DRAM_Test: Error\n");
2378 return status;
2379 }
2380 chip->isFirstOpenChip = FALSE;
2381 }
2382
2383 DBG (DBG_ASIC, "SafeInitialChip: exit\n");
2384 return status;
2385 }
2386
2387
2388 static SANE_Status
DRAM_Test(PAsic chip)2389 DRAM_Test (PAsic chip)
2390 {
2391 SANE_Status status = SANE_STATUS_GOOD;
2392 unsigned char *temps;
2393 unsigned int i;
2394
2395 DBG (DBG_ASIC, "DRAM_Test:Enter\n");
2396
2397 temps = (unsigned char *) malloc (64);
2398
2399 for (i = 0; i < 64; i++)
2400 {
2401 *(temps + i) = i;
2402 }
2403
2404 /*set start address */
2405 status = Mustek_SendData (chip, ES01_A0_HostStartAddr0_7, 0x00);
2406 if (status != SANE_STATUS_GOOD)
2407 {
2408 free (temps);
2409 return status;
2410 }
2411
2412 status = Mustek_SendData (chip, ES01_A1_HostStartAddr8_15, 0x00);
2413 if (status != SANE_STATUS_GOOD)
2414 {
2415 free (temps);
2416 return status;
2417 }
2418
2419 status =
2420 Mustek_SendData (chip, ES01_A2_HostStartAddr16_21, 0x00 | ACCESS_DRAM);
2421 if (status != SANE_STATUS_GOOD)
2422 {
2423 free (temps);
2424 return status;
2425 }
2426
2427 Mustek_SendData (chip, ES01_79_AFEMCLK_SDRAMCLK_DELAY_CONTROL,
2428 SDRAMCLK_DELAY_12_ns);
2429 status = Mustek_SendData (chip, ES01_A3_HostEndAddr0_7, 0xff);
2430 if (status != SANE_STATUS_GOOD)
2431 {
2432 free (temps);
2433 return status;
2434 }
2435
2436 status = Mustek_SendData (chip, ES01_A4_HostEndAddr8_15, 0xff);
2437 if (status != SANE_STATUS_GOOD)
2438 {
2439 free (temps);
2440 return status;
2441 }
2442
2443 status = Mustek_SendData (chip, ES01_A5_HostEndAddr16_21, 0xff);
2444 if (status != SANE_STATUS_GOOD)
2445 {
2446 free (temps);
2447 return status;
2448 }
2449
2450 status = Mustek_DMAWrite (chip, 64, (SANE_Byte *) (temps));
2451 if (status != SANE_STATUS_GOOD)
2452 {
2453 DBG (DBG_ASIC, "Mustek_DMAWrite error\n");
2454 free (temps);
2455 return status;
2456 }
2457
2458 status = Mustek_SendData (chip, ES01_A0_HostStartAddr0_7, 0x00);
2459 if (status != SANE_STATUS_GOOD)
2460 {
2461 free (temps);
2462 return status;
2463 }
2464
2465 status = Mustek_SendData (chip, ES01_A1_HostStartAddr8_15, 0x00);
2466 if (status != SANE_STATUS_GOOD)
2467 {
2468 free (temps);
2469 return status;
2470 }
2471
2472 status =
2473 Mustek_SendData (chip, ES01_A2_HostStartAddr16_21, 0x00 | ACCESS_DRAM);
2474 if (status != SANE_STATUS_GOOD)
2475 {
2476 free (temps);
2477 return status;
2478 }
2479
2480 /*set end address */
2481 status = Mustek_SendData (chip, ES01_A3_HostEndAddr0_7, 0xff);
2482 if (status != SANE_STATUS_GOOD)
2483 {
2484 free (temps);
2485 return status;
2486 }
2487
2488 status = Mustek_SendData (chip, ES01_A4_HostEndAddr8_15, 0xff);
2489 if (status != SANE_STATUS_GOOD)
2490 {
2491 free (temps);
2492 return status;
2493 }
2494
2495 status = Mustek_SendData (chip, ES01_A5_HostEndAddr16_21, 0xff);
2496 if (status != SANE_STATUS_GOOD)
2497 {
2498 free (temps);
2499 return status;
2500 }
2501
2502 memset (temps, 0, 64);
2503
2504 status = Mustek_DMARead (chip, 64, (SANE_Byte *) (temps));
2505 if (status != SANE_STATUS_GOOD)
2506 {
2507 free (temps);
2508 return status;
2509 }
2510
2511 for (i = 0; i < 60; i += 10)
2512 {
2513 DBG (DBG_ASIC, "%d,%d,%d,%d,%d,%d,%d,%d,%d,%d\n",
2514 *(temps + i), *(temps + i + 1), *(temps + i + 2), *(temps + i + 3),
2515 *(temps + i + 4), *(temps + i + 5), *(temps + i + 6),
2516 *(temps + i + 7), *(temps + i + 8), *(temps + i + 9));
2517 }
2518
2519 for (i = 0; i < 64; i++)
2520 {
2521 if (*(temps + i) != i)
2522 {
2523 DBG (DBG_ERR, "DRAM Test error...(No.=%d)\n", i + 1);
2524 return SANE_STATUS_IO_ERROR;
2525 }
2526 }
2527
2528 free (temps);
2529
2530 DBG (DBG_ASIC, "DRAM_Text: Exit\n");
2531 return status;
2532 }
2533
2534 #if SANE_UNUSED
2535 static SANE_Status
SetPowerSave(PAsic chip)2536 SetPowerSave (PAsic chip)
2537 {
2538 SANE_Status status = SANE_STATUS_GOOD;
2539 DBG (DBG_ASIC, "SetPowerSave:Enter\n");
2540
2541 if (chip->firmwarestate < FS_OPENED)
2542 OpenScanChip (chip);
2543
2544 if (chip->firmwarestate > FS_OPENED)
2545 Asic_ScanStop (chip);
2546
2547 Mustek_SendData (chip, ES01_94_PowerSaveControl, 0x10);
2548
2549 chip->firmwarestate = FS_OPENED;
2550 DBG (DBG_ASIC, "SetPowerSave:Exit\n");
2551 return status;
2552 }
2553 #endif
2554
2555 static SANE_Status
SetLineTimeAndExposure(PAsic chip)2556 SetLineTimeAndExposure (PAsic chip)
2557 {
2558 SANE_Status status = SANE_STATUS_GOOD;
2559 DBG (DBG_ASIC, "SetLineTimeAndExposure:Enter\n");
2560
2561 if (chip->firmwarestate < FS_OPENED)
2562 OpenScanChip (chip);
2563
2564 Mustek_SendData (chip, ES01_C4_MultiTGTimesRed, 0);
2565 Mustek_SendData (chip, ES01_C5_MultiTGTimesGreen, 0);
2566 Mustek_SendData (chip, ES01_C6_MultiTGTimesBlue, 0);
2567
2568 Mustek_SendData (chip, ES01_C7_MultiTGDummyPixelNumberLSB, 0);
2569 Mustek_SendData (chip, ES01_C8_MultiTGDummyPixelNumberMSB, 0);
2570
2571 Mustek_SendData (chip, ES01_C9_CCDDummyPixelNumberLSB, 0);
2572 Mustek_SendData (chip, ES01_CA_CCDDummyPixelNumberMSB, 0);
2573
2574 Mustek_SendData (chip, ES01_CB_CCDDummyCycleNumber, 0);
2575
2576
2577 chip->firmwarestate = FS_OPENED;
2578
2579 DBG (DBG_ASIC, "SetLineTimeAndExposure:Exit\n");
2580 return status;
2581 }
2582
2583
2584
2585
2586
2587 static SANE_Status
CCDTiming(PAsic chip)2588 CCDTiming (PAsic chip)
2589 {
2590 SANE_Status status = SANE_STATUS_GOOD;
2591 unsigned int dwPH1, dwPH2, dwPHRS, dwPHCP;
2592
2593 DBG (DBG_ASIC, "CCDTiming:Enter\n");
2594 DBG (DBG_ASIC, "Dpi=%d\n", chip->Scan.Dpi);
2595
2596 if (chip->firmwarestate < FS_OPENED)
2597 OpenScanChip (chip);
2598
2599 Mustek_SendData (chip, ES01_82_AFE_ADCCLK_TIMING_ADJ_BYTE0,
2600 (SANE_Byte) (chip->Timing.AFE_ADCCLK_Timing));
2601 Mustek_SendData (chip, ES01_83_AFE_ADCCLK_TIMING_ADJ_BYTE1,
2602 (SANE_Byte) (chip->Timing.AFE_ADCCLK_Timing >> 8));
2603 Mustek_SendData (chip, ES01_84_AFE_ADCCLK_TIMING_ADJ_BYTE2,
2604 (SANE_Byte) (chip->Timing.AFE_ADCCLK_Timing >> 16));
2605 Mustek_SendData (chip, ES01_85_AFE_ADCCLK_TIMING_ADJ_BYTE3,
2606 (SANE_Byte) (chip->Timing.AFE_ADCCLK_Timing >> 24));
2607
2608 Mustek_SendData (chip, ES01_1F0_AFERS_TIMING_ADJ_B0,
2609 (SANE_Byte) (chip->Timing.AFE_ADCRS_Timing));
2610 Mustek_SendData (chip, ES01_1F1_AFERS_TIMING_ADJ_B1,
2611 (SANE_Byte) (chip->Timing.AFE_ADCRS_Timing >> 8));
2612 Mustek_SendData (chip, ES01_1F2_AFERS_TIMING_ADJ_B2,
2613 (SANE_Byte) (chip->Timing.AFE_ADCRS_Timing >> 16));
2614 Mustek_SendData (chip, ES01_1F3_AFERS_TIMING_ADJ_B3,
2615 (SANE_Byte) (chip->Timing.AFE_ADCRS_Timing >> 24));
2616
2617 Mustek_SendData (chip, ES01_1EC_AFEVS_TIMING_ADJ_B0,
2618 (SANE_Byte) (chip->Timing.AFE_ADCVS_Timing));
2619 Mustek_SendData (chip, ES01_1ED_AFEVS_TIMING_ADJ_B1,
2620 (SANE_Byte) (chip->Timing.AFE_ADCVS_Timing >> 8));
2621 Mustek_SendData (chip, ES01_1EE_AFEVS_TIMING_ADJ_B2,
2622 (SANE_Byte) (chip->Timing.AFE_ADCVS_Timing >> 16));
2623 Mustek_SendData (chip, ES01_1EF_AFEVS_TIMING_ADJ_B3,
2624 (SANE_Byte) (chip->Timing.AFE_ADCVS_Timing >> 24));
2625
2626 Mustek_SendData (chip, ES01_160_CHANNEL_A_LATCH_POSITION_HB,
2627 HIBYTE (chip->Timing.AFE_ChannelA_LatchPos));
2628 Mustek_SendData (chip, ES01_161_CHANNEL_A_LATCH_POSITION_LB,
2629 LOBYTE (chip->Timing.AFE_ChannelA_LatchPos));
2630
2631 Mustek_SendData (chip, ES01_162_CHANNEL_B_LATCH_POSITION_HB,
2632 HIBYTE (chip->Timing.AFE_ChannelB_LatchPos));
2633 Mustek_SendData (chip, ES01_163_CHANNEL_B_LATCH_POSITION_LB,
2634 LOBYTE (chip->Timing.AFE_ChannelB_LatchPos));
2635
2636 Mustek_SendData (chip, ES01_164_CHANNEL_C_LATCH_POSITION_HB,
2637 HIBYTE (chip->Timing.AFE_ChannelC_LatchPos));
2638 Mustek_SendData (chip, ES01_165_CHANNEL_C_LATCH_POSITION_LB,
2639 LOBYTE (chip->Timing.AFE_ChannelC_LatchPos));
2640
2641 Mustek_SendData (chip, ES01_166_CHANNEL_D_LATCH_POSITION_HB,
2642 HIBYTE (chip->Timing.AFE_ChannelD_LatchPos));
2643 Mustek_SendData (chip, ES01_167_CHANNEL_D_LATCH_POSITION_LB,
2644 LOBYTE (chip->Timing.AFE_ChannelD_LatchPos));
2645
2646 Mustek_SendData (chip, ES01_168_SECONDARY_FF_LATCH_POSITION,
2647 chip->Timing.AFE_Secondary_FF_LatchPos);
2648
2649 Mustek_SendData (chip, ES01_1D0_DUMMY_CYCLE_TIMING_B0,
2650 (SANE_Byte) (chip->Timing.CCD_DummyCycleTiming));
2651 Mustek_SendData (chip, ES01_1D1_DUMMY_CYCLE_TIMING_B1,
2652 (SANE_Byte) (chip->Timing.CCD_DummyCycleTiming >> 8));
2653 Mustek_SendData (chip, ES01_1D2_DUMMY_CYCLE_TIMING_B2,
2654 (SANE_Byte) (chip->Timing.CCD_DummyCycleTiming >> 16));
2655 Mustek_SendData (chip, ES01_1D3_DUMMY_CYCLE_TIMING_B3,
2656 (SANE_Byte) (chip->Timing.CCD_DummyCycleTiming >> 24));
2657
2658 if (chip->Scan.Dpi >= 1200)
2659 {
2660 dwPH1 = chip->Timing.CCD_PH1_Timing_1200;
2661 dwPH2 = chip->Timing.CCD_PH2_Timing_1200;
2662 dwPHRS = chip->Timing.CCD_PHRS_Timing_1200;
2663 dwPHCP = chip->Timing.CCD_PHCP_Timing_1200;
2664 }
2665 else
2666 {
2667 dwPH1 = chip->Timing.CCD_PH1_Timing_600;
2668 dwPH2 = chip->Timing.CCD_PH2_Timing_600;
2669 dwPHRS = chip->Timing.CCD_PHRS_Timing_600;
2670 dwPHCP = chip->Timing.CCD_PHCP_Timing_600;
2671 }
2672
2673 Mustek_SendData (chip, ES01_1D4_PH1_TIMING_ADJ_B0, (SANE_Byte) (dwPH1));
2674 Mustek_SendData (chip, ES01_1D5_PH1_TIMING_ADJ_B1, (SANE_Byte) (dwPH1 >> 8));
2675 Mustek_SendData (chip, ES01_1D6_PH1_TIMING_ADJ_B2, (SANE_Byte) (dwPH1 >> 16));
2676 Mustek_SendData (chip, ES01_1D7_PH1_TIMING_ADJ_B3, (SANE_Byte) (dwPH1 >> 24));
2677
2678 /* set ccd ph1 ph2 rs cp */
2679 Mustek_SendData (chip, ES01_D0_PH1_0, 0);
2680 Mustek_SendData (chip, ES01_D1_PH2_0, 4);
2681 Mustek_SendData (chip, ES01_D4_PHRS_0, 0);
2682 Mustek_SendData (chip, ES01_D5_PHCP_0, 0);
2683
2684 Mustek_SendData (chip, ES01_1D8_PH2_TIMING_ADJ_B0, (SANE_Byte) (dwPH2));
2685 Mustek_SendData (chip, ES01_1D9_PH2_TIMING_ADJ_B1, (SANE_Byte) (dwPH2 >> 8));
2686 Mustek_SendData (chip, ES01_1DA_PH2_TIMING_ADJ_B2, (SANE_Byte) (dwPH2 >> 16));
2687 Mustek_SendData (chip, ES01_1DB_PH2_TIMING_ADJ_B3, (SANE_Byte) (dwPH2 >> 24));
2688
2689 Mustek_SendData (chip, ES01_1E4_PHRS_TIMING_ADJ_B0, (SANE_Byte) (dwPHRS));
2690 Mustek_SendData (chip, ES01_1E5_PHRS_TIMING_ADJ_B1, (SANE_Byte) (dwPHRS >> 8));
2691 Mustek_SendData (chip, ES01_1E6_PHRS_TIMING_ADJ_B2, (SANE_Byte) (dwPHRS >> 16));
2692 Mustek_SendData (chip, ES01_1E7_PHRS_TIMING_ADJ_B3, (SANE_Byte) (dwPHRS >> 24));
2693
2694 Mustek_SendData (chip, ES01_1E8_PHCP_TIMING_ADJ_B0, (SANE_Byte) (dwPHCP));
2695 Mustek_SendData (chip, ES01_1E9_PHCP_TIMING_ADJ_B1, (SANE_Byte) (dwPHCP >> 8));
2696 Mustek_SendData (chip, ES01_1EA_PHCP_TIMING_ADJ_B2, (SANE_Byte) (dwPHCP >> 16));
2697 Mustek_SendData (chip, ES01_1EB_PHCP_TIMING_ADJ_B3, (SANE_Byte) (dwPHCP >> 24));
2698
2699 chip->firmwarestate = FS_OPENED;
2700 DBG (DBG_ASIC, "CCDTiming:Exit\n");
2701 return status;
2702 }
2703
2704 static SANE_Status
IsCarriageHome(PAsic chip, SANE_Bool * LampHome, SANE_Bool * TAHome)2705 IsCarriageHome (PAsic chip, SANE_Bool * LampHome, SANE_Bool * TAHome)
2706 {
2707 SANE_Status status = SANE_STATUS_GOOD;
2708 SANE_Byte temp;
2709
2710 DBG (DBG_ASIC, "IsCarriageHome:Enter\n");
2711
2712 status = GetChipStatus (chip, 0, &temp);
2713 if (status != SANE_STATUS_GOOD)
2714 {
2715 DBG (DBG_ASIC, "IsCarriageHome:Error!\n");
2716 return status;
2717 }
2718
2719 if ((temp & SENSOR0_DETECTED) == SENSOR0_DETECTED)
2720 *LampHome = TRUE;
2721 else
2722 {
2723 *LampHome = FALSE;
2724 }
2725
2726 *TAHome = TRUE;
2727
2728 DBG (DBG_ASIC, "LampHome=%d\n", *LampHome);
2729
2730 DBG (DBG_ASIC, "IsCarriageHome:Exit\n");
2731 return status;
2732 }
2733
2734
2735 static SANE_Status
GetChipStatus(PAsic chip, SANE_Byte Selector, SANE_Byte * ChipStatus)2736 GetChipStatus (PAsic chip, SANE_Byte Selector, SANE_Byte * ChipStatus)
2737 {
2738 SANE_Status status = SANE_STATUS_GOOD;
2739 DBG (DBG_ASIC, "GetChipStatus:Enter\n");
2740
2741 status = Mustek_SendData (chip, ES01_8B_Status, Selector);
2742 if (status != SANE_STATUS_GOOD)
2743 return status;
2744
2745 status = Mustek_WriteAddressLineForRegister (chip, ES01_8B_Status);
2746 if (status != SANE_STATUS_GOOD)
2747 return status;
2748
2749 *ChipStatus = ES01_8B_Status;
2750 status = Mustek_ReceiveData (chip, ChipStatus);
2751 if (status != SANE_STATUS_GOOD)
2752 return status;
2753
2754 DBG (DBG_ASIC, "GetChipStatus:Exit\n");
2755 return status;
2756 }
2757
2758 static SANE_Status
SetAFEGainOffset(PAsic chip)2759 SetAFEGainOffset (PAsic chip)
2760 {
2761 SANE_Status status = SANE_STATUS_GOOD;
2762 int i = 0;
2763
2764 DBG (DBG_ASIC, "SetAFEGainOffset:Enter\n");
2765
2766 if (chip->AD.DirectionR)
2767 { /* Negative */
2768 Mustek_SendData (chip, ES01_60_AFE_AUTO_GAIN_OFFSET_RED_LB,
2769 (chip->AD.GainR << 1) | 0x01);
2770 Mustek_SendData (chip, ES01_61_AFE_AUTO_GAIN_OFFSET_RED_HB,
2771 chip->AD.OffsetR);
2772 }
2773 else
2774 { /* Positive */
2775 Mustek_SendData (chip, ES01_60_AFE_AUTO_GAIN_OFFSET_RED_LB,
2776 (chip->AD.GainR << 1));
2777 Mustek_SendData (chip, ES01_61_AFE_AUTO_GAIN_OFFSET_RED_HB,
2778 chip->AD.OffsetR);
2779 }
2780
2781 if (chip->AD.DirectionG)
2782 {
2783 Mustek_SendData (chip, ES01_62_AFE_AUTO_GAIN_OFFSET_GREEN_LB,
2784 (chip->AD.GainG << 1) | 0x01);
2785 Mustek_SendData (chip, ES01_63_AFE_AUTO_GAIN_OFFSET_GREEN_HB,
2786 chip->AD.OffsetG);
2787 }
2788 else
2789 {
2790 Mustek_SendData (chip, ES01_62_AFE_AUTO_GAIN_OFFSET_GREEN_LB,
2791 (chip->AD.GainG << 1));
2792
2793 Mustek_SendData (chip, ES01_63_AFE_AUTO_GAIN_OFFSET_GREEN_HB,
2794 chip->AD.OffsetG);
2795 }
2796
2797 if (chip->AD.DirectionB)
2798 {
2799 Mustek_SendData (chip, ES01_64_AFE_AUTO_GAIN_OFFSET_BLUE_LB,
2800 (chip->AD.GainB << 1) | 0x01);
2801 Mustek_SendData (chip, ES01_65_AFE_AUTO_GAIN_OFFSET_BLUE_HB,
2802 chip->AD.OffsetB);
2803 }
2804 else
2805 {
2806 Mustek_SendData (chip, ES01_64_AFE_AUTO_GAIN_OFFSET_BLUE_LB,
2807 (chip->AD.GainB << 1));
2808 Mustek_SendData (chip, ES01_65_AFE_AUTO_GAIN_OFFSET_BLUE_HB,
2809 chip->AD.OffsetB);
2810 }
2811
2812
2813 Mustek_SendData (chip, ES01_2A0_AFE_GAIN_OFFSET_CONTROL, 0x01);
2814
2815 for (i = 0; i < 4; i++)
2816 {
2817
2818 if (chip->AD.DirectionR == 0)
2819 {
2820 Mustek_SendData (chip, ES01_2A1_AFE_AUTO_CONFIG_GAIN,
2821 (SANE_Byte) (chip->AD.GainR << 1));
2822 Mustek_SendData (chip, ES01_2A2_AFE_AUTO_CONFIG_OFFSET,
2823 (SANE_Byte) (chip->AD.OffsetR));
2824 }
2825 else
2826 {
2827 Mustek_SendData (chip, ES01_2A1_AFE_AUTO_CONFIG_GAIN,
2828 (SANE_Byte) (chip->AD.GainR << 1) | 0x01);
2829 Mustek_SendData (chip, ES01_2A2_AFE_AUTO_CONFIG_OFFSET,
2830 (SANE_Byte) (chip->AD.OffsetR));
2831 }
2832 }
2833
2834 for (i = 0; i < 4; i++)
2835 {
2836 if (chip->AD.DirectionG == 0)
2837 {
2838 Mustek_SendData (chip, ES01_2A1_AFE_AUTO_CONFIG_GAIN,
2839 (SANE_Byte) (chip->AD.GainG << 1));
2840 Mustek_SendData (chip, ES01_2A2_AFE_AUTO_CONFIG_OFFSET,
2841 (SANE_Byte) (chip->AD.OffsetG));
2842 }
2843 else
2844 {
2845 Mustek_SendData (chip, ES01_2A1_AFE_AUTO_CONFIG_GAIN,
2846 (SANE_Byte) (chip->AD.GainG << 1) | 0x01);
2847 Mustek_SendData (chip, ES01_2A2_AFE_AUTO_CONFIG_OFFSET,
2848 (SANE_Byte) (chip->AD.OffsetG));
2849 }
2850 }
2851
2852 for (i = 0; i < 4; i++)
2853 {
2854 if (chip->AD.DirectionB == 0)
2855 {
2856 Mustek_SendData (chip, ES01_2A1_AFE_AUTO_CONFIG_GAIN,
2857 (SANE_Byte) (chip->AD.GainB << 1));
2858 Mustek_SendData (chip, ES01_2A2_AFE_AUTO_CONFIG_OFFSET,
2859 (SANE_Byte) (chip->AD.OffsetB));
2860 }
2861 else
2862 {
2863 Mustek_SendData (chip, ES01_2A1_AFE_AUTO_CONFIG_GAIN,
2864 (SANE_Byte) (chip->AD.GainB << 1) | 0x01);
2865 Mustek_SendData (chip, ES01_2A2_AFE_AUTO_CONFIG_OFFSET,
2866 (SANE_Byte) (chip->AD.OffsetB));
2867 }
2868 }
2869
2870 for (i = 0; i < 36; i++)
2871 {
2872 Mustek_SendData (chip, ES01_2A1_AFE_AUTO_CONFIG_GAIN, 0);
2873 Mustek_SendData (chip, ES01_2A2_AFE_AUTO_CONFIG_OFFSET, 0);
2874 }
2875
2876 Mustek_SendData (chip, ES01_2A0_AFE_GAIN_OFFSET_CONTROL, 0x00);
2877
2878 /* Set to AFE */
2879 Mustek_SendData (chip, ES01_04_ADAFEPGACH1, chip->AD.GainR);
2880 Mustek_SendData (chip, ES01_06_ADAFEPGACH2, chip->AD.GainG);
2881 Mustek_SendData (chip, ES01_08_ADAFEPGACH3, chip->AD.GainB);
2882
2883 if (chip->AD.DirectionR)
2884 Mustek_SendData (chip, ES01_0B_AD9826OffsetRedN, chip->AD.OffsetR);
2885 else
2886 Mustek_SendData (chip, ES01_0A_AD9826OffsetRedP, chip->AD.OffsetR);
2887
2888 if (chip->AD.DirectionG)
2889 Mustek_SendData (chip, ES01_0D_AD9826OffsetGreenN, chip->AD.OffsetG);
2890 else
2891 Mustek_SendData (chip, ES01_0C_AD9826OffsetGreenP, chip->AD.OffsetG);
2892
2893 if (chip->AD.DirectionB)
2894 Mustek_SendData (chip, ES01_0F_AD9826OffsetBlueN, chip->AD.OffsetB);
2895 else
2896 Mustek_SendData (chip, ES01_0E_AD9826OffsetBlueP, chip->AD.OffsetB);
2897
2898
2899 LLFSetRamAddress (chip, 0x0, PackAreaStartAddress - (512 * 8 - 1),
2900 ACCESS_DRAM);
2901
2902 Mustek_SendData (chip, ES01_F3_ActionOption,
2903 MOTOR_MOVE_TO_FIRST_LINE_DISABLE |
2904 MOTOR_BACK_HOME_AFTER_SCAN_DISABLE |
2905 SCAN_ENABLE |
2906 SCAN_BACK_TRACKING_DISABLE |
2907 INVERT_MOTOR_DIRECTION_DISABLE |
2908 UNIFORM_MOTOR_AND_SCAN_SPEED_ENABLE |
2909 ES01_STATIC_SCAN_DISABLE | MOTOR_TEST_LOOP_DISABLE);
2910
2911 Mustek_SendData (chip, ES01_9A_AFEControl,
2912 AD9826_AFE | AUTO_CHANGE_AFE_GAIN_OFFSET_DISABLE);
2913
2914 Mustek_SendData (chip, ES01_00_ADAFEConfiguration, 0x70);
2915 Mustek_SendData (chip, ES01_02_ADAFEMuxConfig, 0x80);
2916
2917 DBG (DBG_ASIC, "SetAFEGainOffset:Exit\n");
2918 return status;
2919 }
2920
2921 static SANE_Status
SetLEDTime(PAsic chip)2922 SetLEDTime (PAsic chip)
2923 {
2924 SANE_Status status = SANE_STATUS_GOOD;
2925 DBG (DBG_ASIC, "SetLEDTime:Enter\n");
2926
2927 Mustek_SendData (chip, ES01_B8_ChannelRedExpStartPixelLSB,
2928 LOBYTE (chip->Timing.ChannelR_StartPixel));
2929 Mustek_SendData (chip, ES01_B9_ChannelRedExpStartPixelMSB,
2930 HIBYTE (chip->Timing.ChannelR_StartPixel));
2931 Mustek_SendData (chip, ES01_BA_ChannelRedExpEndPixelLSB,
2932 LOBYTE (chip->Timing.ChannelR_EndPixel));
2933 Mustek_SendData (chip, ES01_BB_ChannelRedExpEndPixelMSB,
2934 HIBYTE (chip->Timing.ChannelR_EndPixel));
2935
2936 Mustek_SendData (chip, ES01_BC_ChannelGreenExpStartPixelLSB,
2937 LOBYTE (chip->Timing.ChannelG_StartPixel));
2938 Mustek_SendData (chip, ES01_BD_ChannelGreenExpStartPixelMSB,
2939 HIBYTE (chip->Timing.ChannelG_StartPixel));
2940 Mustek_SendData (chip, ES01_BE_ChannelGreenExpEndPixelLSB,
2941 LOBYTE (chip->Timing.ChannelG_EndPixel));
2942 Mustek_SendData (chip, ES01_BF_ChannelGreenExpEndPixelMSB,
2943 HIBYTE (chip->Timing.ChannelG_EndPixel));
2944
2945 Mustek_SendData (chip, ES01_C0_ChannelBlueExpStartPixelLSB,
2946 LOBYTE (chip->Timing.ChannelB_StartPixel));
2947 Mustek_SendData (chip, ES01_C1_ChannelBlueExpStartPixelMSB,
2948 HIBYTE (chip->Timing.ChannelB_StartPixel));
2949 Mustek_SendData (chip, ES01_C2_ChannelBlueExpEndPixelLSB,
2950 LOBYTE (chip->Timing.ChannelB_EndPixel));
2951 Mustek_SendData (chip, ES01_C3_ChannelBlueExpEndPixelMSB,
2952 HIBYTE (chip->Timing.ChannelB_EndPixel));
2953
2954 DBG (DBG_ASIC, "SetLEDTime:Exit\n");
2955 return status;
2956 }
2957
2958 static SANE_Status
SetScanMode(PAsic chip, SANE_Byte bScanBits)2959 SetScanMode (PAsic chip, SANE_Byte bScanBits)
2960 {
2961 SANE_Status status = SANE_STATUS_GOOD;
2962 SANE_Byte temp_f5_register = 0;
2963 SANE_Byte GrayBWChannel;
2964
2965 DBG (DBG_ASIC, "SetScanMode():Enter; set f5 register\n");
2966
2967 if (bScanBits >= 24)
2968 {
2969 temp_f5_register |= COLOR_ES02;
2970 }
2971 else
2972 {
2973 temp_f5_register |= GRAY_ES02;
2974 }
2975
2976 if ((bScanBits == 8) || (bScanBits == 24))
2977 {
2978 temp_f5_register |= _8_BITS_ES02;
2979 }
2980 else if (bScanBits == 1)
2981 {
2982 temp_f5_register |= _1_BIT_ES02;
2983 }
2984 else
2985 {
2986 temp_f5_register |= _16_BITS_ES02;
2987 }
2988
2989 if (bScanBits < 24)
2990 {
2991 GrayBWChannel = 1;
2992 }
2993 else
2994 {
2995 GrayBWChannel = 4;
2996 }
2997
2998 if (GrayBWChannel == 0)
2999 {
3000 temp_f5_register |= GRAY_RED_ES02;
3001 }
3002 else if (GrayBWChannel == 1)
3003 {
3004 temp_f5_register |= GRAY_GREEN_ES02;
3005 }
3006 else if (GrayBWChannel == 2)
3007 {
3008 temp_f5_register |= GRAY_BLUE_ES02;
3009 }
3010 else
3011 {
3012 temp_f5_register |= GRAY_GREEN_BLUE_ES02;
3013 }
3014
3015 status = Mustek_SendData (chip, ES01_F5_ScanDataFormat, temp_f5_register);
3016
3017 DBG (DBG_ASIC, "F5_ScanDataFormat=0x%x\n", temp_f5_register);
3018 DBG (DBG_ASIC, "SetScanMode():Exit\n");
3019 return status;
3020 }
3021
3022 static SANE_Status
SetPackAddress(PAsic chip, unsigned short wXResolution, unsigned short wWidth, unsigned short wX, double XRatioAdderDouble, double XRatioTypeDouble, SANE_Byte byClear_Pulse_Width, unsigned short * PValidPixelNumber)3023 SetPackAddress (PAsic chip, unsigned short wXResolution, unsigned short wWidth, unsigned short wX,
3024 double XRatioAdderDouble, double XRatioTypeDouble,
3025 SANE_Byte byClear_Pulse_Width, unsigned short * PValidPixelNumber)
3026 {
3027 SANE_Status status = SANE_STATUS_GOOD;
3028
3029 SANE_Byte OverLapPixel;
3030 SANE_Byte TotalLineShift;
3031 unsigned short SegmentTotalPixel;
3032 unsigned int dwLineTotalPixel;
3033 unsigned short ValidPixelNumber = *PValidPixelNumber;
3034
3035 unsigned int FinalLinePixelPerSegment;
3036 SANE_Byte InValidPixelNumber;
3037 unsigned int CISPackAreaStartAddress;
3038 SANE_Byte PackAreaUseLine;
3039
3040 unsigned int MaxPixelHW;
3041 int i;
3042
3043 DBG (DBG_ASIC, "SetPackAddress:Enter\n");
3044
3045 OverLapPixel = 0;
3046 TotalLineShift = 1;
3047 PackAreaUseLine = TotalLineShift + 1;
3048
3049 if (wXResolution > (SENSOR_DPI / 2))
3050 {
3051 ValidPixelNumber = ValidPixelNumberFor1200DPI;
3052 OverLapPixel = OverLapPixelNumber1200;
3053 }
3054 else
3055 {
3056 ValidPixelNumber = ValidPixelNumberFor600DPI;
3057 OverLapPixel = OverLapPixelNumber600;
3058 }
3059
3060 ValidPixelNumber = (unsigned short) ((wWidth + 10 + 15) * XRatioAdderDouble);
3061 ValidPixelNumber >>= 4;
3062 ValidPixelNumber <<= 4;
3063
3064 ValidPixelNumber += (OverLapPixel * 2);
3065
3066 for (i = 0; i < 16; i++)
3067 {
3068 Mustek_SendData (chip, ES01_2B0_SEGMENT0_OVERLAP_SEGMENT1 + i,
3069 OverLapPixel);
3070 Mustek_SendData (chip, ES01_2C0_VALID_PIXEL_PARAMETER_OF_SEGMENT1 + i,
3071 0);
3072 }
3073
3074 FinalLinePixelPerSegment = ValidPixelNumber + OverLapPixel * 2;
3075
3076 if ((FinalLinePixelPerSegment % 8) > 0)
3077 {
3078 InValidPixelNumber = (SANE_Byte) (8 - (FinalLinePixelPerSegment % 8));
3079 }
3080 else
3081 {
3082 InValidPixelNumber = 0;
3083 }
3084
3085 Mustek_SendData (chip, ES01_1B0_SEGMENT_PIXEL_NUMBER_LB,
3086 LOBYTE (ValidPixelNumber));
3087 Mustek_SendData (chip, ES01_1B1_SEGMENT_PIXEL_NUMBER_HB,
3088 HIBYTE (ValidPixelNumber));
3089
3090 SegmentTotalPixel =
3091 ValidPixelNumber + OverLapPixel * 2 + InValidPixelNumber;
3092
3093 Mustek_SendData (chip, ES01_169_NUMBER_OF_SEGMENT_PIXEL_LB,
3094 LOBYTE (ValidPixelNumber));
3095 Mustek_SendData (chip, ES01_16A_NUMBER_OF_SEGMENT_PIXEL_HB,
3096 HIBYTE (ValidPixelNumber));
3097 Mustek_SendData (chip, ES01_16B_BETWEEN_SEGMENT_INVALID_PIXEL, 0);
3098
3099 Mustek_SendData (chip, ES01_B6_LineWidthPixelLSB,
3100 LOBYTE (ValidPixelNumber));
3101 Mustek_SendData (chip, ES01_B7_LineWidthPixelMSB,
3102 HIBYTE (ValidPixelNumber));
3103
3104 Mustek_SendData (chip, ES01_19A_CHANNEL_LINE_GAP_LB,
3105 LOBYTE (ValidPixelNumber));
3106 Mustek_SendData (chip, ES01_19B_CHANNEL_LINE_GAP_HB,
3107 HIBYTE (ValidPixelNumber));
3108 DBG (DBG_ASIC, "ValidPixelNumber=%d\n", ValidPixelNumber);
3109
3110 for (i = 0; i < 36; i++)
3111 {
3112 Mustek_SendData (chip, 0x270 + i, 0);
3113 }
3114
3115 Mustek_SendData (chip, 0x270,
3116 (SANE_Byte) ((SegmentTotalPixel * (PackAreaUseLine) * 1)));
3117 Mustek_SendData (chip, 0x271,
3118 (SANE_Byte) ((SegmentTotalPixel * (PackAreaUseLine) * 1) >> 8));
3119 Mustek_SendData (chip, 0x272,
3120 (SANE_Byte) ((SegmentTotalPixel * (PackAreaUseLine) *
3121 1) >> 16));
3122
3123 Mustek_SendData (chip, 0x27C,
3124 (SANE_Byte) ((SegmentTotalPixel * (PackAreaUseLine) * 2)));
3125 Mustek_SendData (chip, 0x27D,
3126 (SANE_Byte) ((SegmentTotalPixel * (PackAreaUseLine) * 2) >> 8));
3127 Mustek_SendData (chip, 0x27E,
3128 (SANE_Byte) ((SegmentTotalPixel * (PackAreaUseLine) *
3129 2) >> 16));
3130
3131 Mustek_SendData (chip, 0x288,
3132 (SANE_Byte) ((SegmentTotalPixel * (PackAreaUseLine) * 3)));
3133 Mustek_SendData (chip, 0x289,
3134 (SANE_Byte) ((SegmentTotalPixel * (PackAreaUseLine) * 3) >> 8));
3135 Mustek_SendData (chip, 0x28A,
3136 (SANE_Byte) ((SegmentTotalPixel * (PackAreaUseLine) *
3137 3) >> 16));
3138 DBG (DBG_ASIC, "channel gap=%d\n", SegmentTotalPixel * (PackAreaUseLine));
3139
3140
3141 Mustek_SendData (chip, ES01_B4_StartPixelLSB, LOBYTE (wX + 0));
3142 Mustek_SendData (chip, ES01_B5_StartPixelMSB, HIBYTE (wX + 0));
3143
3144
3145 dwLineTotalPixel = ValidPixelNumber;
3146
3147 Mustek_SendData (chip, ES01_1B9_LINE_PIXEL_NUMBER_LB,
3148 LOBYTE (XRatioTypeDouble * (dwLineTotalPixel - 1)));
3149 Mustek_SendData (chip, ES01_1BA_LINE_PIXEL_NUMBER_HB,
3150 HIBYTE (XRatioTypeDouble * (dwLineTotalPixel - 1)));
3151
3152 /* final start read out pixel */
3153 Mustek_SendData (chip, ES01_1F4_START_READ_OUT_PIXEL_LB, LOBYTE (0));
3154 Mustek_SendData (chip, ES01_1F5_START_READ_OUT_PIXEL_HB, HIBYTE (0));
3155
3156 MaxPixelHW = (dwLineTotalPixel + InValidPixelNumber) - 10;
3157
3158 if (wWidth > MaxPixelHW)
3159 {
3160 DBG (DBG_ERR, "read out pixel over max pixel! image will shift!!!\n");
3161 }
3162
3163 /* final read pixel width */
3164 Mustek_SendData (chip, ES01_1F6_READ_OUT_PIXEL_LENGTH_LB,
3165 LOBYTE (wWidth + 9));
3166 Mustek_SendData (chip, ES01_1F7_READ_OUT_PIXEL_LENGTH_HB,
3167 HIBYTE (wWidth + 9));
3168
3169 /* data output sequence */
3170 Mustek_SendData (chip, ES01_1F8_PACK_CHANNEL_SELECT_B0, 0);
3171 Mustek_SendData (chip, ES01_1F9_PACK_CHANNEL_SELECT_B1, 0);
3172 Mustek_SendData (chip, ES01_1FA_PACK_CHANNEL_SELECT_B2, 0x18);
3173
3174 Mustek_SendData (chip, ES01_1FB_PACK_CHANNEL_SIZE_B0,
3175 (SANE_Byte) ((SegmentTotalPixel * PackAreaUseLine)));
3176 Mustek_SendData (chip, ES01_1FC_PACK_CHANNEL_SIZE_B1,
3177 (SANE_Byte) ((SegmentTotalPixel * PackAreaUseLine) >> 8));
3178 Mustek_SendData (chip, ES01_1FD_PACK_CHANNEL_SIZE_B2,
3179 (SANE_Byte) ((SegmentTotalPixel * PackAreaUseLine) >> 16));
3180
3181 Mustek_SendData (chip, ES01_16C_LINE_SHIFT_OUT_TIMES_DIRECTION, 0x01);
3182 Mustek_SendData (chip, ES01_1CE_LINE_SEGMENT_NUMBER, 0x00);
3183 Mustek_SendData (chip, ES01_D8_PHTG_EDGE_TIMING_ADJUST, 0x17);
3184
3185 Mustek_SendData (chip, ES01_D9_CLEAR_PULSE_WIDTH, byClear_Pulse_Width);
3186
3187 Mustek_SendData (chip, ES01_DA_CLEAR_SIGNAL_INVERTING_OUTPUT, 0x54 | 0x01);
3188 Mustek_SendData (chip, ES01_CD_TG_R_CONTROL, 0x3C);
3189 Mustek_SendData (chip, ES01_CE_TG_G_CONTROL, 0);
3190 Mustek_SendData (chip, ES01_CF_TG_B_CONTROL, 0x3C);
3191
3192
3193 /* set pack area address */
3194
3195 CISPackAreaStartAddress = PackAreaStartAddress;
3196 DBG (DBG_ASIC, "CISPackAreaStartAddress=%d\n", CISPackAreaStartAddress);
3197
3198 /* cycle 1 */
3199 Mustek_SendData (chip, ES01_16D_EXPOSURE_CYCLE1_SEGMENT1_START_ADDR_BYTE0,
3200 (SANE_Byte) ((CISPackAreaStartAddress + 0)));
3201 Mustek_SendData (chip, ES01_16E_EXPOSURE_CYCLE1_SEGMENT1_START_ADDR_BYTE1,
3202 (SANE_Byte) ((CISPackAreaStartAddress + 0) >> 8));
3203 Mustek_SendData (chip, ES01_16F_EXPOSURE_CYCLE1_SEGMENT1_START_ADDR_BYTE2,
3204 (SANE_Byte) ((CISPackAreaStartAddress + 0) >> 16));
3205
3206 Mustek_SendData (chip, ES01_170_EXPOSURE_CYCLE1_SEGMENT2_START_ADDR_BYTE0,
3207 (SANE_Byte) ((CISPackAreaStartAddress + 0xC0000)));
3208 Mustek_SendData (chip, ES01_171_EXPOSURE_CYCLE1_SEGMENT2_START_ADDR_BYTE1,
3209 (SANE_Byte) ((CISPackAreaStartAddress + 0xC0000) >> 8));
3210 Mustek_SendData (chip, ES01_172_EXPOSURE_CYCLE1_SEGMENT2_START_ADDR_BYTE2,
3211 (SANE_Byte) ((CISPackAreaStartAddress + 0xC0000) >> 16));
3212
3213 Mustek_SendData (chip, ES01_173_EXPOSURE_CYCLE1_SEGMENT3_START_ADDR_BYTE0,
3214 (SANE_Byte) ((CISPackAreaStartAddress + 0xC0000)));
3215 Mustek_SendData (chip, ES01_174_EXPOSURE_CYCLE1_SEGMENT3_START_ADDR_BYTE1,
3216 (SANE_Byte) ((CISPackAreaStartAddress + 0xC0000) >> 8));
3217 Mustek_SendData (chip, ES01_175_EXPOSURE_CYCLE1_SEGMENT3_START_ADDR_BYTE2,
3218 (SANE_Byte) ((CISPackAreaStartAddress + 0xC0000) >> 16));
3219
3220 Mustek_SendData (chip, ES01_176_EXPOSURE_CYCLE1_SEGMENT4_START_ADDR_BYTE0,
3221 (SANE_Byte) ((CISPackAreaStartAddress + 0xC0000)));
3222 Mustek_SendData (chip, ES01_177_EXPOSURE_CYCLE1_SEGMENT4_START_ADDR_BYTE1,
3223 (SANE_Byte) ((CISPackAreaStartAddress + 0xC0000) >> 8));
3224 Mustek_SendData (chip, ES01_178_EXPOSURE_CYCLE1_SEGMENT4_START_ADDR_BYTE2,
3225 (SANE_Byte) ((CISPackAreaStartAddress + 0xC0000) >> 16));
3226
3227 /* cycle 2 */
3228 Mustek_SendData (chip, ES01_179_EXPOSURE_CYCLE2_SEGMENT1_START_ADDR_BYTE0,
3229 (SANE_Byte) ((CISPackAreaStartAddress + 0xC0000)));
3230 Mustek_SendData (chip, ES01_17A_EXPOSURE_CYCLE2_SEGMENT1_START_ADDR_BYTE1,
3231 (SANE_Byte) ((CISPackAreaStartAddress + 0xC0000) >> 8));
3232 Mustek_SendData (chip, ES01_17B_EXPOSURE_CYCLE2_SEGMENT1_START_ADDR_BYTE2,
3233 (SANE_Byte) ((CISPackAreaStartAddress + 0xC0000) >> 16));
3234
3235 Mustek_SendData (chip, ES01_17C_EXPOSURE_CYCLE2_SEGMENT2_START_ADDR_BYTE0,
3236 (SANE_Byte) ((CISPackAreaStartAddress + 0xC0000)));
3237 Mustek_SendData (chip, ES01_17D_EXPOSURE_CYCLE2_SEGMENT2_START_ADDR_BYTE1,
3238 (SANE_Byte) ((CISPackAreaStartAddress + 0xC0000) >> 8));
3239 Mustek_SendData (chip, ES01_17E_EXPOSURE_CYCLE2_SEGMENT2_START_ADDR_BYTE2,
3240 (SANE_Byte) ((CISPackAreaStartAddress + 0xC0000) >> 16));
3241
3242 Mustek_SendData (chip, ES01_17F_EXPOSURE_CYCLE2_SEGMENT3_START_ADDR_BYTE0,
3243 (SANE_Byte) ((CISPackAreaStartAddress + 0xC0000)));
3244 Mustek_SendData (chip, ES01_180_EXPOSURE_CYCLE2_SEGMENT3_START_ADDR_BYTE1,
3245 (SANE_Byte) ((CISPackAreaStartAddress + 0xC0000) >> 8));
3246 Mustek_SendData (chip, ES01_181_EXPOSURE_CYCLE2_SEGMENT3_START_ADDR_BYTE2,
3247 (SANE_Byte) ((CISPackAreaStartAddress + 0xC0000) >> 16));
3248
3249 Mustek_SendData (chip, ES01_182_EXPOSURE_CYCLE2_SEGMENT4_START_ADDR_BYTE0,
3250 (SANE_Byte) ((CISPackAreaStartAddress + 0xC0000)));
3251 Mustek_SendData (chip, ES01_183_EXPOSURE_CYCLE2_SEGMENT4_START_ADDR_BYTE1,
3252 (SANE_Byte) ((CISPackAreaStartAddress + 0xC0000) >> 8));
3253 Mustek_SendData (chip, ES01_184_EXPOSURE_CYCLE2_SEGMENT4_START_ADDR_BYTE2,
3254 (SANE_Byte) ((CISPackAreaStartAddress + 0xC0000) >> 16));
3255
3256 /* cycle 3 */
3257 Mustek_SendData (chip, ES01_185_EXPOSURE_CYCLE3_SEGMENT1_START_ADDR_BYTE0,
3258 (SANE_Byte) ((CISPackAreaStartAddress + 0xC0000)));
3259
3260 Mustek_SendData (chip, ES01_186_EXPOSURE_CYCLE3_SEGMENT1_START_ADDR_BYTE1,
3261 (SANE_Byte) ((CISPackAreaStartAddress + 0xC0000) >> 8));
3262 Mustek_SendData (chip, ES01_187_EXPOSURE_CYCLE3_SEGMENT1_START_ADDR_BYTE2,
3263 (SANE_Byte) ((CISPackAreaStartAddress + 0xC0000) >> 16));
3264
3265 Mustek_SendData (chip, ES01_188_EXPOSURE_CYCLE3_SEGMENT2_START_ADDR_BYTE0,
3266 (SANE_Byte) ((CISPackAreaStartAddress + 0xC0000)));
3267 Mustek_SendData (chip, ES01_189_EXPOSURE_CYCLE3_SEGMENT2_START_ADDR_BYTE1,
3268 (SANE_Byte) ((CISPackAreaStartAddress + 0xC0000) >> 8));
3269 Mustek_SendData (chip, ES01_18A_EXPOSURE_CYCLE3_SEGMENT2_START_ADDR_BYTE2,
3270 (SANE_Byte) ((CISPackAreaStartAddress + 0xC0000) >> 16));
3271
3272 Mustek_SendData (chip, ES01_18B_EXPOSURE_CYCLE3_SEGMENT3_START_ADDR_BYTE0,
3273 (SANE_Byte) ((CISPackAreaStartAddress + 0xC0000)));
3274 Mustek_SendData (chip, ES01_18C_EXPOSURE_CYCLE3_SEGMENT3_START_ADDR_BYTE1,
3275 (SANE_Byte) ((CISPackAreaStartAddress + 0xC0000) >> 8));
3276 Mustek_SendData (chip, ES01_18D_EXPOSURE_CYCLE3_SEGMENT3_START_ADDR_BYTE2,
3277 (SANE_Byte) ((CISPackAreaStartAddress + 0xC0000) >> 16));
3278
3279 Mustek_SendData (chip, ES01_18E_EXPOSURE_CYCLE3_SEGMENT4_START_ADDR_BYTE0,
3280 (SANE_Byte) ((CISPackAreaStartAddress + 0xC0000)));
3281 Mustek_SendData (chip, ES01_18F_EXPOSURE_CYCLE3_SEGMENT4_START_ADDR_BYTE1,
3282 (SANE_Byte) ((CISPackAreaStartAddress + 0xC0000) >> 8));
3283 Mustek_SendData (chip, ES01_190_EXPOSURE_CYCLE3_SEGMENT4_START_ADDR_BYTE2,
3284 (SANE_Byte) ((CISPackAreaStartAddress + 0xC0000) >> 16));
3285 DBG (DBG_ASIC, "set CISPackAreaStartAddress ok\n");
3286
3287 Mustek_SendData (chip, 0x260, InValidPixelNumber);
3288 Mustek_SendData (chip, 0x261, InValidPixelNumber << 4);
3289 Mustek_SendData (chip, 0x262, InValidPixelNumber);
3290 Mustek_SendData (chip, 0x263, 0);
3291 DBG (DBG_ASIC, "InValidPixelNumber=%d\n", InValidPixelNumber);
3292
3293 Mustek_SendData (chip, 0x264, 0);
3294 Mustek_SendData (chip, 0x265, 0);
3295 Mustek_SendData (chip, 0x266, 0);
3296 Mustek_SendData (chip, 0x267, 0);
3297
3298 Mustek_SendData (chip, 0x268, 0);
3299 Mustek_SendData (chip, 0x269, 0);
3300 Mustek_SendData (chip, 0x26A, 0);
3301 Mustek_SendData (chip, 0x26B, 0);
3302
3303 Mustek_SendData (chip, 0x26C, 0);
3304 Mustek_SendData (chip, 0x26D, 0);
3305 Mustek_SendData (chip, 0x26E, 0);
3306 Mustek_SendData (chip, 0x26F, 0);
3307 DBG (DBG_ASIC, "Set Invalid Pixel ok\n");
3308
3309
3310 /* Pack Start Address */
3311 Mustek_SendData (chip, ES01_19E_PACK_AREA_R_START_ADDR_BYTE0,
3312 (SANE_Byte) ((CISPackAreaStartAddress +
3313 (SegmentTotalPixel * (PackAreaUseLine * 0)))));
3314 Mustek_SendData (chip, ES01_19F_PACK_AREA_R_START_ADDR_BYTE1,
3315 (SANE_Byte) ((CISPackAreaStartAddress +
3316 (SegmentTotalPixel *
3317 (PackAreaUseLine * 0))) >> 8));
3318 Mustek_SendData (chip, ES01_1A0_PACK_AREA_R_START_ADDR_BYTE2,
3319 (SANE_Byte) ((CISPackAreaStartAddress +
3320 (SegmentTotalPixel *
3321 (PackAreaUseLine * 0))) >> 16));
3322
3323
3324 Mustek_SendData (chip, ES01_1A1_PACK_AREA_G_START_ADDR_BYTE0,
3325 (SANE_Byte) ((CISPackAreaStartAddress +
3326 (SegmentTotalPixel * (PackAreaUseLine * 1)))));
3327 Mustek_SendData (chip, ES01_1A2_PACK_AREA_G_START_ADDR_BYTE1,
3328 (SANE_Byte) ((CISPackAreaStartAddress +
3329 (SegmentTotalPixel *
3330 (PackAreaUseLine * 1))) >> 8));
3331 Mustek_SendData (chip, ES01_1A3_PACK_AREA_G_START_ADDR_BYTE2,
3332 (SANE_Byte) ((CISPackAreaStartAddress +
3333 (SegmentTotalPixel *
3334 (PackAreaUseLine * 1))) >> 16));
3335
3336 Mustek_SendData (chip, ES01_1A4_PACK_AREA_B_START_ADDR_BYTE0,
3337 (SANE_Byte) ((CISPackAreaStartAddress +
3338 (SegmentTotalPixel * (PackAreaUseLine * 2)))));
3339 Mustek_SendData (chip, ES01_1A5_PACK_AREA_B_START_ADDR_BYTE1,
3340 (SANE_Byte) ((CISPackAreaStartAddress +
3341 (SegmentTotalPixel *
3342 (PackAreaUseLine * 2))) >> 8));
3343 Mustek_SendData (chip, ES01_1A6_PACK_AREA_B_START_ADDR_BYTE2,
3344 (SANE_Byte) ((CISPackAreaStartAddress +
3345 (SegmentTotalPixel *
3346 (PackAreaUseLine * 2))) >> 16));
3347
3348 /* Pack End Address */
3349 Mustek_SendData (chip, ES01_1A7_PACK_AREA_R_END_ADDR_BYTE0,
3350 (SANE_Byte) ((CISPackAreaStartAddress +
3351 (SegmentTotalPixel * (PackAreaUseLine * 1) -
3352 1))));
3353 Mustek_SendData (chip, ES01_1A8_PACK_AREA_R_END_ADDR_BYTE1,
3354 (SANE_Byte) ((CISPackAreaStartAddress +
3355 (SegmentTotalPixel * (PackAreaUseLine * 1) -
3356 1)) >> 8));
3357 Mustek_SendData (chip, ES01_1A9_PACK_AREA_R_END_ADDR_BYTE2,
3358 (SANE_Byte) ((CISPackAreaStartAddress +
3359 (SegmentTotalPixel * (PackAreaUseLine * 1) -
3360 1)) >> 16));
3361
3362 Mustek_SendData (chip, ES01_1AA_PACK_AREA_G_END_ADDR_BYTE0,
3363 (SANE_Byte) ((CISPackAreaStartAddress +
3364 (SegmentTotalPixel * (PackAreaUseLine * 2) -
3365 1))));
3366 Mustek_SendData (chip, ES01_1AB_PACK_AREA_G_END_ADDR_BYTE1,
3367 (SANE_Byte) ((CISPackAreaStartAddress +
3368 (SegmentTotalPixel * (PackAreaUseLine * 2) -
3369 1)) >> 8));
3370 Mustek_SendData (chip, ES01_1AC_PACK_AREA_G_END_ADDR_BYTE2,
3371 (SANE_Byte) ((CISPackAreaStartAddress +
3372 (SegmentTotalPixel * (PackAreaUseLine * 2) -
3373 1)) >> 16));
3374
3375 Mustek_SendData (chip, ES01_1AD_PACK_AREA_B_END_ADDR_BYTE0,
3376 (SANE_Byte) ((CISPackAreaStartAddress +
3377 (SegmentTotalPixel * (PackAreaUseLine * 3) -
3378 1))));
3379 Mustek_SendData (chip, ES01_1AE_PACK_AREA_B_END_ADDR_BYTE1,
3380 (SANE_Byte) ((CISPackAreaStartAddress +
3381 (SegmentTotalPixel * (PackAreaUseLine * 3) -
3382 1)) >> 8));
3383 Mustek_SendData (chip, ES01_1AF_PACK_AREA_B_END_ADDR_BYTE2,
3384 (SANE_Byte) ((CISPackAreaStartAddress +
3385 (SegmentTotalPixel * (PackAreaUseLine * 3) -
3386 1)) >> 16));
3387 DBG (DBG_ASIC,
3388 "CISPackAreaStartAddress + (SegmentTotalPixel*(PackAreaUseLine*1))=%d\n",
3389 (CISPackAreaStartAddress +
3390 (SegmentTotalPixel * (PackAreaUseLine * 1))));
3391
3392 Mustek_SendData (chip, ES01_19C_MAX_PACK_LINE, PackAreaUseLine);
3393
3394 status =
3395 Mustek_SendData (chip, ES01_19D_PACK_THRESHOLD_LINE, TotalLineShift);
3396 DBG (DBG_ASIC, "PackAreaUseLine=%d,TotalLineShift=%d\n", PackAreaUseLine,
3397 TotalLineShift);
3398
3399 *PValidPixelNumber = ValidPixelNumber;
3400
3401 DBG (DBG_ASIC, "SetPackAddress:Enter\n");
3402 return status;
3403 }
3404
3405 static SANE_Status
SetExtraSetting(PAsic chip, unsigned short wXResolution, unsigned short wCCD_PixelNumber, SANE_Bool isCaribrate)3406 SetExtraSetting (PAsic chip, unsigned short wXResolution, unsigned short wCCD_PixelNumber,
3407 SANE_Bool isCaribrate)
3408 {
3409 SANE_Status status = SANE_STATUS_GOOD;
3410 SANE_Byte byPHTG_PulseWidth, byPHTG_WaitWidth;
3411 SANE_Byte temp_ff_register = 0;
3412 SANE_Byte bThreshold = 128;
3413
3414 DBG (DBG_ASIC, "SetExtraSetting:Enter\n");
3415
3416 Mustek_SendData (chip, ES01_B8_ChannelRedExpStartPixelLSB,
3417 LOBYTE (chip->Timing.ChannelR_StartPixel));
3418 Mustek_SendData (chip, ES01_B9_ChannelRedExpStartPixelMSB,
3419 HIBYTE (chip->Timing.ChannelR_StartPixel));
3420 Mustek_SendData (chip, ES01_BA_ChannelRedExpEndPixelLSB,
3421 LOBYTE (chip->Timing.ChannelR_EndPixel));
3422 Mustek_SendData (chip, ES01_BB_ChannelRedExpEndPixelMSB,
3423 HIBYTE (chip->Timing.ChannelR_EndPixel));
3424
3425 Mustek_SendData (chip, ES01_BC_ChannelGreenExpStartPixelLSB,
3426 LOBYTE (chip->Timing.ChannelG_StartPixel));
3427 Mustek_SendData (chip, ES01_BD_ChannelGreenExpStartPixelMSB,
3428 HIBYTE (chip->Timing.ChannelG_StartPixel));
3429 Mustek_SendData (chip, ES01_BE_ChannelGreenExpEndPixelLSB,
3430 LOBYTE (chip->Timing.ChannelG_EndPixel));
3431 Mustek_SendData (chip, ES01_BF_ChannelGreenExpEndPixelMSB,
3432 HIBYTE (chip->Timing.ChannelG_EndPixel));
3433
3434 Mustek_SendData (chip, ES01_C0_ChannelBlueExpStartPixelLSB,
3435 LOBYTE (chip->Timing.ChannelB_StartPixel));
3436 Mustek_SendData (chip, ES01_C1_ChannelBlueExpStartPixelMSB,
3437 HIBYTE (chip->Timing.ChannelB_StartPixel));
3438 Mustek_SendData (chip, ES01_C2_ChannelBlueExpEndPixelLSB,
3439 LOBYTE (chip->Timing.ChannelB_EndPixel));
3440 Mustek_SendData (chip, ES01_C3_ChannelBlueExpEndPixelMSB,
3441 HIBYTE (chip->Timing.ChannelB_EndPixel));
3442
3443 byPHTG_PulseWidth = chip->Timing.PHTG_PluseWidth;
3444 byPHTG_WaitWidth = chip->Timing.PHTG_WaitWidth;
3445 Mustek_SendData (chip, ES01_B2_PHTGPulseWidth, byPHTG_PulseWidth);
3446 Mustek_SendData (chip, ES01_B3_PHTGWaitWidth, byPHTG_WaitWidth);
3447
3448 Mustek_SendData (chip, ES01_CC_PHTGTimingAdjust,
3449 chip->Timing.PHTG_TimingAdj);
3450 Mustek_SendData (chip, ES01_D0_PH1_0, chip->Timing.PHTG_TimingSetup);
3451
3452 DBG (DBG_ASIC, "ChannelR_StartPixel=%d,ChannelR_EndPixel=%d\n",
3453 chip->Timing.ChannelR_StartPixel, chip->Timing.ChannelR_EndPixel);
3454
3455 if (wXResolution == 1200)
3456 {
3457 Mustek_SendData (chip, ES01_DE_CCD_SETUP_REGISTER,
3458 chip->Timing.DE_CCD_SETUP_REGISTER_1200);
3459 }
3460 else
3461 {
3462 Mustek_SendData (chip, ES01_DE_CCD_SETUP_REGISTER,
3463 chip->Timing.DE_CCD_SETUP_REGISTER_600);
3464 }
3465
3466 if (isCaribrate == TRUE)
3467 {
3468 temp_ff_register |= BYPASS_DARK_SHADING_ENABLE;
3469 temp_ff_register |= BYPASS_WHITE_SHADING_ENABLE;
3470 }
3471 else /*Setwindow */
3472 {
3473 temp_ff_register |= BYPASS_DARK_SHADING_DISABLE;
3474 temp_ff_register |= BYPASS_WHITE_SHADING_DISABLE;
3475 }
3476
3477 temp_ff_register |= BYPASS_PRE_GAMMA_ENABLE;
3478
3479 temp_ff_register |= BYPASS_CONVOLUTION_ENABLE;
3480
3481
3482 temp_ff_register |= BYPASS_MATRIX_ENABLE;
3483
3484 temp_ff_register |= BYPASS_GAMMA_ENABLE;
3485
3486 if (isCaribrate == TRUE)
3487 {
3488 Mustek_SendData (chip, ES01_FF_SCAN_IMAGE_OPTION, 0xfc | (0x00 & 0x03));
3489 DBG (DBG_ASIC, "FF_SCAN_IMAGE_OPTION=0x%x\n", 0xfc | (0x00 & 0x03));
3490 }
3491 else /*Setwindow */
3492 {
3493 Mustek_SendData (chip, ES01_FF_SCAN_IMAGE_OPTION,
3494 temp_ff_register | (0x00 & 0x03));
3495 DBG (DBG_ASIC, "FF_SCAN_IMAGE_OPTION=0x%x\n",
3496 temp_ff_register | (0x00 & 0x03));
3497 }
3498
3499 /* pixel process time */
3500 Mustek_SendData (chip, ES01_B0_CCDPixelLSB, LOBYTE (wCCD_PixelNumber));
3501 Mustek_SendData (chip, ES01_B1_CCDPixelMSB, HIBYTE (wCCD_PixelNumber));
3502 Mustek_SendData (chip, ES01_DF_ICG_CONTROL, 0x17);
3503 DBG (DBG_ASIC, "wCCD_PixelNumber=%d\n", wCCD_PixelNumber);
3504
3505 Mustek_SendData (chip, ES01_88_LINE_ART_THRESHOLD_HIGH_VALUE, bThreshold);
3506 Mustek_SendData (chip, ES01_89_LINE_ART_THRESHOLD_LOW_VALUE,
3507 bThreshold - 1);
3508 DBG (DBG_ASIC, "bThreshold=%d\n", bThreshold);
3509
3510 usleep (50000);
3511
3512 DBG (DBG_ASIC, "SetExtraSetting:Exit\n");
3513 return status;
3514 }
3515
3516
3517 /* ---------------------- high level asic functions ------------------------ */
3518
3519
3520 /* HOLD: We don't want to have global vid/pids */
3521 static unsigned short ProductID = 0x0409;
3522 static unsigned short VendorID = 0x055f;
3523
3524 static SANE_String_Const device_name;
3525
3526 static SANE_Status
attach_one_scanner(SANE_String_Const devname)3527 attach_one_scanner (SANE_String_Const devname)
3528 {
3529 DBG (DBG_ASIC, "attach_one_scanner: enter\n");
3530 DBG (DBG_INFO, "attach_one_scanner: devname = %s\n", devname);
3531 device_name = devname;
3532 return SANE_STATUS_GOOD;
3533 }
3534
3535 static SANE_Status
Asic_Open(PAsic chip, SANE_Byte *pDeviceName)3536 Asic_Open (PAsic chip, SANE_Byte *pDeviceName)
3537 {
3538 SANE_Status status;
3539 SANE_Status sane_status;
3540
3541 DBG (DBG_ASIC, "Asic_Open: Enter\n");
3542
3543 device_name = NULL;
3544
3545 if (chip->firmwarestate > FS_OPENED)
3546 {
3547 DBG (DBG_ASIC, "chip has been opened. fd=%d\n", chip->fd);
3548 return SANE_STATUS_INVAL;
3549 }
3550
3551 /* init usb */
3552 sanei_usb_init ();
3553
3554 /* find scanner */
3555 sane_status =
3556 sanei_usb_find_devices (VendorID, ProductID, attach_one_scanner);
3557 if (sane_status != SANE_STATUS_GOOD)
3558 {
3559 DBG (DBG_ERR, "Asic_Open: sanei_usb_find_devices failed: %s\n",
3560 sane_strstatus (sane_status));
3561 return SANE_STATUS_INVAL;
3562 }
3563 /* open usb */
3564 if (device_name == NULL)
3565 {
3566 DBG (DBG_ERR, "Asic_Open: no scanner found\n");
3567 return SANE_STATUS_INVAL;
3568 }
3569 sane_status = sanei_usb_open (device_name, &chip->fd);
3570 if (sane_status != SANE_STATUS_GOOD)
3571 {
3572 DBG (DBG_ERR, "Asic_Open: sanei_usb_open of %s failed: %s\n",
3573 device_name, sane_strstatus (sane_status));
3574 return SANE_STATUS_INVAL;
3575 }
3576
3577 /* open scanner chip */
3578 status = OpenScanChip (chip);
3579 if (status != SANE_STATUS_GOOD)
3580 {
3581 sanei_usb_close (chip->fd);
3582 DBG (DBG_ASIC, "Asic_Open: OpenScanChip error\n");
3583 return status;
3584 }
3585
3586 Mustek_SendData (chip, ES01_94_PowerSaveControl, 0x27);
3587 Mustek_SendData (chip, ES01_86_DisableAllClockWhenIdle,
3588 CLOSE_ALL_CLOCK_DISABLE);
3589 Mustek_SendData (chip, ES01_79_AFEMCLK_SDRAMCLK_DELAY_CONTROL,
3590 SDRAMCLK_DELAY_12_ns);
3591
3592 /* SDRAM initial sequence */
3593 Mustek_SendData (chip, ES01_87_SDRAM_Timing, 0xf1);
3594 Mustek_SendData (chip, ES01_87_SDRAM_Timing, 0xa5);
3595 Mustek_SendData (chip, ES01_87_SDRAM_Timing, 0x91);
3596 Mustek_SendData (chip, ES01_87_SDRAM_Timing, 0x81);
3597 Mustek_SendData (chip, ES01_87_SDRAM_Timing, 0xf0);
3598
3599
3600 chip->firmwarestate = FS_OPENED;
3601 Asic_WaitUnitReady (chip);
3602 DBG (DBG_ASIC, "Asic_WaitUnitReady\n");
3603 status = SafeInitialChip (chip);
3604 if (status != SANE_STATUS_GOOD)
3605 {
3606 DBG (DBG_ERR, "Asic_Open: SafeInitialChip error\n");
3607 return status;
3608 }
3609
3610 pDeviceName = (SANE_Byte *) strdup (device_name);
3611 if (!pDeviceName)
3612 {
3613 DBG (DBG_ERR, "Asic_Open: not enough memory\n");
3614 return SANE_STATUS_INVAL;
3615 }
3616 DBG (DBG_INFO, "Asic_Open: device %s successfully opened\n", pDeviceName);
3617 DBG (DBG_ASIC, "Asic_Open: Exit\n");
3618 return status;
3619 }
3620
3621
3622 static SANE_Status
Asic_Close(PAsic chip)3623 Asic_Close (PAsic chip)
3624 {
3625 SANE_Status status;
3626 DBG (DBG_ASIC, "Asic_Close: Enter\n");
3627
3628 if (chip->firmwarestate < FS_OPENED)
3629 {
3630 DBG (DBG_ASIC, "Asic_Close: Scanner is not opened\n");
3631 return SANE_STATUS_GOOD;
3632 }
3633
3634 if (chip->firmwarestate > FS_OPENED)
3635 {
3636 DBG (DBG_ASIC,
3637 "Asic_Close: Scanner is scanning, try to stop scanning\n");
3638 Asic_ScanStop (chip);
3639 }
3640
3641 Mustek_SendData (chip, ES01_86_DisableAllClockWhenIdle,
3642 CLOSE_ALL_CLOCK_ENABLE);
3643
3644 status = CloseScanChip (chip);
3645 if (status != SANE_STATUS_GOOD)
3646 {
3647 DBG (DBG_ERR, "Asic_Close: CloseScanChip error\n");
3648 return status;
3649 }
3650
3651 sanei_usb_close (chip->fd);
3652 chip->firmwarestate = FS_ATTACHED;
3653
3654 DBG (DBG_ASIC, "Asic_Close: Exit\n");
3655 return status;
3656 }
3657
3658 static SANE_Status
Asic_TurnLamp(PAsic chip, SANE_Bool isLampOn)3659 Asic_TurnLamp (PAsic chip, SANE_Bool isLampOn)
3660 {
3661 SANE_Status status = SANE_STATUS_GOOD;
3662 SANE_Byte PWM;
3663
3664 DBG (DBG_ASIC, "Asic_TurnLamp: Enter\n");
3665
3666 if (chip->firmwarestate < FS_OPENED)
3667 {
3668 DBG (DBG_ERR, "Asic_TurnLamp: Scanner is not opened\n");
3669 return SANE_STATUS_INVAL;
3670 }
3671
3672 if (chip->firmwarestate > FS_OPENED)
3673 {
3674 Mustek_SendData (chip, ES01_F4_ActiveTriger, ACTION_TRIGER_DISABLE);
3675 }
3676
3677 if (isLampOn)
3678 {
3679 PWM = LAMP0_PWM_DEFAULT;
3680 }
3681 else
3682 {
3683 PWM = 0;
3684 }
3685 Mustek_SendData (chip, ES01_99_LAMP_PWM_FREQ_CONTROL, 1);
3686 Mustek_SendData (chip, ES01_90_Lamp0PWM, PWM);
3687 DBG (DBG_ASIC, "Lamp0 PWM = %d\n", PWM);
3688
3689 chip->firmwarestate = FS_OPENED;
3690
3691 DBG (DBG_ASIC, "Asic_TurnLamp: Exit\n");
3692 return status;
3693 }
3694
3695
3696 static SANE_Status
Asic_TurnTA(PAsic chip, SANE_Bool isTAOn)3697 Asic_TurnTA (PAsic chip, SANE_Bool isTAOn)
3698 {
3699 SANE_Byte PWM;
3700
3701 DBG (DBG_ASIC, "Asic_TurnTA: Enter\n");
3702
3703 if (chip->firmwarestate < FS_OPENED)
3704 {
3705 DBG (DBG_ERR, "Asic_TurnTA: Scanner is not opened\n");
3706 return SANE_STATUS_INVAL;
3707 }
3708
3709 if (chip->firmwarestate > FS_OPENED)
3710 Mustek_SendData (chip, ES01_F4_ActiveTriger, ACTION_TRIGER_DISABLE);
3711
3712 if (isTAOn)
3713 {
3714 PWM = LAMP1_PWM_DEFAULT;
3715 }
3716 else
3717 {
3718 PWM = 0;
3719
3720 }
3721 Mustek_SendData (chip, ES01_99_LAMP_PWM_FREQ_CONTROL, 1);
3722 Mustek_SendData (chip, ES01_91_Lamp1PWM, PWM);
3723 DBG (DBG_ASIC, "Lamp1 PWM = %d\n", PWM);
3724
3725 chip->firmwarestate = FS_OPENED;
3726 DBG (DBG_ASIC, "Asic_TurnTA: Exit\n");
3727 return SANE_STATUS_GOOD;
3728 }
3729
3730 static SANE_Status
Asic_WaitUnitReady(PAsic chip)3731 Asic_WaitUnitReady (PAsic chip)
3732 {
3733 SANE_Status status = SANE_STATUS_GOOD;
3734 SANE_Byte temp_status;
3735 int i = 0;
3736
3737 DBG (DBG_ASIC, "Asic_WaitUnitReady:Enter\n");
3738
3739 if (chip->firmwarestate < FS_OPENED)
3740 {
3741 DBG (DBG_ERR, "Asic_WaitUnitReady: Scanner has not been opened\n");
3742
3743 return SANE_STATUS_INVAL;
3744 }
3745
3746
3747 do
3748 {
3749 status = GetChipStatus (chip, 1, &temp_status);
3750 if (status != SANE_STATUS_GOOD)
3751 {
3752 DBG (DBG_ASIC, "WaitChipIdle:Error!\n");
3753 return status;
3754 }
3755 i++;
3756 usleep (100000);
3757 }
3758 while (((temp_status & 0x1f) != 0) && i < 300);
3759 DBG (DBG_ASIC, "Wait %d s\n", (unsigned short) (i * 0.1));
3760
3761 Mustek_SendData (chip, ES01_F4_ActiveTriger, ACTION_TRIGER_DISABLE);
3762 chip->motorstate = MS_STILL;
3763
3764 DBG (DBG_ASIC, "Asic_WaitUnitReady: Exit\n");
3765 return status;
3766 }
3767
3768 #if SANE_UNUSED
3769 static SANE_Status
Asic_Release(PAsic chip)3770 Asic_Release (PAsic chip)
3771 {
3772 SANE_Status status = SANE_STATUS_GOOD;
3773 DBG (DBG_ASIC, "Asic_Release()\n");
3774
3775 if (chip->firmwarestate > FS_ATTACHED)
3776 status = Asic_Close (chip);
3777
3778 chip->firmwarestate = FS_NULL;
3779
3780 DBG (DBG_ASIC, "Asic_Release: Exit\n");
3781 return status;
3782 }
3783 #endif
3784
3785 static SANE_Status
Asic_Initialize(PAsic chip)3786 Asic_Initialize (PAsic chip)
3787 {
3788 SANE_Status status = SANE_STATUS_GOOD;
3789 DBG (DBG_ASIC, "Asic_Initialize:Enter\n");
3790
3791
3792 chip->motorstate = MS_STILL;
3793 chip->dwBytesCountPerRow = 0;
3794 chip->lpGammaTable = NULL;
3795 DBG (DBG_ASIC, "isFirstOpenChip=%d\n", chip->isFirstOpenChip);
3796
3797 chip->isFirstOpenChip = TRUE;
3798 DBG (DBG_ASIC, "isFirstOpenChip=%d\n", chip->isFirstOpenChip);
3799
3800 chip->SWWidth = 0;
3801 chip->TA_Status = TA_UNKNOW;
3802 chip->lpShadingTable = NULL;
3803 chip->isMotorMove = MOTOR_0_ENABLE;
3804
3805 Asic_Reset (chip);
3806 InitTiming (chip);
3807
3808 chip->isUniformSpeedToScan = UNIFORM_MOTOR_AND_SCAN_SPEED_DISABLE;
3809 chip->isMotorGoToFirstLine = MOTOR_MOVE_TO_FIRST_LINE_ENABLE;
3810
3811 chip->UsbHost = HT_USB10;
3812
3813 DBG (DBG_ASIC, "Asic_Initialize: Exit\n");
3814 return status;
3815 }
3816
3817 static SANE_Status
Asic_SetWindow(PAsic chip, SANE_Byte bScanBits, unsigned short wXResolution, unsigned short wYResolution, unsigned short wX, unsigned short wY, unsigned short wWidth, unsigned short wLength)3818 Asic_SetWindow (PAsic chip, SANE_Byte bScanBits,
3819 unsigned short wXResolution, unsigned short wYResolution,
3820 unsigned short wX, unsigned short wY, unsigned short wWidth, unsigned short wLength)
3821 {
3822 SANE_Status status = SANE_STATUS_GOOD;
3823
3824 unsigned short ValidPixelNumber;
3825
3826 unsigned short BytePerPixel = 0;
3827 unsigned int dwTotalLineTheBufferNeed = 0;
3828 unsigned short dwTotal_CCDResolution = 1200;
3829 unsigned short wThinkCCDResolution = 0;
3830 unsigned short wCCD_PixelNumber = 0;
3831 unsigned int dwLineWidthPixel = 0;
3832 unsigned short wNowMotorDPI;
3833 unsigned short XRatioTypeWord;
3834 double XRatioTypeDouble;
3835 double XRatioAdderDouble;
3836
3837 LLF_MOTORMOVE *lpMotorStepsTable =
3838 (LLF_MOTORMOVE *) malloc (sizeof (LLF_MOTORMOVE));
3839 SANE_Byte byDummyCycleNum = 0;
3840 unsigned short Total_MotorDPI;
3841
3842 unsigned short wMultiMotorStep = 1;
3843 SANE_Byte bMotorMoveType = _MOTOR_MOVE_TYPE;
3844
3845 SANE_Byte byClear_Pulse_Width = 0;
3846
3847 unsigned int dwLinePixelReport;
3848 SANE_Byte byPHTG_PulseWidth, byPHTG_WaitWidth;
3849
3850 unsigned short StartSpeed, EndSpeed;
3851 LLF_CALCULATEMOTORTABLE CalMotorTable;
3852 LLF_MOTOR_CURRENT_AND_PHASE CurrentPhase;
3853 LLF_RAMACCESS RamAccess;
3854 unsigned int dwStartAddr, dwEndAddr, dwTableBaseAddr, dwShadingTableAddr;
3855
3856 SANE_Byte isMotorMoveToFirstLine = chip->isMotorGoToFirstLine;
3857 SANE_Byte isUniformSpeedToScan = chip->isUniformSpeedToScan;
3858 SANE_Byte isScanBackTracking = SCAN_BACK_TRACKING_ENABLE;
3859 unsigned short * lpMotorTable;
3860 unsigned int RealTableSize;
3861 double dbXRatioAdderDouble;
3862 unsigned short wFullBank;
3863
3864 DBG (DBG_ASIC, "Asic_SetWindow: Enter\n");
3865 DBG (DBG_ASIC,
3866 "bScanBits=%d,wXResolution=%d,wYResolution=%d,wX=%d,wY=%d,wWidth=%d,wLength=%d\n",
3867 bScanBits, wXResolution, wYResolution, wX, wY, wWidth, wLength);
3868
3869 if (chip->firmwarestate != FS_OPENED)
3870 {
3871 DBG (DBG_ERR, "Asic_SetWindow: Scanner is not opened\n");
3872 return SANE_STATUS_INVAL;
3873 }
3874
3875 Mustek_SendData (chip, ES01_F3_ActionOption, 0);
3876 Mustek_SendData (chip, ES01_86_DisableAllClockWhenIdle,
3877 CLOSE_ALL_CLOCK_DISABLE);
3878 Mustek_SendData (chip, ES01_F4_ActiveTriger, ACTION_TRIGER_DISABLE);
3879
3880 status = Asic_WaitUnitReady (chip);
3881
3882 /* dummy clock mode */
3883 Mustek_SendData (chip, 0x1CD, 0);
3884
3885 /* LED Flash */
3886 Mustek_SendData (chip, ES01_94_PowerSaveControl, 0x27 | 64 | 128);
3887
3888 /* calculate byte per line */
3889 if (bScanBits > 24)
3890 {
3891 BytePerPixel = 6;
3892 chip->dwBytesCountPerRow = (unsigned int) (wWidth) * 6;
3893 }
3894 else if (bScanBits == 24)
3895 {
3896 BytePerPixel = 3;
3897 chip->dwBytesCountPerRow = (unsigned int) (wWidth) * 3;
3898 }
3899 else if ((bScanBits > 8) && (bScanBits <= 16))
3900 {
3901 BytePerPixel = 2;
3902 chip->dwBytesCountPerRow = (unsigned int) (wWidth) * 2;
3903 }
3904 else if (bScanBits == 8)
3905 {
3906 BytePerPixel = 1;
3907 chip->dwBytesCountPerRow = (unsigned int) (wWidth);
3908 }
3909 else if (bScanBits < 8)
3910 {
3911 BytePerPixel = 1;
3912 chip->dwBytesCountPerRow = (unsigned int) (wWidth);
3913 }
3914 DBG (DBG_ASIC, "dwBytesCountPerRow = %d\n", chip->dwBytesCountPerRow);
3915
3916 byDummyCycleNum = 0;
3917 if (chip->lsLightSource == LS_REFLECTIVE)
3918 {
3919 if (chip->UsbHost == HT_USB10)
3920 {
3921 switch (wYResolution)
3922 {
3923 case 2400:
3924 case 1200:
3925 if (chip->dwBytesCountPerRow > 22000)
3926 byDummyCycleNum = 4;
3927 else if (chip->dwBytesCountPerRow > 15000)
3928 byDummyCycleNum = 3;
3929 else if (chip->dwBytesCountPerRow > 10000)
3930 byDummyCycleNum = 2;
3931 else if (chip->dwBytesCountPerRow > 5000)
3932 byDummyCycleNum = 1;
3933 break;
3934 case 600:
3935 case 300:
3936 case 150:
3937 case 100:
3938 if (chip->dwBytesCountPerRow > 21000)
3939 byDummyCycleNum = 7;
3940 else if (chip->dwBytesCountPerRow > 18000)
3941 byDummyCycleNum = 6;
3942 else if (chip->dwBytesCountPerRow > 15000)
3943 byDummyCycleNum = 5;
3944 else if (chip->dwBytesCountPerRow > 12000)
3945 byDummyCycleNum = 4;
3946 else if (chip->dwBytesCountPerRow > 9000)
3947 byDummyCycleNum = 3;
3948 else if (chip->dwBytesCountPerRow > 6000)
3949 byDummyCycleNum = 2;
3950 else if (chip->dwBytesCountPerRow > 3000)
3951 byDummyCycleNum = 1;
3952 break;
3953 case 75:
3954 case 50:
3955 byDummyCycleNum = 1;
3956 break;
3957 default:
3958 byDummyCycleNum = 0;
3959 break;
3960 }
3961 }
3962 else
3963 {
3964 switch (wYResolution)
3965 {
3966 case 2400:
3967 case 1200:
3968 case 75:
3969 case 50:
3970 byDummyCycleNum = 1;
3971 break;
3972 default:
3973 byDummyCycleNum = 0;
3974 break;
3975 }
3976 }
3977 }
3978
3979 dwTotalLineTheBufferNeed = wLength;
3980
3981 chip->Scan.Dpi = wXResolution;
3982 CCDTiming (chip);
3983
3984 dwTotal_CCDResolution = SENSOR_DPI;
3985
3986 if (chip->lsLightSource == LS_REFLECTIVE)
3987 {
3988 if (wXResolution > (dwTotal_CCDResolution / 2))
3989 { /* full ccd resolution 1200dpi */
3990 wThinkCCDResolution = dwTotal_CCDResolution;
3991 Mustek_SendData (chip, ES01_98_GPIOControl8_15, 0x01);
3992 Mustek_SendData (chip, ES01_96_GPIOValue8_15, 0x01);
3993
3994 wCCD_PixelNumber = chip->Timing.wCCDPixelNumber_1200;
3995 }
3996 else
3997 { /*600dpi */
3998 wThinkCCDResolution = dwTotal_CCDResolution / 2;
3999 Mustek_SendData (chip, ES01_98_GPIOControl8_15, 0x01);
4000 Mustek_SendData (chip, ES01_96_GPIOValue8_15, 0x00);
4001 wCCD_PixelNumber = chip->Timing.wCCDPixelNumber_600;
4002 }
4003 }
4004 else
4005 {
4006 if (wXResolution > (dwTotal_CCDResolution / 2))
4007 {
4008 wThinkCCDResolution = dwTotal_CCDResolution;
4009 Mustek_SendData (chip, ES01_98_GPIOControl8_15, 0x01);
4010 Mustek_SendData (chip, ES01_96_GPIOValue8_15, 0x01);
4011 wCCD_PixelNumber = TA_IMAGE_PIXELNUMBER;
4012 }
4013 else
4014 {
4015 wThinkCCDResolution = dwTotal_CCDResolution / 2;
4016 Mustek_SendData (chip, ES01_98_GPIOControl8_15, 0x01);
4017 Mustek_SendData (chip, ES01_96_GPIOValue8_15, 0x00);
4018 wCCD_PixelNumber = TA_IMAGE_PIXELNUMBER;
4019 }
4020 }
4021
4022 dwLineWidthPixel = wWidth;
4023
4024 SetLineTimeAndExposure (chip);
4025
4026 Mustek_SendData (chip, ES01_CB_CCDDummyCycleNumber, byDummyCycleNum);
4027
4028
4029 SetLEDTime (chip);
4030
4031 /* calculate Y ratio */
4032 Total_MotorDPI = 1200;
4033 wNowMotorDPI = Total_MotorDPI;
4034
4035
4036 /* SetADConverter */
4037 Mustek_SendData (chip, ES01_74_HARDWARE_SETTING,
4038 MOTOR1_SERIAL_INTERFACE_G10_8_ENABLE | LED_OUT_G11_DISABLE
4039 | SLAVE_SERIAL_INTERFACE_G15_14_DISABLE |
4040 SHUTTLE_CCD_DISABLE);
4041
4042 /* set AFE */
4043 Mustek_SendData (chip, ES01_9A_AFEControl,
4044 AD9826_AFE | AUTO_CHANGE_AFE_GAIN_OFFSET_DISABLE);
4045 SetAFEGainOffset (chip);
4046
4047 Mustek_SendData (chip, ES01_F7_DigitalControl, DIGITAL_REDUCE_DISABLE);
4048
4049 /* calculate X ratio */
4050 XRatioTypeDouble = wXResolution;
4051 XRatioTypeDouble /= wThinkCCDResolution;
4052 XRatioAdderDouble = 1 / XRatioTypeDouble;
4053 XRatioTypeWord = (unsigned short) (XRatioTypeDouble * 32768); /* 32768 = 2^15 */
4054
4055 XRatioAdderDouble = (double) (XRatioTypeWord) / 32768;
4056 XRatioAdderDouble = 1 / XRatioAdderDouble;
4057
4058 /* 0x8000 = 1.00000 -> get all pixel */
4059 Mustek_SendData (chip, ES01_9E_HorizontalRatio1to15LSB,
4060 LOBYTE (XRatioTypeWord));
4061 Mustek_SendData (chip, ES01_9F_HorizontalRatio1to15MSB,
4062 HIBYTE (XRatioTypeWord));
4063
4064 /* SetMotorType */
4065 Mustek_SendData (chip, ES01_A6_MotorOption, MOTOR_0_ENABLE |
4066 MOTOR_1_DISABLE |
4067 HOME_SENSOR_0_ENABLE | ES03_TABLE_DEFINE);
4068
4069 Mustek_SendData (chip, ES01_F6_MorotControl1, SPEED_UNIT_1_PIXEL_TIME |
4070 MOTOR_SYNC_UNIT_1_PIXEL_TIME);
4071
4072 /* SetScanStepTable */
4073
4074 /*set Motor move type */
4075 if (wYResolution >= 1200)
4076 bMotorMoveType = _8_TABLE_SPACE_FOR_1_DIV_2_STEP;
4077
4078 switch (bMotorMoveType)
4079 {
4080 case _4_TABLE_SPACE_FOR_FULL_STEP:
4081 wMultiMotorStep = 1;
4082 break;
4083
4084 case _8_TABLE_SPACE_FOR_1_DIV_2_STEP:
4085 wMultiMotorStep = 2;
4086 break;
4087
4088 case _16_TABLE_SPACE_FOR_1_DIV_4_STEP:
4089 wMultiMotorStep = 4;
4090 break;
4091
4092 case _32_TABLE_SPACE_FOR_1_DIV_8_STEP:
4093 wMultiMotorStep = 8;
4094 break;
4095 }
4096 wY *= wMultiMotorStep;
4097
4098 SetScanMode (chip, bScanBits);
4099
4100
4101
4102 /*set white shading int and dec */
4103 if (chip->lsLightSource == LS_REFLECTIVE)
4104 Mustek_SendData (chip, ES01_F8_WHITE_SHADING_DATA_FORMAT,
4105 ES01_SHADING_3_INT_13_DEC);
4106 else
4107 Mustek_SendData (chip, ES01_F8_WHITE_SHADING_DATA_FORMAT,
4108 ES01_SHADING_4_INT_12_DEC);
4109
4110 SetPackAddress (chip, wXResolution, wWidth, wX, XRatioAdderDouble,
4111 XRatioTypeDouble, byClear_Pulse_Width, &ValidPixelNumber);
4112 SetExtraSetting (chip, wXResolution, wCCD_PixelNumber, FALSE);
4113
4114 /* calculate line time */
4115 byPHTG_PulseWidth = chip->Timing.PHTG_PluseWidth;
4116 byPHTG_WaitWidth = chip->Timing.PHTG_WaitWidth;
4117 dwLinePixelReport = ((byClear_Pulse_Width + 1) * 2 +
4118 (byPHTG_PulseWidth + 1) * (1) +
4119 (byPHTG_WaitWidth + 1) * (1) +
4120 (wCCD_PixelNumber + 1)) * (byDummyCycleNum + 1);
4121
4122 DBG (DBG_ASIC, "Motor Time = %d\n",
4123 (dwLinePixelReport * wYResolution / wNowMotorDPI) / wMultiMotorStep);
4124 if ((dwLinePixelReport * wYResolution / wNowMotorDPI) / wMultiMotorStep >
4125 64000)
4126 {
4127 DBG (DBG_ASIC, "Motor Time Over Flow !!!\n");
4128 }
4129
4130 EndSpeed =
4131 (unsigned short) ((dwLinePixelReport * wYResolution / wNowMotorDPI) /
4132 wMultiMotorStep);
4133 SetMotorStepTable (chip, lpMotorStepsTable, wY, dwTotalLineTheBufferNeed * wNowMotorDPI / wYResolution * wMultiMotorStep, wYResolution); /*modified by Chester 92/04/08 */
4134
4135
4136 if (EndSpeed >= 20000)
4137 {
4138 Asic_MotorMove (chip, 1, wY / wMultiMotorStep);
4139 isUniformSpeedToScan = UNIFORM_MOTOR_AND_SCAN_SPEED_ENABLE;
4140 isScanBackTracking = SCAN_BACK_TRACKING_DISABLE;
4141 isMotorMoveToFirstLine = MOTOR_MOVE_TO_FIRST_LINE_DISABLE;
4142 }
4143
4144 Mustek_SendData (chip, ES01_F3_ActionOption, isMotorMoveToFirstLine |
4145 MOTOR_BACK_HOME_AFTER_SCAN_DISABLE |
4146 SCAN_ENABLE |
4147 isScanBackTracking |
4148 INVERT_MOTOR_DIRECTION_DISABLE |
4149 isUniformSpeedToScan |
4150 ES01_STATIC_SCAN_DISABLE | MOTOR_TEST_LOOP_DISABLE);
4151
4152 if (EndSpeed > 8000)
4153 {
4154 StartSpeed = EndSpeed;
4155 }
4156 else
4157 {
4158 if (EndSpeed <= 1000)
4159 StartSpeed = EndSpeed + 4500;
4160 else
4161 StartSpeed = EndSpeed + 3500;
4162 }
4163
4164 Mustek_SendData (chip, ES01_FD_MotorFixedspeedLSB, LOBYTE (EndSpeed));
4165 Mustek_SendData (chip, ES01_FE_MotorFixedspeedMSB, HIBYTE (EndSpeed));
4166
4167 lpMotorTable = (unsigned short *) malloc (512 * 8 * 2);
4168 memset (lpMotorTable, 0, 512 * 8 * sizeof (unsigned short));
4169
4170 CalMotorTable.StartSpeed = StartSpeed;
4171 CalMotorTable.EndSpeed = EndSpeed;
4172 CalMotorTable.AccStepBeforeScan = lpMotorStepsTable->wScanAccSteps;
4173 CalMotorTable.DecStepAfterScan = lpMotorStepsTable->bScanDecSteps;
4174 CalMotorTable.lpMotorTable = lpMotorTable;
4175
4176 CalculateMotorTable (&CalMotorTable, wYResolution);
4177
4178 CurrentPhase.MotorDriverIs3967 = 0;
4179 CurrentPhase.FillPhase = 1;
4180 CurrentPhase.MoveType = bMotorMoveType;
4181 SetMotorCurrent (chip, EndSpeed, &CurrentPhase);
4182 LLFSetMotorCurrentAndPhase (chip, &CurrentPhase);
4183
4184 DBG (DBG_ASIC,
4185 "EndSpeed = %d, BytesCountPerRow=%d, MotorCurrentTable=%d, LinePixelReport=%d\n",
4186 EndSpeed, chip->dwBytesCountPerRow, CurrentPhase.MotorCurrentTableA[0],
4187 dwLinePixelReport);
4188
4189 /* write motor table */
4190 RealTableSize = 512 * 8;
4191 dwTableBaseAddr = PackAreaStartAddress - RealTableSize;
4192
4193 dwStartAddr = dwTableBaseAddr;
4194
4195 RamAccess.ReadWrite = WRITE_RAM;
4196 RamAccess.IsOnChipGamma = EXTERNAL_RAM;
4197 RamAccess.DramDelayTime = SDRAMCLK_DELAY_12_ns;
4198 RamAccess.LoStartAddress = (unsigned short) (dwStartAddr);
4199 RamAccess.HiStartAddress = (unsigned short) (dwStartAddr >> 16);
4200 RamAccess.RwSize = RealTableSize * 2;
4201 RamAccess.BufferPtr = (SANE_Byte *) lpMotorTable;
4202 LLFRamAccess (chip, &RamAccess);
4203
4204 Mustek_SendData (chip, ES01_DB_PH_RESET_EDGE_TIMING_ADJUST, 0x00);
4205
4206 Mustek_SendData (chip, ES01_DC_CLEAR_EDGE_TO_PH_TG_EDGE_WIDTH, 0);
4207
4208 Mustek_SendData (chip, ES01_9D_MotorTableAddrA14_A21,
4209 (SANE_Byte) (dwTableBaseAddr >> TABLE_OFFSET_BASE));
4210
4211
4212 /* set address and shading table */
4213 /*set image buffer range and write shading table */
4214 RealTableSize =
4215 (ACC_DEC_STEP_TABLE_SIZE * NUM_OF_ACC_DEC_STEP_TABLE) +
4216 ShadingTableSize (ValidPixelNumber);
4217 dwShadingTableAddr =
4218 PackAreaStartAddress -
4219 (((RealTableSize +
4220 (TABLE_BASE_SIZE - 1)) >> TABLE_OFFSET_BASE) << TABLE_OFFSET_BASE);
4221 dwEndAddr = dwShadingTableAddr - 1;
4222 dwStartAddr = dwShadingTableAddr;
4223
4224 if (wXResolution > 600)
4225 dbXRatioAdderDouble = 1200 / wXResolution;
4226 else
4227 dbXRatioAdderDouble = 600 / wXResolution;
4228
4229 RamAccess.ReadWrite = WRITE_RAM;
4230 RamAccess.IsOnChipGamma = EXTERNAL_RAM;
4231 RamAccess.DramDelayTime = SDRAMCLK_DELAY_12_ns;
4232 RamAccess.LoStartAddress = (unsigned short) (dwStartAddr);
4233 RamAccess.HiStartAddress = (unsigned short) (dwStartAddr >> 16);
4234 RamAccess.RwSize =
4235 ShadingTableSize ((int) ((wWidth + 4) * dbXRatioAdderDouble)) *
4236 sizeof (unsigned short);
4237 RamAccess.BufferPtr = (SANE_Byte *) chip->lpShadingTable;
4238 LLFRamAccess (chip, &RamAccess);
4239
4240 /*tell scan chip the shading table address, unit is 2^15 bytes(2^14 word) */
4241 Mustek_SendData (chip, ES01_9B_ShadingTableAddrA14_A21,
4242 (SANE_Byte) (dwShadingTableAddr >> TABLE_OFFSET_BASE));
4243
4244 /*empty bank */
4245 Mustek_SendData (chip, ES01_FB_BufferEmptySize16WordLSB,
4246 LOBYTE (WaitBufferOneLineSize >> (7 - 3)));
4247 Mustek_SendData (chip, ES01_FC_BufferEmptySize16WordMSB,
4248 HIBYTE (WaitBufferOneLineSize >> (7 - 3)));
4249
4250 /*full bank */
4251 wFullBank =
4252 (unsigned short) ((dwEndAddr -
4253 (((dwLineWidthPixel * BytePerPixel) / 2) * 3 * 1)) / BANK_SIZE);
4254 Mustek_SendData (chip, ES01_F9_BufferFullSize16WordLSB, LOBYTE (wFullBank));
4255 Mustek_SendData (chip, ES01_FA_BufferFullSize16WordMSB, HIBYTE (wFullBank));
4256
4257
4258 /* set buffer address */
4259 LLFSetRamAddress (chip, 0x0, dwEndAddr, ACCESS_DRAM);
4260
4261 Mustek_SendData (chip, ES01_00_ADAFEConfiguration, 0x70);
4262 Mustek_SendData (chip, ES01_02_ADAFEMuxConfig, 0x80);
4263
4264 free (lpMotorTable);
4265 free (lpMotorStepsTable);
4266 chip->firmwarestate = FS_OPENED;
4267
4268 DBG (DBG_ASIC, "Asic_SetWindow: Exit\n");
4269 return status;
4270 }
4271
4272 static SANE_Status
Asic_Reset(PAsic chip)4273 Asic_Reset (PAsic chip)
4274 {
4275 SANE_Status status = SANE_STATUS_GOOD;
4276 DBG (DBG_ASIC, "Asic_Reset: Enter\n");
4277
4278 chip->lsLightSource = LS_REFLECTIVE;
4279
4280 chip->dwBytesCountPerRow = 0;
4281 chip->AD.DirectionR = 0;
4282 chip->AD.DirectionG = 0;
4283 chip->AD.DirectionB = 0;
4284 chip->AD.GainR = 0;
4285 chip->AD.GainG = 0;
4286 chip->AD.GainB = 0;
4287
4288 chip->AD.OffsetR = 0;
4289 chip->AD.OffsetG = 0;
4290 chip->AD.OffsetB = 0;
4291
4292 chip->Scan.TotalMotorSteps = 60000;
4293 chip->Scan.StartLine = 0;
4294 chip->Scan.StartPixel = 0;
4295
4296 DBG (DBG_ASIC, "Asic_Reset: Exit\n");
4297 return status;
4298 }
4299
4300 static SANE_Status
Asic_SetSource(PAsic chip, LIGHTSOURCE lsLightSource)4301 Asic_SetSource (PAsic chip, LIGHTSOURCE lsLightSource)
4302 {
4303 SANE_Status status = SANE_STATUS_GOOD;
4304 DBG (DBG_ASIC, "Asic_SetSource: Enter\n");
4305
4306 chip->lsLightSource = lsLightSource;
4307 switch (chip->lsLightSource)
4308 {
4309 case 1:
4310 DBG (DBG_ASIC, "Asic_SetSource: Source is Reflect\n");
4311 break;
4312 case 2:
4313 DBG (DBG_ASIC, "Asic_SetSource: Source is Position\n");
4314 break;
4315 case 4:
4316 DBG (DBG_ASIC, "Asic_SetSource: Source is Negative\n");
4317 break;
4318 default:
4319 DBG (DBG_ASIC, "Asic_SetSource: Source error\n");
4320 }
4321
4322 DBG (DBG_ASIC, "Asic_SetSource: Exit\n");
4323 return status;
4324 }
4325
4326 static SANE_Status
Asic_ScanStart(PAsic chip)4327 Asic_ScanStart (PAsic chip)
4328 {
4329 SANE_Status status = SANE_STATUS_GOOD;
4330 DBG (DBG_ASIC, "Asic_ScanStart: Enter\n");
4331
4332 if (chip->firmwarestate != FS_OPENED)
4333 {
4334 DBG (DBG_ERR, "Asic_ScanStart: Scanner is not opened\n");
4335 return SANE_STATUS_INVAL;
4336 }
4337
4338 Mustek_SendData (chip, ES01_8B_Status, 0x1c | 0x20);
4339 Mustek_WriteAddressLineForRegister (chip, 0x8B);
4340 Mustek_ClearFIFO (chip);
4341 Mustek_SendData (chip, ES01_F4_ActiveTriger, ACTION_TRIGER_ENABLE);
4342
4343
4344 chip->firmwarestate = FS_SCANNING;
4345
4346 DBG (DBG_ASIC, "Asic_ScanStart: Exit\n");
4347 return status;
4348 }
4349
4350 static SANE_Status
Asic_ScanStop(PAsic chip)4351 Asic_ScanStop (PAsic chip)
4352 {
4353 SANE_Status status = SANE_STATUS_GOOD;
4354 SANE_Byte temps[2];
4355 SANE_Byte buf[4];
4356
4357 DBG (DBG_ASIC, "Asic_ScanStop: Enter\n");
4358
4359 if (chip->firmwarestate < FS_SCANNING)
4360 {
4361 return status;
4362 }
4363
4364 usleep (100 * 1000);
4365
4366 buf[0] = 0x02; /*stop */
4367 buf[1] = 0x02;
4368 buf[2] = 0x02;
4369 buf[3] = 0x02;
4370 status = WriteIOControl (chip, 0xc0, 0, 4, buf);
4371 if (status != SANE_STATUS_GOOD)
4372 {
4373 DBG (DBG_ERR, "Asic_ScanStop: Stop scan error\n");
4374 return status;
4375 }
4376
4377 buf[0] = 0x00; /*clear */
4378 buf[1] = 0x00;
4379 buf[2] = 0x00;
4380 buf[3] = 0x00;
4381 status = WriteIOControl (chip, 0xc0, 0, 4, buf);
4382 if (status != SANE_STATUS_GOOD)
4383 {
4384 DBG (DBG_ERR, "Asic_ScanStop: Clear scan error\n");
4385 return status;
4386 }
4387
4388 status = Mustek_DMARead (chip, 2, temps);
4389 if (status != SANE_STATUS_GOOD)
4390 {
4391 DBG (DBG_ERR, "Asic_ScanStop: DMAReadGeneralMode error\n");
4392 return status;
4393 }
4394
4395 Mustek_SendData (chip, ES01_F3_ActionOption, 0);
4396 Mustek_SendData (chip, ES01_86_DisableAllClockWhenIdle,
4397 CLOSE_ALL_CLOCK_DISABLE);
4398 Mustek_SendData (chip, ES01_F4_ActiveTriger, ACTION_TRIGER_DISABLE);
4399 Mustek_ClearFIFO (chip);
4400
4401 chip->firmwarestate = FS_OPENED;
4402 DBG (DBG_ASIC, "Asic_ScanStop: Exit\n");
4403 return status;
4404 }
4405
4406 static SANE_Status
Asic_ReadImage(PAsic chip, SANE_Byte * pBuffer, unsigned short LinesCount)4407 Asic_ReadImage (PAsic chip, SANE_Byte * pBuffer, unsigned short LinesCount)
4408 {
4409 SANE_Status status = SANE_STATUS_GOOD;
4410 unsigned int dwXferBytes;
4411
4412 DBG (DBG_ASIC, "Asic_ReadImage: Enter : LinesCount = %d\n", LinesCount);
4413
4414 if (chip->firmwarestate != FS_SCANNING)
4415 {
4416 DBG (DBG_ERR, "Asic_ReadImage: Scanner is not scanning\n");
4417 return SANE_STATUS_INVAL;
4418 }
4419
4420 dwXferBytes = (unsigned int) (LinesCount) * chip->dwBytesCountPerRow;
4421 DBG (DBG_ASIC, "Asic_ReadImage: chip->dwBytesCountPerRow = %d\n",
4422 chip->dwBytesCountPerRow);
4423
4424 /* HOLD: an unsigned long can't be < 0
4425 if (dwXferBytes < 0)
4426 {
4427 DBG (DBG_ASIC, "Asic_ReadImage: dwXferBytes <0\n");
4428 return SANE_STATUS_INVAL;
4429 }
4430 */
4431 if (dwXferBytes == 0)
4432
4433 {
4434 DBG (DBG_ASIC, "Asic_ReadImage: dwXferBytes == 0\n");
4435 return SANE_STATUS_GOOD;
4436 }
4437
4438 status = Mustek_DMARead (chip, dwXferBytes, pBuffer);
4439
4440 DBG (DBG_ASIC, "Asic_ReadImage: Exit\n");
4441 return status;
4442 }
4443
4444
4445 #if SANE_UNUSED
4446 static SANE_Status
Asic_CheckFunctionKey(PAsic chip, SANE_Byte * key)4447 Asic_CheckFunctionKey (PAsic chip, SANE_Byte * key)
4448 {
4449 SANE_Status status = SANE_STATUS_GOOD;
4450 SANE_Byte bBuffer_1 = 0xff;
4451 SANE_Byte bBuffer_2 = 0xff;
4452
4453 DBG (DBG_ASIC, "Asic_CheckFunctionKey: Enter\n");
4454
4455 if (chip->firmwarestate != FS_OPENED)
4456 {
4457 DBG (DBG_ERR, "Asic_CheckFunctionKey: Scanner is not Opened\n");
4458 return SANE_STATUS_INVAL;
4459 }
4460
4461 Mustek_SendData (chip, ES01_97_GPIOControl0_7, 0x00);
4462 Mustek_SendData (chip, ES01_95_GPIOValue0_7, 0x17);
4463 Mustek_SendData (chip, ES01_98_GPIOControl8_15, 0x00);
4464 Mustek_SendData (chip, ES01_96_GPIOValue8_15, 0x08);
4465
4466 GetChipStatus (chip, 0x02, &bBuffer_1);
4467 GetChipStatus (chip, 0x03, &bBuffer_2);
4468
4469
4470 if (((0xff - bBuffer_1) & 0x10) == 0x10)
4471 *key = 0x01;
4472
4473 if (((0xff - bBuffer_1) & 0x01) == 0x01)
4474 *key = 0x02;
4475 if (((0xff - bBuffer_1) & 0x04) == 0x04)
4476 *key = 0x04;
4477 if (((0xff - bBuffer_2) & 0x08) == 0x08)
4478 *key = 0x08;
4479 if (((0xff - bBuffer_1) & 0x02) == 0x02)
4480 *key = 0x10;
4481
4482
4483 DBG (DBG_ASIC, "CheckFunctionKey=%d\n", *key);
4484 DBG (DBG_ASIC, "Asic_CheckFunctionKey: Exit\n");
4485 return status;
4486 }
4487 #endif
4488
4489 static SANE_Status
Asic_IsTAConnected(PAsic chip, SANE_Bool * hasTA)4490 Asic_IsTAConnected (PAsic chip, SANE_Bool * hasTA)
4491 {
4492 SANE_Byte bBuffer_1 = 0xff;
4493
4494 DBG (DBG_ASIC, "Asic_IsTAConnected: Enter\n");
4495
4496 Mustek_SendData (chip, ES01_97_GPIOControl0_7, 0x00);
4497 Mustek_SendData (chip, ES01_95_GPIOValue0_7, 0x00);
4498
4499 Mustek_SendData (chip, ES01_98_GPIOControl8_15, 0x00);
4500 Mustek_SendData (chip, ES01_96_GPIOValue8_15, 0x00);
4501
4502
4503 GetChipStatus (chip, 0x02, &bBuffer_1);
4504
4505 if (((0xff - bBuffer_1) & 0x08) == 0x08)
4506 *hasTA = TRUE;
4507 else
4508 *hasTA = FALSE;
4509
4510 DBG (DBG_ASIC, "hasTA=%d\n", *hasTA);
4511 DBG (DBG_ASIC, "Asic_IsTAConnected():Exit\n");
4512 return SANE_STATUS_GOOD;
4513 }
4514
4515 #if SANE_UNUSED
4516 static SANE_Status
Asic_DownloadGammaTable(PAsic chip, void * lpBuffer)4517 Asic_DownloadGammaTable (PAsic chip, void * lpBuffer)
4518 {
4519 SANE_Status status = SANE_STATUS_GOOD;
4520 DBG (DBG_ASIC, "Asic_DownloadGammaTable()\n");
4521
4522 chip->lpGammaTable = lpBuffer;
4523
4524 DBG (DBG_ASIC, "Asic_DownloadGammaTable: Exit\n");
4525 return status;
4526 }
4527 #endif
4528
4529 static SANE_Status
Asic_ReadCalibrationData(PAsic chip, void * pBuffer, unsigned int dwXferBytes, SANE_Byte bScanBits)4530 Asic_ReadCalibrationData (PAsic chip, void * pBuffer,
4531 unsigned int dwXferBytes, SANE_Byte bScanBits)
4532 {
4533 SANE_Status status = SANE_STATUS_GOOD;
4534 SANE_Byte * pCalBuffer;
4535 unsigned int dwTotalReadData;
4536 unsigned int dwReadImageData;
4537
4538 DBG (DBG_ASIC, "Asic_ReadCalibrationData: Enter\n");
4539
4540 if (chip->firmwarestate != FS_SCANNING)
4541 {
4542 DBG (DBG_ERR, "Asic_ReadCalibrationData: Scanner is not scanning\n");
4543 return SANE_STATUS_INVAL;
4544 }
4545
4546 if (bScanBits == 24)
4547 {
4548 unsigned int i;
4549 pCalBuffer = (SANE_Byte *) malloc (dwXferBytes);
4550 if (pCalBuffer == NULL)
4551 {
4552 DBG (DBG_ERR,
4553 "Asic_ReadCalibrationData: Can't malloc bCalBuffer memory\n");
4554 return SANE_STATUS_NO_MEM;
4555 }
4556
4557 for (dwTotalReadData = 0; dwTotalReadData < dwXferBytes;)
4558 {
4559 dwReadImageData = (dwXferBytes - dwTotalReadData) < 65536 ?
4560 (dwXferBytes - dwTotalReadData) : 65536;
4561
4562 Mustek_DMARead (chip, dwReadImageData,
4563 (SANE_Byte *) (pCalBuffer + dwTotalReadData));
4564 dwTotalReadData += dwReadImageData;
4565 }
4566
4567 dwXferBytes /= 3;
4568 for (i = 0; i < dwXferBytes; i++)
4569
4570 {
4571 *((SANE_Byte *) pBuffer + i) = *(pCalBuffer + i * 3);
4572 *((SANE_Byte *) pBuffer + dwXferBytes + i) = *(pCalBuffer + i * 3 + 1);
4573 *((SANE_Byte *) pBuffer + dwXferBytes * 2 + i) =
4574 *(pCalBuffer + i * 3 + 2);
4575 }
4576 free (pCalBuffer);
4577 }
4578 else if (bScanBits == 8)
4579 {
4580 for (dwTotalReadData = 0; dwTotalReadData < dwXferBytes;)
4581 {
4582 dwReadImageData = (dwXferBytes - dwTotalReadData) < 65536 ?
4583 (dwXferBytes - dwTotalReadData) : 65536;
4584
4585 Mustek_DMARead (chip, dwReadImageData,
4586 (SANE_Byte *) pBuffer + dwTotalReadData);
4587 dwTotalReadData += dwReadImageData;
4588 }
4589 }
4590
4591 DBG (DBG_ASIC, "Asic_ReadCalibrationData: Exit\n");
4592 return status;
4593 }
4594
4595 static SANE_Status
Asic_SetMotorType(PAsic chip, SANE_Bool isMotorMove, SANE_Bool isUniformSpeed)4596 Asic_SetMotorType (PAsic chip, SANE_Bool isMotorMove, SANE_Bool isUniformSpeed)
4597 {
4598 SANE_Status status = SANE_STATUS_GOOD;
4599 (void) isUniformSpeed;
4600 DBG (DBG_ASIC, "Asic_SetMotorType:Enter\n");
4601
4602 if (isMotorMove)
4603 {
4604 chip->isMotorMove = MOTOR_0_ENABLE;
4605 }
4606 else
4607 chip->isMotorMove = MOTOR_0_DISABLE;
4608
4609 DBG (DBG_ASIC, "isMotorMove=%d\n", chip->isMotorMove);
4610 DBG (DBG_ASIC, "Asic_SetMotorType: Exit\n");
4611 return status;
4612 }
4613
4614 static SANE_Status
Asic_MotorMove(PAsic chip, SANE_Bool isForward, unsigned int dwTotalSteps)4615 Asic_MotorMove (PAsic chip, SANE_Bool isForward, unsigned int dwTotalSteps)
4616 {
4617 SANE_Status status = SANE_STATUS_GOOD;
4618 unsigned short *NormalMoveMotorTable;
4619 LLF_CALCULATEMOTORTABLE CalMotorTable;
4620 LLF_MOTOR_CURRENT_AND_PHASE CurrentPhase;
4621 LLF_SETMOTORTABLE LLF_SetMotorTable;
4622 LLF_MOTORMOVE MotorMove;
4623
4624 DBG (DBG_ASIC, "Asic_MotorMove:Enter\n");
4625
4626 NormalMoveMotorTable = (unsigned short *) malloc (512 * 8 * 2);
4627
4628 CalMotorTable.StartSpeed = 5000;
4629 CalMotorTable.EndSpeed = 1800;
4630 CalMotorTable.AccStepBeforeScan = 511;
4631 CalMotorTable.lpMotorTable = NormalMoveMotorTable;
4632 LLFCalculateMotorTable (&CalMotorTable);
4633
4634 CurrentPhase.MotorDriverIs3967 = 0;
4635 CurrentPhase.MotorCurrentTableA[0] = 200;
4636 CurrentPhase.MotorCurrentTableB[0] = 200;
4637 CurrentPhase.MoveType = _4_TABLE_SPACE_FOR_FULL_STEP;
4638 LLFSetMotorCurrentAndPhase (chip, &CurrentPhase);
4639
4640 LLF_SetMotorTable.MotorTableAddress = 0;
4641 LLF_SetMotorTable.MotorTablePtr = NormalMoveMotorTable;
4642 LLFSetMotorTable (chip, &LLF_SetMotorTable);
4643
4644 free (NormalMoveMotorTable);
4645
4646 MotorMove.MotorSelect = MOTOR_0_ENABLE | MOTOR_1_DISABLE;
4647 MotorMove.MotorMoveUnit = ES03_TABLE_DEFINE;
4648 MotorMove.MotorSpeedUnit = SPEED_UNIT_1_PIXEL_TIME;
4649 MotorMove.MotorSyncUnit = MOTOR_SYNC_UNIT_1_PIXEL_TIME;
4650 MotorMove.HomeSensorSelect = HOME_SENSOR_0_ENABLE;
4651 MotorMove.ActionMode = ACTION_MODE_ACCDEC_MOVE;
4652 MotorMove.ActionType = isForward;
4653
4654 if (dwTotalSteps > 1000)
4655 {
4656 MotorMove.AccStep = 511;
4657 MotorMove.DecStep = 255;
4658 MotorMove.FixMoveSteps = dwTotalSteps - (511 + 255);
4659 }
4660 else
4661 {
4662
4663 MotorMove.ActionMode = ACTION_MODE_UNIFORM_SPEED_MOVE;
4664 MotorMove.AccStep = 1;
4665 MotorMove.DecStep = 1;
4666 MotorMove.FixMoveSteps = dwTotalSteps - 2;
4667 }
4668
4669 MotorMove.FixMoveSpeed = 7000;
4670 MotorMove.WaitOrNoWait = TRUE;
4671
4672 LLFMotorMove (chip, &MotorMove);
4673
4674 DBG (DBG_ASIC, "Asic_MotorMove: Exit\n");
4675 return status;
4676 }
4677
4678 static SANE_Status
Asic_CarriageHome(PAsic chip, SANE_Bool isTA)4679 Asic_CarriageHome (PAsic chip, SANE_Bool isTA)
4680 {
4681 SANE_Status status = SANE_STATUS_GOOD;
4682 SANE_Bool LampHome, TAHome;
4683 (void) isTA;
4684
4685 DBG (DBG_ASIC, "Asic_CarriageHome:Enter\n");
4686
4687 status = IsCarriageHome (chip, &LampHome, &TAHome);
4688 if (!LampHome)
4689 {
4690 status = MotorBackHome (chip, TRUE);
4691 }
4692
4693 DBG (DBG_ASIC, "Asic_CarriageHome: Exit\n");
4694 return status;
4695 }
4696
4697 static SANE_Status
Asic_SetShadingTable(PAsic chip, unsigned short * lpWhiteShading, unsigned short * lpDarkShading, unsigned short wXResolution, unsigned short wWidth, unsigned short wX)4698 Asic_SetShadingTable (PAsic chip, unsigned short * lpWhiteShading,
4699 unsigned short * lpDarkShading,
4700 unsigned short wXResolution, unsigned short wWidth, unsigned short wX)
4701 {
4702 SANE_Status status = SANE_STATUS_GOOD;
4703 unsigned short i, j, n;
4704 unsigned short wValidPixelNumber;
4705 double dbXRatioAdderDouble;
4706 unsigned int wShadingTableSize;
4707
4708 (void) wX;
4709 DBG (DBG_ASIC, "Asic_SetShadingTable:Enter\n");
4710
4711 if (chip->firmwarestate < FS_OPENED)
4712
4713 OpenScanChip (chip);
4714 if (chip->firmwarestate == FS_SCANNING)
4715 Mustek_SendData (chip, ES01_F4_ActiveTriger, ACTION_TRIGER_DISABLE);
4716
4717
4718 if (wXResolution > 600)
4719 dbXRatioAdderDouble = 1200 / wXResolution;
4720 else
4721 dbXRatioAdderDouble = 600 / wXResolution;
4722
4723 wValidPixelNumber = (unsigned short) ((wWidth + 4) * dbXRatioAdderDouble);
4724 DBG (DBG_ASIC, "wValidPixelNumber = %d\n", wValidPixelNumber);
4725
4726 /* clear old Shading table, if it has. */
4727 /* first 4 element and latest 5 of Shading table can't been used */
4728 wShadingTableSize = (ShadingTableSize (wValidPixelNumber)) * sizeof (unsigned short);
4729 if (chip->lpShadingTable != NULL)
4730 {
4731 free (chip->lpShadingTable);
4732
4733 }
4734
4735 DBG (DBG_ASIC, "Alloc a new shading table= %d Byte!\n", wShadingTableSize);
4736 chip->lpShadingTable = (SANE_Byte *) malloc (wShadingTableSize);
4737 if (chip->lpShadingTable == NULL)
4738 {
4739 DBG (DBG_ASIC, "lpShadingTable == NULL\n");
4740 return SANE_STATUS_NO_MEM;
4741 }
4742
4743 n = 0;
4744 for (i = 0; i <= (wValidPixelNumber / 40); i++)
4745 {
4746 if (i < (wValidPixelNumber / 40))
4747 {
4748 for (j = 0; j < 40; j++)
4749 {
4750 *((unsigned short *) chip->lpShadingTable + i * 256 + j * 6) =
4751 *((unsigned short *) lpDarkShading + n * 3);
4752 *((unsigned short *) chip->lpShadingTable + i * 256 + j * 6 + 2) =
4753 *((unsigned short *) lpDarkShading + n * 3 + 1);
4754 *((unsigned short *) chip->lpShadingTable + i * 256 + j * 6 + 4) =
4755 *((unsigned short *) lpDarkShading + n * 3 + 2);
4756
4757 *((unsigned short *) chip->lpShadingTable + i * 256 + j * 6 + 1) =
4758 *((unsigned short *) lpWhiteShading + n * 3);
4759 *((unsigned short *) chip->lpShadingTable + i * 256 + j * 6 + 3) =
4760 *((unsigned short *) lpWhiteShading + n * 3 + 1);
4761 *((unsigned short *) chip->lpShadingTable + i * 256 + j * 6 + 5) =
4762 *((unsigned short *) lpWhiteShading + n * 3 + 2);
4763 if ((j % (unsigned short) dbXRatioAdderDouble) ==
4764 (dbXRatioAdderDouble - 1))
4765 n++;
4766
4767 if (i == 0 && j < 4 * dbXRatioAdderDouble)
4768 n = 0;
4769 }
4770 }
4771 else
4772 {
4773 for (j = 0; j < (wValidPixelNumber % 40); j++)
4774 {
4775 *((unsigned short *) chip->lpShadingTable + i * 256 + j * 6) =
4776 *((unsigned short *) lpDarkShading + (n) * 3);
4777 *((unsigned short *) chip->lpShadingTable + i * 256 + j * 6 + 2) =
4778 *((unsigned short *) lpDarkShading + (n) * 3 + 1);
4779 *((unsigned short *) chip->lpShadingTable + i * 256 + j * 6 + 4) =
4780 *((unsigned short *) lpDarkShading + (n) * 3 + 2);
4781
4782 *((unsigned short *) chip->lpShadingTable + i * 256 + j * 6 + 1) =
4783 *((unsigned short *) lpWhiteShading + (n) * 3);
4784 *((unsigned short *) chip->lpShadingTable + i * 256 + j * 6 + 3) =
4785 *((unsigned short *) lpWhiteShading + (n) * 3 + 1);
4786 *((unsigned short *) chip->lpShadingTable + i * 256 + j * 6 + 5) =
4787 *((unsigned short *) lpWhiteShading + (n) * 3 + 2);
4788
4789 if ((j % (unsigned short) dbXRatioAdderDouble) ==
4790 (dbXRatioAdderDouble - 1))
4791 n++;
4792
4793 if (i == 0 && j < 4 * dbXRatioAdderDouble)
4794 n = 0;
4795 }
4796 }
4797 }
4798
4799 DBG (DBG_ASIC, "Asic_SetShadingTable: Exit\n");
4800 return status;
4801 }
4802
4803 static SANE_Status
Asic_WaitCarriageHome(PAsic chip, SANE_Bool isTA)4804 Asic_WaitCarriageHome (PAsic chip, SANE_Bool isTA)
4805 {
4806 SANE_Status status = SANE_STATUS_GOOD;
4807 SANE_Bool LampHome, TAHome;
4808 int i;
4809
4810 (void) isTA;
4811
4812 DBG (DBG_ASIC, "Asic_WaitCarriageHome:Enter\n");
4813
4814 for (i = 0; i < 100; i++)
4815 {
4816 status = IsCarriageHome (chip, &LampHome, &TAHome);
4817 if (LampHome)
4818 break;
4819 usleep (300000);
4820 }
4821 if (i == 100)
4822 status = SANE_STATUS_DEVICE_BUSY;
4823 DBG (DBG_ASIC, "Wait %d s\n", (unsigned short) (i * 0.3));
4824
4825 Mustek_SendData (chip, ES01_F4_ActiveTriger, ACTION_TRIGER_DISABLE);
4826 chip->firmwarestate = FS_OPENED;
4827 chip->motorstate = MS_STILL;
4828
4829 DBG (DBG_ASIC, "Asic_WaitCarriageHome: Exit\n");
4830 return status;
4831 }
4832
4833 static SANE_Status
Asic_SetCalibrate(PAsic chip, SANE_Byte bScanBits, unsigned short wXResolution, unsigned short wYResolution, unsigned short wX, unsigned short wY, unsigned short wWidth, unsigned short wLength, SANE_Bool isShading)4834 Asic_SetCalibrate (PAsic chip, SANE_Byte bScanBits, unsigned short wXResolution,
4835 unsigned short wYResolution, unsigned short wX, unsigned short wY,
4836 unsigned short wWidth, unsigned short wLength, SANE_Bool isShading)
4837 {
4838 SANE_Status status = SANE_STATUS_GOOD;
4839 unsigned short ValidPixelNumber;
4840
4841 unsigned short wPerLineNeedBufferSize = 0;
4842 unsigned short BytePerPixel = 0;
4843 unsigned int dwTotalLineTheBufferNeed = 0;
4844 unsigned short dwTotal_CCDResolution = 0;
4845 unsigned short wThinkCCDResolution = 0;
4846 unsigned short wCCD_PixelNumber = 0;
4847 unsigned short wScanAccSteps = 1;
4848 SANE_Byte byScanDecSteps = 1;
4849 unsigned int dwLineWidthPixel = 0;
4850
4851 unsigned short wNowMotorDPI;
4852 unsigned short XRatioTypeWord;
4853 double XRatioTypeDouble;
4854 double XRatioAdderDouble;
4855
4856 LLF_MOTORMOVE *lpMotorStepsTable =
4857 (LLF_MOTORMOVE *) malloc (sizeof (LLF_MOTORMOVE));
4858
4859 SANE_Byte byDummyCycleNum = 1;
4860 unsigned short Total_MotorDPI;
4861 unsigned short BeforeScanFixSpeedStep = 0;
4862 unsigned short BackTrackFixSpeedStep = 20;
4863 unsigned short wMultiMotorStep = 1;
4864 SANE_Byte bMotorMoveType = _MOTOR_MOVE_TYPE;
4865 SANE_Byte isMotorMoveToFirstLine = MOTOR_MOVE_TO_FIRST_LINE_DISABLE;
4866 SANE_Byte isUniformSpeedToScan = UNIFORM_MOTOR_AND_SCAN_SPEED_ENABLE;
4867 SANE_Byte isScanBackTracking = SCAN_BACK_TRACKING_DISABLE;
4868 unsigned int TotalStep = 0;
4869 unsigned short StartSpeed, EndSpeed;
4870 LLF_CALCULATEMOTORTABLE CalMotorTable;
4871 LLF_MOTOR_CURRENT_AND_PHASE CurrentPhase;
4872 LLF_RAMACCESS RamAccess;
4873 unsigned int dwStartAddr, dwEndAddr, dwTableBaseAddr;
4874 SANE_Byte byClear_Pulse_Width = 0;
4875 unsigned int dwLinePixelReport = 0;
4876 SANE_Byte byPHTG_PulseWidth, byPHTG_WaitWidth;
4877 unsigned short * lpMotorTable = (unsigned short *) malloc (512 * 8 * 2);
4878 unsigned int RealTableSize;
4879 unsigned short wFullBank;
4880
4881 DBG (DBG_ASIC, "Asic_SetCalibrate: Enter\n");
4882 DBG (DBG_ASIC,
4883 "bScanBits=%d,wXResolution=%d, wYResolution=%d, wX=%d, wY=%d, wWidth=%d, wLength=%d\n",
4884 bScanBits, wXResolution, wYResolution, wX, wY, wWidth, wLength);
4885
4886 if (chip->firmwarestate != FS_OPENED)
4887 {
4888 DBG (DBG_ERR, "Asic_SetCalibrate: Scanner is not opened\n");
4889 return SANE_STATUS_INVAL;
4890 }
4891
4892 if (lpMotorStepsTable == NULL)
4893 {
4894 DBG (DBG_ERR, "Asic_SetCalibrate: insufficiency memory!\n");
4895 return SANE_STATUS_INVAL;
4896 }
4897 DBG (DBG_ASIC, "malloc LLF_MOTORMOVE =%ld Byte\n", (long int) (sizeof (LLF_MOTORMOVE)));
4898
4899 Mustek_SendData (chip, ES01_F3_ActionOption, 0);
4900 Mustek_SendData (chip, ES01_86_DisableAllClockWhenIdle,
4901 CLOSE_ALL_CLOCK_DISABLE);
4902 Mustek_SendData (chip, ES01_F4_ActiveTriger, ACTION_TRIGER_DISABLE);
4903
4904 status = Asic_WaitUnitReady (chip);
4905
4906 Mustek_SendData (chip, 0x1CD, 0);
4907
4908 Mustek_SendData (chip, ES01_94_PowerSaveControl, 0x27 | 64 | 128);
4909
4910 if (bScanBits > 24)
4911 {
4912 wPerLineNeedBufferSize = wWidth * 6;
4913 BytePerPixel = 6;
4914 chip->dwBytesCountPerRow = (unsigned int) (wWidth) * 6;
4915 }
4916 else if (bScanBits == 24)
4917 {
4918 wPerLineNeedBufferSize = wWidth * 3;
4919 chip->dwCalibrationBytesCountPerRow = wWidth * 3;
4920 BytePerPixel = 3;
4921 chip->dwBytesCountPerRow = (unsigned int) (wWidth) * 3;
4922 }
4923 else if ((bScanBits > 8) && (bScanBits <= 16))
4924 {
4925 wPerLineNeedBufferSize = wWidth * 2;
4926 BytePerPixel = 2;
4927 chip->dwBytesCountPerRow = (unsigned int) (wWidth) * 2;
4928 }
4929 else if (bScanBits == 8)
4930 {
4931 wPerLineNeedBufferSize = wWidth;
4932 BytePerPixel = 1;
4933 chip->dwBytesCountPerRow = (unsigned int) (wWidth);
4934 }
4935 else if (bScanBits < 8)
4936 {
4937 wPerLineNeedBufferSize = wWidth >> 3;
4938 BytePerPixel = 1;
4939 chip->dwBytesCountPerRow = (unsigned int) (wWidth);
4940 }
4941 DBG (DBG_ASIC,
4942 "wPerLineNeedBufferSize=%d,BytePerPixel=%d,dwBytesCountPerRow=%d\n",
4943 wPerLineNeedBufferSize, BytePerPixel, chip->dwBytesCountPerRow);
4944
4945
4946 dwTotalLineTheBufferNeed = wLength;
4947 DBG (DBG_ASIC, "wPerLineNeedBufferSize=%d,wLength=%d\n",
4948 wPerLineNeedBufferSize, wLength);
4949
4950
4951 chip->Scan.Dpi = wXResolution;
4952 CCDTiming (chip);
4953
4954 dwTotal_CCDResolution = SENSOR_DPI;
4955 if (chip->lsLightSource == LS_REFLECTIVE)
4956 {
4957 if (wXResolution > (dwTotal_CCDResolution / 2))
4958 {
4959 wThinkCCDResolution = dwTotal_CCDResolution;
4960 Mustek_SendData (chip, ES01_98_GPIOControl8_15, 0x01);
4961 Mustek_SendData (chip, ES01_96_GPIOValue8_15, 0x01);
4962 wCCD_PixelNumber = chip->Timing.wCCDPixelNumber_1200;
4963 }
4964 else
4965 {
4966 wThinkCCDResolution = dwTotal_CCDResolution / 2;
4967 Mustek_SendData (chip, ES01_98_GPIOControl8_15, 0x01);
4968 Mustek_SendData (chip, ES01_96_GPIOValue8_15, 0x00);
4969 wCCD_PixelNumber = chip->Timing.wCCDPixelNumber_600;
4970 }
4971 }
4972 else
4973 {
4974 if (wXResolution > (dwTotal_CCDResolution / 2))
4975 {
4976 wThinkCCDResolution = dwTotal_CCDResolution;
4977 Mustek_SendData (chip, ES01_98_GPIOControl8_15, 0x01);
4978 Mustek_SendData (chip, ES01_96_GPIOValue8_15, 0x01);
4979 wCCD_PixelNumber = TA_CAL_PIXELNUMBER;
4980 }
4981 else
4982 {
4983 wThinkCCDResolution = dwTotal_CCDResolution / 2;
4984 Mustek_SendData (chip, ES01_98_GPIOControl8_15, 0x01);
4985 Mustek_SendData (chip, ES01_96_GPIOValue8_15, 0x00);
4986 wCCD_PixelNumber = TA_CAL_PIXELNUMBER;
4987 }
4988 }
4989 DBG (DBG_ASIC, "wThinkCCDResolution=%d,wCCD_PixelNumber=%d\n",
4990 wThinkCCDResolution, wCCD_PixelNumber);
4991
4992 dwLineWidthPixel = wWidth;
4993
4994 if (isShading)
4995 wYResolution = 600;
4996 DBG (DBG_ASIC, "dwLineWidthPixel=%d,wYResolution=%d\n", dwLineWidthPixel,
4997 wYResolution);
4998
4999 SetLineTimeAndExposure (chip);
5000 if (wYResolution == 600)
5001 {
5002 Mustek_SendData (chip, ES01_CB_CCDDummyCycleNumber, byDummyCycleNum);
5003 DBG (DBG_ASIC, "Find Boundary CCDDummyCycleNumber == %d\n",
5004 byDummyCycleNum);
5005 }
5006
5007 SetLEDTime (chip);
5008
5009 /* calculate Y ratio */
5010 Total_MotorDPI = 1200;
5011
5012 wNowMotorDPI = Total_MotorDPI;
5013 DBG (DBG_ASIC, "wNowMotorDPI=%d\n", wNowMotorDPI);
5014
5015 /* SetADConverter */
5016 Mustek_SendData (chip, ES01_74_HARDWARE_SETTING,
5017 MOTOR1_SERIAL_INTERFACE_G10_8_ENABLE | LED_OUT_G11_DISABLE
5018 | SLAVE_SERIAL_INTERFACE_G15_14_DISABLE |
5019 SHUTTLE_CCD_DISABLE);
5020
5021 /* set AFE */
5022 Mustek_SendData (chip, ES01_9A_AFEControl,
5023 AD9826_AFE | AUTO_CHANGE_AFE_GAIN_OFFSET_DISABLE);
5024 Mustek_SendData (chip, ES01_F7_DigitalControl, DIGITAL_REDUCE_DISABLE);
5025
5026 XRatioTypeDouble = wXResolution;
5027 XRatioTypeDouble /= wThinkCCDResolution;
5028 XRatioAdderDouble = 1 / XRatioTypeDouble;
5029 XRatioTypeWord = (unsigned short) (XRatioTypeDouble * 32768);
5030
5031 XRatioAdderDouble = (double) (XRatioTypeWord) / 32768;
5032 XRatioAdderDouble = 1 / XRatioAdderDouble;
5033
5034 Mustek_SendData (chip, ES01_9E_HorizontalRatio1to15LSB,
5035 LOBYTE (XRatioTypeWord));
5036 Mustek_SendData (chip, ES01_9F_HorizontalRatio1to15MSB,
5037 HIBYTE (XRatioTypeWord));
5038 DBG (DBG_ASIC,
5039 "XRatioTypeDouble=%.2f,XRatioAdderDouble=%.2f,XRatioTypeWord=%d\n",
5040 XRatioTypeDouble, XRatioAdderDouble, XRatioTypeWord);
5041
5042 if (chip->isMotorMove == MOTOR_0_ENABLE)
5043 {
5044 Mustek_SendData (chip, ES01_A6_MotorOption, MOTOR_0_ENABLE |
5045 MOTOR_1_DISABLE |
5046 HOME_SENSOR_0_ENABLE | ES03_TABLE_DEFINE);
5047 }
5048 else
5049 {
5050 Mustek_SendData (chip, ES01_A6_MotorOption, MOTOR_0_DISABLE |
5051 MOTOR_1_DISABLE |
5052 HOME_SENSOR_0_ENABLE | ES03_TABLE_DEFINE);
5053 }
5054 DBG (DBG_ASIC, "isMotorMove=%d\n", chip->isMotorMove);
5055
5056 Mustek_SendData (chip, ES01_F6_MorotControl1, SPEED_UNIT_1_PIXEL_TIME |
5057 MOTOR_SYNC_UNIT_1_PIXEL_TIME);
5058
5059 wScanAccSteps = 1;
5060 byScanDecSteps = 1;
5061 DBG (DBG_ASIC, "wScanAccSteps=%d,byScanDecSteps=%d\n", wScanAccSteps,
5062 byScanDecSteps);
5063
5064 Mustek_SendData (chip, ES01_AE_MotorSyncPixelNumberM16LSB, LOBYTE (0));
5065 Mustek_SendData (chip, ES01_AF_MotorSyncPixelNumberM16MSB, HIBYTE (0));
5066 DBG (DBG_ASIC, "MotorSyncPixelNumber=%d\n", 0);
5067
5068 Mustek_SendData (chip, ES01_EC_ScanAccStep0_7, LOBYTE (wScanAccSteps));
5069 Mustek_SendData (chip, ES01_ED_ScanAccStep8_8, HIBYTE (wScanAccSteps));
5070 DBG (DBG_ASIC, "wScanAccSteps=%d\n", wScanAccSteps);
5071
5072 DBG (DBG_ASIC, "BeforeScanFixSpeedStep=%d,BackTrackFixSpeedStep=%d\n",
5073 BeforeScanFixSpeedStep, BackTrackFixSpeedStep);
5074
5075 Mustek_SendData (chip, ES01_EE_FixScanStepLSB,
5076 LOBYTE (BeforeScanFixSpeedStep));
5077 Mustek_SendData (chip, ES01_8A_FixScanStepMSB,
5078 HIBYTE (BeforeScanFixSpeedStep));
5079 DBG (DBG_ASIC, "BeforeScanFixSpeedStep=%d\n", BeforeScanFixSpeedStep);
5080
5081 Mustek_SendData (chip, ES01_EF_ScanDecStep, byScanDecSteps);
5082 DBG (DBG_ASIC, "byScanDecSteps=%d\n", byScanDecSteps);
5083
5084 Mustek_SendData (chip, ES01_E6_ScanBackTrackingStepLSB,
5085 LOBYTE (BackTrackFixSpeedStep));
5086 Mustek_SendData (chip, ES01_E7_ScanBackTrackingStepMSB,
5087 HIBYTE (BackTrackFixSpeedStep));
5088 DBG (DBG_ASIC, "BackTrackFixSpeedStep=%d\n", BackTrackFixSpeedStep);
5089
5090 Mustek_SendData (chip, ES01_E8_ScanRestartStepLSB,
5091 LOBYTE (BackTrackFixSpeedStep));
5092 Mustek_SendData (chip, ES01_E9_ScanRestartStepMSB,
5093 HIBYTE (BackTrackFixSpeedStep));
5094 DBG (DBG_ASIC, "BackTrackFixSpeedStep=%d\n", BackTrackFixSpeedStep);
5095
5096 switch (bMotorMoveType)
5097 {
5098 case _4_TABLE_SPACE_FOR_FULL_STEP:
5099 wMultiMotorStep = 1;
5100 break;
5101
5102 case _8_TABLE_SPACE_FOR_1_DIV_2_STEP:
5103 wMultiMotorStep = 2;
5104 break;
5105
5106 case _16_TABLE_SPACE_FOR_1_DIV_4_STEP:
5107 wMultiMotorStep = 4;
5108 break;
5109
5110 case _32_TABLE_SPACE_FOR_1_DIV_8_STEP:
5111 wMultiMotorStep = 8;
5112 break;
5113 }
5114 DBG (DBG_ASIC, "wMultiMotorStep=%d\n", wMultiMotorStep);
5115
5116 TotalStep = wScanAccSteps + BeforeScanFixSpeedStep +
5117 (dwTotalLineTheBufferNeed * wNowMotorDPI / wYResolution) + byScanDecSteps;
5118 DBG (DBG_ASIC, "TotalStep=%d\n", TotalStep);
5119
5120 Mustek_SendData (chip, ES01_F0_ScanImageStep0_7, (SANE_Byte) (TotalStep));
5121 Mustek_SendData (chip, ES01_F1_ScanImageStep8_15, (SANE_Byte) (TotalStep >> 8));
5122 Mustek_SendData (chip, ES01_F2_ScanImageStep16_19,
5123 (SANE_Byte) (TotalStep >> 16));
5124
5125 SetScanMode (chip, bScanBits);
5126
5127 DBG (DBG_ASIC,
5128 "isMotorMoveToFirstLine=%d,isUniformSpeedToScan=%d,isScanBackTracking=%d\n",
5129 isMotorMoveToFirstLine, isUniformSpeedToScan, isScanBackTracking);
5130
5131
5132 Mustek_SendData (chip, ES01_F3_ActionOption, isMotorMoveToFirstLine |
5133 MOTOR_BACK_HOME_AFTER_SCAN_DISABLE |
5134 SCAN_ENABLE |
5135 isScanBackTracking |
5136 INVERT_MOTOR_DIRECTION_DISABLE |
5137 isUniformSpeedToScan |
5138 ES01_STATIC_SCAN_DISABLE | MOTOR_TEST_LOOP_DISABLE);
5139
5140 if (chip->lsLightSource == LS_REFLECTIVE)
5141 Mustek_SendData (chip, ES01_F8_WHITE_SHADING_DATA_FORMAT,
5142 ES01_SHADING_3_INT_13_DEC);
5143 else
5144 Mustek_SendData (chip, ES01_F8_WHITE_SHADING_DATA_FORMAT,
5145 ES01_SHADING_4_INT_12_DEC);
5146
5147 SetPackAddress (chip, wXResolution, wWidth, wX, XRatioAdderDouble,
5148 XRatioTypeDouble, byClear_Pulse_Width, &ValidPixelNumber);
5149 SetExtraSetting (chip, wXResolution, wCCD_PixelNumber, TRUE);
5150
5151 byPHTG_PulseWidth = chip->Timing.PHTG_PluseWidth;
5152 byPHTG_WaitWidth = chip->Timing.PHTG_WaitWidth;
5153 dwLinePixelReport = ((byClear_Pulse_Width + 1) * 2 +
5154 (byPHTG_PulseWidth + 1) * (1) +
5155 (byPHTG_WaitWidth + 1) * (1) +
5156 (wCCD_PixelNumber + 1)) * (byDummyCycleNum + 1);
5157
5158 DBG (DBG_ASIC, "Motor Time = %d\n",
5159 (dwLinePixelReport * wYResolution / wNowMotorDPI));
5160 if ((dwLinePixelReport * wYResolution / wNowMotorDPI) > 64000)
5161 {
5162 DBG (DBG_ASIC, "Motor Time Over Flow !!!\n");
5163 }
5164
5165 EndSpeed = (unsigned short) (dwLinePixelReport / (wNowMotorDPI / wYResolution));
5166
5167 if (wXResolution > 600)
5168 {
5169 StartSpeed = EndSpeed;
5170 }
5171 else
5172 {
5173 StartSpeed = EndSpeed + 3500;
5174 }
5175 DBG (DBG_ASIC, "StartSpeed =%d, EndSpeed = %d\n", StartSpeed, EndSpeed);
5176
5177
5178 Mustek_SendData (chip, ES01_FD_MotorFixedspeedLSB, LOBYTE (EndSpeed));
5179 Mustek_SendData (chip, ES01_FE_MotorFixedspeedMSB, HIBYTE (EndSpeed));
5180 memset (lpMotorTable, 0, 512 * 8 * sizeof (unsigned short));
5181
5182 CalMotorTable.StartSpeed = StartSpeed;
5183 CalMotorTable.EndSpeed = EndSpeed;
5184 CalMotorTable.AccStepBeforeScan = wScanAccSteps;
5185 CalMotorTable.lpMotorTable = lpMotorTable;
5186
5187 LLFCalculateMotorTable (&CalMotorTable);
5188
5189 CurrentPhase.MotorDriverIs3967 = 0;
5190 CurrentPhase.FillPhase = 1;
5191 CurrentPhase.MoveType = bMotorMoveType;
5192 CurrentPhase.MotorCurrentTableA[0] = 200;
5193 CurrentPhase.MotorCurrentTableB[0] = 200;
5194 LLFSetMotorCurrentAndPhase (chip, &CurrentPhase);
5195
5196 RealTableSize = 512 * 8;
5197 dwTableBaseAddr = PackAreaStartAddress - RealTableSize;
5198
5199 dwStartAddr = dwTableBaseAddr;
5200
5201 RamAccess.ReadWrite = WRITE_RAM;
5202 RamAccess.IsOnChipGamma = EXTERNAL_RAM;
5203 RamAccess.DramDelayTime = SDRAMCLK_DELAY_12_ns;
5204 RamAccess.LoStartAddress = (unsigned short) (dwStartAddr);
5205 RamAccess.HiStartAddress = (unsigned short) (dwStartAddr >> 16);
5206 RamAccess.RwSize = RealTableSize * 2;
5207 RamAccess.BufferPtr = (SANE_Byte *) lpMotorTable;
5208 LLFRamAccess (chip, &RamAccess);
5209
5210 Mustek_SendData (chip, ES01_9D_MotorTableAddrA14_A21,
5211 (SANE_Byte) (dwTableBaseAddr >> TABLE_OFFSET_BASE));
5212
5213 dwEndAddr = PackAreaStartAddress - (512 * 8) - 1;
5214
5215 Mustek_SendData (chip, ES01_FB_BufferEmptySize16WordLSB,
5216 LOBYTE (WaitBufferOneLineSize >> (7 - 3)));
5217 Mustek_SendData (chip, ES01_FC_BufferEmptySize16WordMSB,
5218 HIBYTE (WaitBufferOneLineSize >> (7 - 3)));
5219
5220 wFullBank =
5221 (unsigned short) ((dwEndAddr -
5222 (((dwLineWidthPixel * BytePerPixel) / 2) * 3 * 1)) / BANK_SIZE);
5223 Mustek_SendData (chip, ES01_F9_BufferFullSize16WordLSB, LOBYTE (wFullBank));
5224 Mustek_SendData (chip, ES01_FA_BufferFullSize16WordMSB, HIBYTE (wFullBank));
5225
5226 Mustek_SendData (chip, ES01_DB_PH_RESET_EDGE_TIMING_ADJUST, 0x00);
5227
5228 LLFSetRamAddress (chip, 0x0, dwEndAddr, ACCESS_DRAM);
5229
5230 Mustek_SendData (chip, ES01_DC_CLEAR_EDGE_TO_PH_TG_EDGE_WIDTH, 0);
5231
5232 Mustek_SendData (chip, ES01_00_ADAFEConfiguration, 0x70);
5233 Mustek_SendData (chip, ES01_02_ADAFEMuxConfig, 0x80);
5234
5235
5236 free (lpMotorTable);
5237 free (lpMotorStepsTable);
5238
5239 DBG (DBG_ASIC, "Asic_SetCalibrate: Exit\n");
5240 return status;
5241 }
5242
5243
5244 static SANE_Status
Asic_SetAFEGainOffset(PAsic chip)5245 Asic_SetAFEGainOffset (PAsic chip)
5246 {
5247 SANE_Status status = SANE_STATUS_GOOD;
5248 DBG (DBG_ASIC, "Asic_SetAFEGainOffset:Enter\n");
5249
5250 status = SetAFEGainOffset (chip);
5251
5252 DBG (DBG_ASIC, "Asic_SetAFEGainOffset: Exit\n");
5253 return status;
5254 }
5255