From ed43548de752d2f02fcd42158f1f5bfac6f39ec8 Mon Sep 17 00:00:00 2001 From: pimvantend Date: Sat, 22 Aug 2020 11:15:44 +0200 Subject: [PATCH] first support for the lide600. 1200dpi dropped. --- backend/canon_lide70-common.c | 2280 +++++++++++++++++++++++++++++---- backend/canon_lide70.c | 4 + doc/sane-canon_lide70.man | 27 +- 3 files changed, 2055 insertions(+), 256 deletions(-) diff --git a/backend/canon_lide70-common.c b/backend/canon_lide70-common.c index a50f12df4..d96acff15 100644 --- a/backend/canon_lide70-common.c +++ b/backend/canon_lide70-common.c @@ -142,12 +142,19 @@ cp2155_set (int fd, CP2155_Register reg, byte data) cmd_buffer[3] = 0x00; cmd_buffer[4] = data; + DBG (1, "cp2155_set %02x %02x %02x %02x %02x\n", + cmd_buffer[0], cmd_buffer[1], cmd_buffer[2], + cmd_buffer[3], cmd_buffer[4]); +/* + usleep (100 * MSEC); +*/ count = 5; status = sanei_usb_write_bulk (fd, cmd_buffer, &count); if (status != SANE_STATUS_GOOD) { DBG (1, "cp2155_set: sanei_usb_write_bulk error\n"); +/* exit(0); */ } return status; @@ -351,80 +358,6 @@ static byte cp2155_gamma_greenblue_data[] = { 0xfe, 0xfe, 0xff, 0xff }; -/* size=0x01f4 */ -static byte cp2155_slope09_back[] = { - 0x80, 0x25, 0x00, 0x25, 0x84, 0x24, 0x0b, 0x24, 0x96, 0x23, 0x23, 0x23, - 0xb3, 0x22, 0x46, 0x22, - 0xdb, 0x21, 0x73, 0x21, 0x0e, 0x21, 0xab, 0x20, 0x4a, 0x20, 0xeb, 0x1f, - 0x8f, 0x1f, 0x34, 0x1f, - 0xdc, 0x1e, 0x85, 0x1e, 0x31, 0x1e, 0xde, 0x1d, 0x8d, 0x1d, 0x3e, 0x1d, - 0xf0, 0x1c, 0xa4, 0x1c, - 0x59, 0x1c, 0x10, 0x1c, 0xc9, 0x1b, 0x83, 0x1b, 0x3e, 0x1b, 0xfa, 0x1a, - 0xb8, 0x1a, 0x77, 0x1a, - 0x38, 0x1a, 0xf9, 0x19, 0xbc, 0x19, 0x80, 0x19, 0x44, 0x19, 0x0a, 0x19, - 0xd1, 0x18, 0x99, 0x18, - 0x62, 0x18, 0x2c, 0x18, 0xf7, 0x17, 0xc3, 0x17, 0x8f, 0x17, 0x5d, 0x17, - 0x2b, 0x17, 0xfa, 0x16, - 0xca, 0x16, 0x9b, 0x16, 0x6c, 0x16, 0x3e, 0x16, 0x11, 0x16, 0xe5, 0x15, - 0xb9, 0x15, 0x8e, 0x15, - 0x64, 0x15, 0x3a, 0x15, 0x11, 0x15, 0xe9, 0x14, 0xc1, 0x14, 0x9a, 0x14, - 0x73, 0x14, 0x4d, 0x14, - 0x27, 0x14, 0x02, 0x14, 0xde, 0x13, 0xba, 0x13, 0x96, 0x13, 0x74, 0x13, - 0x51, 0x13, 0x2f, 0x13, - 0x0d, 0x13, 0xec, 0x12, 0xcc, 0x12, 0xab, 0x12, 0x8c, 0x12, 0x6c, 0x12, - 0x4d, 0x12, 0x2f, 0x12, - 0x11, 0x12, 0xf3, 0x11, 0xd5, 0x11, 0xb8, 0x11, 0x9c, 0x11, 0x80, 0x11, - 0x64, 0x11, 0x48, 0x11, - 0x2d, 0x11, 0x12, 0x11, 0xf7, 0x10, 0xdd, 0x10, 0xc3, 0x10, 0xa9, 0x10, - 0x90, 0x10, 0x77, 0x10, - 0x5e, 0x10, 0x46, 0x10, 0x2e, 0x10, 0x16, 0x10, 0xfe, 0x0f, 0xe7, 0x0f, - 0xd0, 0x0f, 0xb9, 0x0f, - 0xa2, 0x0f, 0x8c, 0x0f, 0x76, 0x0f, 0x60, 0x0f, 0x4b, 0x0f, 0x35, 0x0f, - 0x20, 0x0f, 0x0b, 0x0f, - 0xf7, 0x0e, 0xe2, 0x0e, 0xce, 0x0e, 0xba, 0x0e, 0xa6, 0x0e, 0x92, 0x0e, - 0x7f, 0x0e, 0x6c, 0x0e, - 0x59, 0x0e, 0x46, 0x0e, 0x33, 0x0e, 0x21, 0x0e, 0x0f, 0x0e, 0xfd, 0x0d, - 0xeb, 0x0d, 0xd9, 0x0d, - 0xc8, 0x0d, 0xb6, 0x0d, 0xa5, 0x0d, 0x94, 0x0d, 0x83, 0x0d, 0x73, 0x0d, - 0x62, 0x0d, 0x52, 0x0d, - 0x41, 0x0d, 0x31, 0x0d, 0x22, 0x0d, 0x12, 0x0d, 0x02, 0x0d, 0xf3, 0x0c, - 0xe3, 0x0c, 0xd4, 0x0c, - 0xc5, 0x0c, 0xb6, 0x0c, 0xa7, 0x0c, 0x99, 0x0c, 0x8a, 0x0c, 0x7c, 0x0c, - 0x6e, 0x0c, 0x60, 0x0c, - 0x52, 0x0c, 0x44, 0x0c, 0x36, 0x0c, 0x28, 0x0c, 0x1b, 0x0c, 0x0d, 0x0c, - 0x00, 0x0c, 0xf3, 0x0b, - 0xe6, 0x0b, 0xd9, 0x0b, 0xcc, 0x0b, 0xbf, 0x0b, 0xb3, 0x0b, 0xa6, 0x0b, - 0x9a, 0x0b, 0x8e, 0x0b, - 0x81, 0x0b, 0x75, 0x0b, 0x69, 0x0b, 0x5d, 0x0b, 0x52, 0x0b, 0x46, 0x0b, - 0x3a, 0x0b, 0x2f, 0x0b, - 0x23, 0x0b, 0x18, 0x0b, 0x0d, 0x0b, 0x02, 0x0b, 0xf6, 0x0a, 0xeb, 0x0a, - 0xe1, 0x0a, 0xd6, 0x0a, - 0xcb, 0x0a, 0xc0, 0x0a, 0xb6, 0x0a, 0xab, 0x0a, 0xa1, 0x0a, 0x97, 0x0a, - 0x8c, 0x0a, 0x82, 0x0a, - 0x78, 0x0a, 0x6e, 0x0a, 0x64, 0x0a, 0x5a, 0x0a, 0x50, 0x0a, 0x47, 0x0a, - 0x3d, 0x0a, 0x33, 0x0a, - 0x2a, 0x0a, 0x20, 0x0a, 0x17, 0x0a, 0x0e, 0x0a, 0x04, 0x0a, 0xfb, 0x09, - 0xf2, 0x09, 0xe9, 0x09, - 0xe0, 0x09, 0xd7, 0x09, 0xce, 0x09, 0xc6, 0x09, 0xbd, 0x09, 0xb4, 0x09, - 0xab, 0x09, 0xa3, 0x09, - 0x9a, 0x09, 0x92, 0x09, 0x8a, 0x09, 0x81, 0x09, 0x79, 0x09, 0x71, 0x09, - 0x69, 0x09, 0x61, 0x09, - 0x59, 0x09, 0x51, 0x09, 0x49, 0x09, 0x41, 0x09, 0x39, 0x09, 0x31, 0x09, - 0x29, 0x09, 0x22, 0x09, - 0x1a, 0x09, 0x12, 0x09, 0x0b, 0x09, 0x03, 0x09, 0xfc, 0x08, 0xf5, 0x08, - 0xed, 0x08, 0xe6, 0x08, - 0xdf, 0x08, 0xd8, 0x08, 0xd0, 0x08, 0xc9, 0x08, 0xc2, 0x08, 0xbb, 0x08, - 0xb4, 0x08, 0xad, 0x08, - 0xa6, 0x08, 0xa0, 0x08 -}; - -/* size=0x0018 */ -static byte cp2155_slope10_back[] = { - 0x80, 0x25, 0xc0, 0x1c, 0x4f, 0x17, 0x9a, 0x13, 0xe9, 0x10, 0xde, 0x0e, - 0x44, 0x0d, 0xfa, 0x0b, - 0xea, 0x0a, 0x07, 0x0a, 0x46, 0x09, 0xa0, 0x08 -}; - static void cp2155_block2 (int fd, unsigned int addr) { @@ -439,77 +372,6 @@ cp2155_block3 (int fd, unsigned int addr) cp2155_block1 (fd, 0x16, addr, cp2155_gamma_greenblue_data, 0x0100); } -static void -cp2155_set_slope (int fd, unsigned int addr, byte * data, size_t size) -{ -/* - DBG (1, "cp2155_set_slope %06x %04lx\n", addr, (u_long) size); -*/ - cp2155_block1 (fd, 0x14, addr, data, size); -} - -/* size=0x0075 */ -static byte cp2155_set_regs_data6[] = { - 0x00, 0x00, 0x00, 0x69, 0x00, 0xe8, 0x1d, 0x00, 0x00, 0x70, 0x00, 0x00, - 0x00, 0x2e, 0x00, 0x04, - 0x04, 0xf8, 0x07, 0x32, 0x32, 0x32, 0x32, 0x00, 0x01, 0x00, 0x01, 0x00, - 0x01, 0x00, 0x01, 0x02, - 0x00, 0x03, 0x15, 0x15, 0x15, 0x15, 0x04, 0x07, 0x29, 0x29, 0x09, 0x09, - 0x02, 0x06, 0x12, 0x12, - 0x03, 0x05, 0x05, 0x03, 0x05, 0x41, 0x61, 0x21, 0x21, 0x25, 0x25, 0x25, - 0x40, 0x40, 0x40, 0x06, - 0x40, 0x06, 0x00, 0x36, 0xd0, 0x00, 0x00, 0x06, 0x00, 0x00, 0x02, 0x83, - 0x7c, 0x02, 0x1c, 0x9c, - 0x38, 0x28, 0x28, 0x27, 0x27, 0x25, 0x25, 0x21, 0x21, 0x1c, 0x1c, 0x16, - 0x16, 0x0f, 0x0f, 0x08, - 0x08, 0x00, 0x00, 0x08, 0x08, 0x0f, 0x0f, 0x16, 0x16, 0x1c, 0x1c, 0x21, - 0x21, 0x25, 0x25, 0x27, - 0x27, 0x02, 0x02, 0x22, 0x00 -}; - -/* size=0x0075 */ -static byte cp2155_set_regs_nr[] = { - 0x07, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0xa0, 0xa1, 0xa2, 0xa3, 0x64, 0x65, - 0x61, 0x62, 0x63, 0x50, - 0x50, 0x90, 0x51, 0x5a, 0x5b, 0x5c, 0x5d, 0x52, 0x53, 0x54, 0x55, 0x56, - 0x57, 0x58, 0x59, 0x5e, - 0x5f, 0x5f, 0x60, 0x60, 0x60, 0x60, 0x50, 0x51, 0x81, 0x81, 0x82, 0x82, - 0x83, 0x84, 0x80, 0x80, - 0xb0, 0x10, 0x10, 0x9b, 0x10, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, - 0x12, 0x13, 0x16, 0x21, - 0x22, 0x20, 0x1d, 0x1e, 0x1f, 0x66, 0x67, 0x68, 0x1a, 0x1b, 0x1c, 0x15, - 0x14, 0x17, 0x43, 0x44, - 0x45, 0x23, 0x33, 0x24, 0x34, 0x25, 0x35, 0x26, 0x36, 0x27, 0x37, 0x28, - 0x38, 0x29, 0x39, 0x2a, - 0x3a, 0x2b, 0x3b, 0x2c, 0x3c, 0x2d, 0x3d, 0x2e, 0x3e, 0x2f, 0x3f, 0x30, - 0x40, 0x31, 0x41, 0x32, - 0x42, 0xca, 0xca, 0xca, 0x18 -}; - -static void -cp2155_set_regs (int fd, byte * data) -{ - DBG (1, "cp2155_set_regs\n"); - int i; - - for (i = 0; i < 0x0075; i++) - { - if (cp2155_set_regs_nr[i] != 0x90) - { - cp2155_set (fd, cp2155_set_regs_nr[i], data[i]); - } - } -} - -static void -cp2155_block5 (int fd, byte v001) -{ - DBG (1, "cp2155_block5 %02x\n", v001); - cp2155_set (fd, 0x90, 0xd8); - cp2155_set (fd, 0x90, 0xd8); - cp2155_set (fd, 0xb0, v001); -} - static void cp2155_block6 (int fd, byte v001, byte v002) { @@ -636,6 +498,26 @@ general_motor (int fd) cp2155_set (fd, 0x0264, 0x20); } +void +general_motor_600 (int fd) +{ + cp2155_set (fd, 0x90, 0xfa); + cp2155_set (fd, 0x10, 0x05); + cp2155_set (fd, 0x11, 0x91); + cp2155_set (fd, 0x60, 0x01); + cp2155_set (fd, 0x80, 0x12); + cp2155_set (fd, 0x03, 0x01); + cp2155_set (fd, 0x71, 0x01); + cp2155_set (fd, 0x0230, 0x11); + cp2155_set (fd, 0x71, 0x18); + cp2155_set (fd, 0x72, 0x00); + cp2155_set (fd, 0x73, 0x10); + cp2155_set (fd, 0x0239, 0x40); + cp2155_set (fd, 0x0238, 0x89); + cp2155_set (fd, 0x023c, 0x2f); + cp2155_set (fd, 0x0264, 0x20); +} + void startblob0075 (CANON_Handle * chndl, unsigned char *buf) { @@ -1368,6 +1250,154 @@ startblob0600 (CANON_Handle * chndl, unsigned char *buf) general_motor (fd); } +void +startblob0600_extra (CANON_Handle * chndl, unsigned char *buf) +{ + + int fd; + fd = chndl->fd; + size_t count; + + cp2155_set (fd, 0x90, 0xd8); + cp2155_set (fd, 0x90, 0xd8); + cp2155_set (fd, 0xb0, 0x00); + cp2155_set (fd, 0x07, 0x00); + cp2155_set (fd, 0x07, 0x00); + cp2155_set (fd, 0x08, chndl->value_08); + cp2155_set (fd, 0x09, chndl->value_09); + cp2155_set (fd, 0x0a, chndl->value_0a); + cp2155_set (fd, 0x0b, chndl->value_0b); + cp2155_set (fd, 0xa0, 0x1d); + cp2155_set (fd, 0xa1, 0x00); + cp2155_set (fd, 0xa2, 0x31); + cp2155_set (fd, 0xa3, 0xf0); + cp2155_set (fd, 0x64, 0x00); + cp2155_set (fd, 0x65, 0x00); + cp2155_set (fd, 0x61, 0x00); + cp2155_set (fd, 0x62, 0x55); + cp2155_set (fd, 0x63, 0x00); + cp2155_set (fd, 0x50, 0x04); + cp2155_set (fd, 0x50, 0x04); + cp2155_set (fd, 0x51, chndl->value_51); + cp2155_set (fd, 0x5a, 0x32); + cp2155_set (fd, 0x5b, 0x32); + cp2155_set (fd, 0x5c, 0x32); + cp2155_set (fd, 0x5d, 0x32); + cp2155_set (fd, 0x52, 0x09); + cp2155_set (fd, 0x53, 0x5a); + cp2155_set (fd, 0x54, 0x06); + cp2155_set (fd, 0x55, 0x08); + cp2155_set (fd, 0x56, 0x05); + cp2155_set (fd, 0x57, 0x5f); + cp2155_set (fd, 0x58, 0xa9); + cp2155_set (fd, 0x59, 0xce); + cp2155_set (fd, 0x5e, 0x02); + cp2155_set (fd, 0x5f, 0x00); + cp2155_set (fd, 0x5f, 0x03); + cp2155_set (fd, 0x60, 0x15); + cp2155_set (fd, 0x60, 0x15); + cp2155_set (fd, 0x60, 0x15); + cp2155_set (fd, 0x60, 0x15); + cp2155_set (fd, 0x50, 0x04); + cp2155_set (fd, 0x51, chndl->value_51); + cp2155_set (fd, 0x81, 0x29); + cp2155_set (fd, 0x81, 0x29); + cp2155_set (fd, 0x82, 0x09); + cp2155_set (fd, 0x82, 0x09); + cp2155_set (fd, 0x83, 0x02); + cp2155_set (fd, 0x84, 0x06); + cp2155_set (fd, 0x80, 0x12); + cp2155_set (fd, 0x80, 0x12); + cp2155_set (fd, 0xb0, 0x08); + + big_write (fd, 0x5174, buf); + + cp2155_set (fd, 0x10, 0x05); + cp2155_set (fd, 0x10, 0x05); + cp2155_set (fd, 0x9b, 0x01); + cp2155_set (fd, 0x10, 0x05); + cp2155_set (fd, 0x11, 0x81); + cp2155_set (fd, 0x11, 0x81); + cp2155_set (fd, 0x11, 0x81); + cp2155_set (fd, 0x11, 0x81); + cp2155_set (fd, 0x11, 0x81); + cp2155_set (fd, 0x11, 0x81); + cp2155_set (fd, 0x11, 0x81); + cp2155_set (fd, 0x12, 0x06); + cp2155_set (fd, 0x13, 0x06); + cp2155_set (fd, 0x16, 0x06); + cp2155_set (fd, 0x21, 0x06); + cp2155_set (fd, 0x22, 0x06); + cp2155_set (fd, 0x20, 0x06); + cp2155_set (fd, 0x1d, 0x00); + cp2155_set (fd, 0x1e, 0x00); + cp2155_set (fd, 0x1f, 0x04); + cp2155_set (fd, 0x66, 0x00); + cp2155_set (fd, 0x67, 0x0f); + cp2155_set (fd, 0x68, 0x39); + cp2155_set (fd, 0x1a, 0x00); + cp2155_set (fd, 0x1b, 0x00); + cp2155_set (fd, 0x1c, 0x02); + cp2155_set (fd, 0x15, 0x80); + cp2155_set (fd, 0x14, 0x7c); + cp2155_set (fd, 0x17, 0x01); + cp2155_set (fd, 0x43, 0x1c); + cp2155_set (fd, 0x44, 0x9c); + cp2155_set (fd, 0x45, 0x38); + cp2155_set (fd, 0x23, 0x14); + cp2155_set (fd, 0x33, 0x14); + cp2155_set (fd, 0x24, 0x14); + cp2155_set (fd, 0x34, 0x14); + cp2155_set (fd, 0x25, 0x14); + cp2155_set (fd, 0x35, 0x14); + cp2155_set (fd, 0x26, 0x14); + cp2155_set (fd, 0x36, 0x14); + cp2155_set (fd, 0x27, 0x14); + cp2155_set (fd, 0x37, 0x14); + cp2155_set (fd, 0x28, 0x14); + cp2155_set (fd, 0x38, 0x14); + cp2155_set (fd, 0x29, 0x14); + cp2155_set (fd, 0x39, 0x14); + cp2155_set (fd, 0x2a, 0x14); + cp2155_set (fd, 0x3a, 0x14); + cp2155_set (fd, 0x2b, 0x14); + cp2155_set (fd, 0x3b, 0x14); + cp2155_set (fd, 0x2c, 0x14); + cp2155_set (fd, 0x3c, 0x14); + cp2155_set (fd, 0x2d, 0x14); + cp2155_set (fd, 0x3d, 0x14); + cp2155_set (fd, 0x2e, 0x14); + cp2155_set (fd, 0x3e, 0x14); + cp2155_set (fd, 0x2f, 0x14); + cp2155_set (fd, 0x3f, 0x14); + cp2155_set (fd, 0x30, 0x14); + cp2155_set (fd, 0x40, 0x14); + cp2155_set (fd, 0x31, 0x14); + cp2155_set (fd, 0x41, 0x14); + cp2155_set (fd, 0x32, 0x14); + cp2155_set (fd, 0x42, 0x14); + cp2155_set (fd, 0xca, 0x00); + cp2155_set (fd, 0xca, 0x00); + cp2155_set (fd, 0xca, 0x00); + cp2155_set (fd, 0x18, 0x00); + + memcpy (buf + 0x00000000, + "\x04\x70\x18\x00\x80\x7f\x80\x7f\x80\x7f\x80\x7f\x80\x7f\x80\x7f", + 16); + memcpy (buf + 0x00000010, + "\x80\x7f\x80\x7f\x80\x7f\x80\x7f\x80\x7f\x80\x7f\x00\x00\x00\x00", + 16); + memcpy (buf + 0x00000020, "\x00\x00\x00\x00", 4); + count = 36; + write_buf (fd, count, buf, 0x03, 0x00); + write_buf (fd, count, buf, 0x03, 0x02); + write_buf (fd, count, buf, 0x03, 0x06); + write_buf (fd, count, buf, 0x03, 0x04); + write_buf (fd, count, buf, 0x03, 0x08); + + general_motor (fd); +} + void startblob1200 (CANON_Handle * chndl, unsigned char *buf) { @@ -1516,6 +1546,1030 @@ startblob1200 (CANON_Handle * chndl, unsigned char *buf) general_motor (fd); } +void +startblob_600_0075 (CANON_Handle * chndl, unsigned char *buf) +{ + + int fd; + fd = chndl->fd; + size_t count; + + cp2155_set (fd, 0x90, 0xe8); + cp2155_set (fd, 0x9b, 0x06); + cp2155_set (fd, 0x9b, 0x04); + cp2155_set (fd, 0x90, 0xf8); + cp2155_set (fd, 0xb0, 0x03); + cp2155_set (fd, 0x07, 0x00); + cp2155_set (fd, 0x07, 0x00); + cp2155_set (fd, 0x08, chndl->value_08); + cp2155_set (fd, 0x09, chndl->value_09); + cp2155_set (fd, 0x0a, chndl->value_0a); + cp2155_set (fd, 0x0b, chndl->value_0b); + cp2155_set (fd, 0xa0, 0x1d); + cp2155_set (fd, 0xa1, 0x00); + cp2155_set (fd, 0xa2, 0x06); + cp2155_set (fd, 0xa3, 0x70); + cp2155_set (fd, 0x64, 0x00); + cp2155_set (fd, 0x65, 0x00); + cp2155_set (fd, 0x61, 0x00); + cp2155_set (fd, 0x62, 0x2e); + cp2155_set (fd, 0x63, 0x00); + cp2155_set (fd, 0x50, 0x04); + cp2155_set (fd, 0x50, 0x04); + cp2155_set (fd, 0x90, 0xf8); + cp2155_set (fd, 0x51, chndl->value_51); + cp2155_set (fd, 0x5a, 0xff); + cp2155_set (fd, 0x5b, 0xff); + cp2155_set (fd, 0x5c, 0xff); + cp2155_set (fd, 0x5d, 0xff); + cp2155_set (fd, 0x52, 0x0c); + cp2155_set (fd, 0x53, 0xda); + cp2155_set (fd, 0x54, 0x0c); + cp2155_set (fd, 0x55, 0x44); + cp2155_set (fd, 0x56, 0x08); + cp2155_set (fd, 0x57, 0xbb); + cp2155_set (fd, 0x58, 0x1d); + cp2155_set (fd, 0x59, 0xa1); + cp2155_set (fd, 0x5e, 0x02); + cp2155_set (fd, 0x5f, 0x00); + cp2155_set (fd, 0x5f, 0x03); + cp2155_set (fd, 0x60, 0x01); + cp2155_set (fd, 0x60, 0x01); + cp2155_set (fd, 0x60, 0x01); + cp2155_set (fd, 0x60, 0x01); + cp2155_set (fd, 0x50, 0x04); + cp2155_set (fd, 0x51, chndl->value_51); + cp2155_set (fd, 0x81, 0x31); + cp2155_set (fd, 0x81, 0x31); + cp2155_set (fd, 0x82, 0x11); + cp2155_set (fd, 0x82, 0x11); + cp2155_set (fd, 0x83, 0x01); + cp2155_set (fd, 0x84, 0x05); + cp2155_set (fd, 0x80, 0x12); + cp2155_set (fd, 0x80, 0x12); + cp2155_set (fd, 0xb0, 0x0b); + + big_write (fd, 0x5694, buf); + + cp2155_set (fd, 0x10, 0x05); + cp2155_set (fd, 0x10, 0x05); + cp2155_set (fd, 0x10, 0x05); + cp2155_set (fd, 0x10, 0x05); + cp2155_set (fd, 0x11, 0xc1); + cp2155_set (fd, 0x11, 0xc1); + cp2155_set (fd, 0x11, 0x81); + cp2155_set (fd, 0x11, 0x81); + cp2155_set (fd, 0x11, 0x81); + cp2155_set (fd, 0x11, 0x81); + cp2155_set (fd, 0x11, 0x81); + cp2155_set (fd, 0x12, 0x7d); + cp2155_set (fd, 0x13, 0x7d); + cp2155_set (fd, 0x16, 0x7d); + cp2155_set (fd, 0x21, 0x06); + cp2155_set (fd, 0x22, 0x7d); + cp2155_set (fd, 0x20, 0x06); + cp2155_set (fd, 0x1d, 0x00); + cp2155_set (fd, 0x1e, 0x00); + cp2155_set (fd, 0x1f, 0x71); + cp2155_set (fd, 0x66, 0x00); + cp2155_set (fd, 0x67, chndl->value_67); + cp2155_set (fd, 0x68, chndl->value_68); + cp2155_set (fd, 0x1a, 0x00); + cp2155_set (fd, 0x1b, 0x00); + cp2155_set (fd, 0x1c, 0x02); + cp2155_set (fd, 0x15, 0x83); + cp2155_set (fd, 0x14, 0x7c); + cp2155_set (fd, 0x17, 0x02); + cp2155_set (fd, 0x43, 0x1c); + cp2155_set (fd, 0x44, 0x9c); + cp2155_set (fd, 0x45, 0x38); + cp2155_set (fd, 0x23, 0x0f); + cp2155_set (fd, 0x33, 0x0f); + cp2155_set (fd, 0x24, 0x0f); + cp2155_set (fd, 0x34, 0x0f); + cp2155_set (fd, 0x25, 0x0f); + cp2155_set (fd, 0x35, 0x0f); + cp2155_set (fd, 0x26, 0x0f); + cp2155_set (fd, 0x36, 0x0f); + cp2155_set (fd, 0x27, 0x0f); + cp2155_set (fd, 0x37, 0x0f); + cp2155_set (fd, 0x28, 0x0f); + cp2155_set (fd, 0x38, 0x0f); + cp2155_set (fd, 0x29, 0x0f); + cp2155_set (fd, 0x39, 0x0f); + cp2155_set (fd, 0x2a, 0x0f); + cp2155_set (fd, 0x3a, 0x0f); + cp2155_set (fd, 0x2b, 0x0f); + cp2155_set (fd, 0x3b, 0x0f); + cp2155_set (fd, 0x2c, 0x0f); + cp2155_set (fd, 0x3c, 0x0f); + cp2155_set (fd, 0x2d, 0x0f); + cp2155_set (fd, 0x3d, 0x0f); + cp2155_set (fd, 0x2e, 0x0f); + cp2155_set (fd, 0x3e, 0x0f); + cp2155_set (fd, 0x2f, 0x0f); + cp2155_set (fd, 0x3f, 0x0f); + cp2155_set (fd, 0x30, 0x0f); + cp2155_set (fd, 0x40, 0x0f); + cp2155_set (fd, 0x31, 0x0f); + cp2155_set (fd, 0x41, 0x0f); + cp2155_set (fd, 0x32, 0x0f); + cp2155_set (fd, 0x42, 0x0f); + cp2155_set (fd, 0xca, 0x00); + cp2155_set (fd, 0xca, 0x00); + cp2155_set (fd, 0xca, 0x00); + cp2155_set (fd, 0x18, 0x00); + + memcpy (buf + 0x00000000, + "\x04\x70\xf4\x01\x80\x25\x80\x25\x80\x25\x80\x25\x80\x25\x80\x25", + 16); + memcpy (buf + 0x00000010, + "\x80\x25\x80\x25\x80\x25\x80\x25\x80\x25\x80\x25\x80\x25\x80\x25", + 16); + memcpy (buf + 0x00000020, + "\x80\x25\x80\x25\x80\x25\x80\x25\x80\x25\x80\x25\x80\x25\x80\x25", + 16); + memcpy (buf + 0x00000030, + "\x80\x25\x80\x25\x80\x25\x80\x25\x80\x25\x80\x25\x80\x25\x80\x25", + 16); + memcpy (buf + 0x00000040, + "\x80\x25\x80\x25\x80\x25\x80\x25\x80\x25\x80\x25\x80\x25\x80\x25", + 16); + memcpy (buf + 0x00000050, + "\x80\x25\x80\x25\x80\x25\x80\x25\x80\x25\x80\x25\x80\x25\x80\x25", + 16); + memcpy (buf + 0x00000060, + "\x80\x25\x80\x25\x80\x25\x80\x25\x80\x25\xe1\x24\x47\x24\xb2\x23", + 16); + memcpy (buf + 0x00000070, + "\x22\x23\x97\x22\x0f\x22\x8c\x21\x0d\x21\x91\x20\x19\x20\xa4\x1f", + 16); + memcpy (buf + 0x00000080, + "\x33\x1f\xc5\x1e\x59\x1e\xf1\x1d\x8b\x1d\x29\x1d\xc8\x1c\x6a\x1c", + 16); + memcpy (buf + 0x00000090, + "\x0f\x1c\xb5\x1b\x5e\x1b\x09\x1b\xb6\x1a\x65\x1a\x16\x1a\xc9\x19", + 16); + memcpy (buf + 0x000000a0, + "\x7d\x19\x34\x19\xec\x18\xa5\x18\x60\x18\x1c\x18\xda\x17\x9a\x17", + 16); + memcpy (buf + 0x000000b0, + "\x5a\x17\x1c\x17\xe0\x16\xa4\x16\x6a\x16\x31\x16\xf9\x15\xc2\x15", + 16); + memcpy (buf + 0x000000c0, + "\x8c\x15\x57\x15\x23\x15\xf1\x14\xbf\x14\x8e\x14\x5e\x14\x2e\x14", + 16); + memcpy (buf + 0x000000d0, + "\x00\x14\xd2\x13\xa6\x13\x7a\x13\x4f\x13\x24\x13\xfa\x12\xd1\x12", + 16); + memcpy (buf + 0x000000e0, + "\xa9\x12\x81\x12\x5a\x12\x34\x12\x0e\x12\xe9\x11\xc5\x11\xa1\x11", + 16); + memcpy (buf + 0x000000f0, + "\x7d\x11\x5a\x11\x38\x11\x16\x11\xf5\x10\xd4\x10\xb4\x10\x94\x10", + 16); + memcpy (buf + 0x00000100, + "\x75\x10\x56\x10\x37\x10\x19\x10\xfc\x0f\xdf\x0f\xc2\x0f\xa6\x0f", + 16); + memcpy (buf + 0x00000110, + "\x8a\x0f\x6e\x0f\x53\x0f\x38\x0f\x1e\x0f\x04\x0f\xea\x0e\xd1\x0e", + 16); + memcpy (buf + 0x00000120, + "\xb8\x0e\x9f\x0e\x86\x0e\x6e\x0e\x57\x0e\x3f\x0e\x28\x0e\x11\x0e", + 16); + memcpy (buf + 0x00000130, + "\xfa\x0d\xe4\x0d\xce\x0d\xb8\x0d\xa3\x0d\x8e\x0d\x79\x0d\x64\x0d", + 16); + memcpy (buf + 0x00000140, + "\x4f\x0d\x3b\x0d\x27\x0d\x14\x0d\x00\x0d\xed\x0c\xda\x0c\xc7\x0c", + 16); + memcpy (buf + 0x00000150, + "\xb4\x0c\xa2\x0c\x8f\x0c\x7d\x0c\x6c\x0c\x5a\x0c\x49\x0c\x37\x0c", + 16); + memcpy (buf + 0x00000160, + "\x26\x0c\x15\x0c\x05\x0c\xf4\x0b\xe4\x0b\xd4\x0b\xc4\x0b\xb4\x0b", + 16); + memcpy (buf + 0x00000170, + "\xa4\x0b\x95\x0b\x85\x0b\x76\x0b\x67\x0b\x58\x0b\x4a\x0b\x3b\x0b", + 16); + memcpy (buf + 0x00000180, + "\x2d\x0b\x1e\x0b\x10\x0b\x02\x0b\xf4\x0a\xe7\x0a\xd9\x0a\xcc\x0a", + 16); + memcpy (buf + 0x00000190, + "\xbe\x0a\xb1\x0a\xa4\x0a\x97\x0a\x8a\x0a\x7e\x0a\x71\x0a\x65\x0a", + 16); + memcpy (buf + 0x000001a0, + "\x58\x0a\x4c\x0a\x40\x0a\x34\x0a\x28\x0a\x1c\x0a\x10\x0a\x05\x0a", + 16); + memcpy (buf + 0x000001b0, + "\xf9\x09\xee\x09\xe3\x09\xd8\x09\xcc\x09\xc1\x09\xb7\x09\xac\x09", + 16); + memcpy (buf + 0x000001c0, + "\xa1\x09\x96\x09\x8c\x09\x82\x09\x77\x09\x6d\x09\x63\x09\x59\x09", + 16); + memcpy (buf + 0x000001d0, + "\x4f\x09\x45\x09\x3b\x09\x31\x09\x28\x09\x1e\x09\x14\x09\x0b\x09", + 16); + memcpy (buf + 0x000001e0, + "\x02\x09\xf8\x08\xef\x08\xe6\x08\xdd\x08\xd4\x08\xcb\x08\xc2\x08", + 16); + memcpy (buf + 0x000001f0, + "\xb9\x08\xb1\x08\xa8\x08\xa0\x08\x00\x00\x00\x00\x00\x00\x00\x00", + 16); + memcpy (buf + 0x00000200, "\x00\x00\x00\x00", 4); + count = 516; + write_buf (fd, count, buf, 0x03, 0x00); + write_buf (fd, count, buf, 0x03, 0x02); + write_buf (fd, count, buf, 0x03, 0x06); + + memcpy (buf + 0x00000000, + "\x04\x70\x18\x00\x80\x25\xc0\x1c\x4f\x17\x9a\x13\xe9\x10\xde\x0e", + 16); + memcpy (buf + 0x00000010, + "\x44\x0d\xfa\x0b\xea\x0a\x07\x0a\x46\x09\xa0\x08\x80\x25\x80\x25", + 16); + memcpy (buf + 0x00000020, "\x80\x25\x80\x25", 4); + count = 36; + write_buf (fd, count, buf, 0x03, 0x04); + write_buf (fd, count, buf, 0x03, 0x08); + + general_motor_600 (fd); + +} + +void +startblob_600_0150 (CANON_Handle * chndl, unsigned char *buf) +{ + + int fd; + fd = chndl->fd; + size_t count; + + cp2155_set (fd, 0x90, 0xe8); + cp2155_set (fd, 0x9b, 0x06); + cp2155_set (fd, 0x9b, 0x04); + cp2155_set (fd, 0x90, 0xf8); + cp2155_set (fd, 0xb0, 0x02); + cp2155_set (fd, 0x07, 0x00); + cp2155_set (fd, 0x07, 0x00); + cp2155_set (fd, 0x08, chndl->value_08); + cp2155_set (fd, 0x09, chndl->value_09); + cp2155_set (fd, 0x0a, chndl->value_0a); + cp2155_set (fd, 0x0b, chndl->value_0b); + cp2155_set (fd, 0xa0, 0x1d); + cp2155_set (fd, 0xa1, 0x00); + cp2155_set (fd, 0xa2, 0x0c); + cp2155_set (fd, 0xa3, 0xd0); + cp2155_set (fd, 0x64, 0x00); + cp2155_set (fd, 0x65, 0x00); + cp2155_set (fd, 0x61, 0x00); + cp2155_set (fd, 0x62, 0x1e); + cp2155_set (fd, 0x63, 0xa0); + cp2155_set (fd, 0x50, 0x04); + cp2155_set (fd, 0x50, 0x04); + cp2155_set (fd, 0x90, 0xf8); + cp2155_set (fd, 0x51, chndl->value_51); + cp2155_set (fd, 0x5a, 0xff); + cp2155_set (fd, 0x5b, 0xff); + cp2155_set (fd, 0x5c, 0xff); + cp2155_set (fd, 0x5d, 0xff); + cp2155_set (fd, 0x52, 0x0c); + cp2155_set (fd, 0x53, 0xda); + cp2155_set (fd, 0x54, 0x0c); + cp2155_set (fd, 0x55, 0x44); + cp2155_set (fd, 0x56, 0x08); + cp2155_set (fd, 0x57, 0xbb); + cp2155_set (fd, 0x58, 0x1d); + cp2155_set (fd, 0x59, 0xa1); + cp2155_set (fd, 0x5e, 0x02); + cp2155_set (fd, 0x5f, 0x00); + cp2155_set (fd, 0x5f, 0x03); + cp2155_set (fd, 0x60, 0x01); + cp2155_set (fd, 0x60, 0x01); + cp2155_set (fd, 0x60, 0x01); + cp2155_set (fd, 0x60, 0x01); + cp2155_set (fd, 0x50, 0x04); + cp2155_set (fd, 0x51, chndl->value_51); + cp2155_set (fd, 0x81, 0x31); + cp2155_set (fd, 0x81, 0x31); + cp2155_set (fd, 0x82, 0x11); + cp2155_set (fd, 0x82, 0x11); + cp2155_set (fd, 0x83, 0x01); + cp2155_set (fd, 0x84, 0x05); + cp2155_set (fd, 0x80, 0x12); + cp2155_set (fd, 0x80, 0x12); + cp2155_set (fd, 0xb0, 0x0a); + + big_write (fd, 0x5694, buf); + + cp2155_set (fd, 0x10, 0x05); + cp2155_set (fd, 0x10, 0x05); + cp2155_set (fd, 0x10, 0x05); + cp2155_set (fd, 0x10, 0x05); + cp2155_set (fd, 0x11, 0x81); + cp2155_set (fd, 0x11, 0x81); + cp2155_set (fd, 0x11, 0x81); + cp2155_set (fd, 0x11, 0x81); + cp2155_set (fd, 0x11, 0x81); + cp2155_set (fd, 0x11, 0x81); + cp2155_set (fd, 0x11, 0x81); + cp2155_set (fd, 0x12, 0x40); + cp2155_set (fd, 0x13, 0x40); + cp2155_set (fd, 0x16, 0x40); + cp2155_set (fd, 0x21, 0x06); + cp2155_set (fd, 0x22, 0x40); + cp2155_set (fd, 0x20, 0x06); + cp2155_set (fd, 0x1d, 0x00); + cp2155_set (fd, 0x1e, 0x00); + cp2155_set (fd, 0x1f, 0x04); + cp2155_set (fd, 0x66, 0x00); + cp2155_set (fd, 0x67, chndl->value_67); + cp2155_set (fd, 0x68, chndl->value_68); + cp2155_set (fd, 0x1a, 0x00); + cp2155_set (fd, 0x1b, 0x00); + cp2155_set (fd, 0x1c, 0x02); + cp2155_set (fd, 0x15, 0x84); + cp2155_set (fd, 0x14, 0x7c); + cp2155_set (fd, 0x17, 0x02); + cp2155_set (fd, 0x43, 0x1c); + cp2155_set (fd, 0x44, 0x9c); + cp2155_set (fd, 0x45, 0x38); + cp2155_set (fd, 0x23, 0x0d); + cp2155_set (fd, 0x33, 0x0d); + cp2155_set (fd, 0x24, 0x0d); + cp2155_set (fd, 0x34, 0x0d); + cp2155_set (fd, 0x25, 0x0d); + cp2155_set (fd, 0x35, 0x0d); + cp2155_set (fd, 0x26, 0x0d); + cp2155_set (fd, 0x36, 0x0d); + cp2155_set (fd, 0x27, 0x0d); + cp2155_set (fd, 0x37, 0x0d); + cp2155_set (fd, 0x28, 0x0d); + cp2155_set (fd, 0x38, 0x0d); + cp2155_set (fd, 0x29, 0x0d); + cp2155_set (fd, 0x39, 0x0d); + cp2155_set (fd, 0x2a, 0x0d); + cp2155_set (fd, 0x3a, 0x0d); + cp2155_set (fd, 0x2b, 0x0d); + cp2155_set (fd, 0x3b, 0x0d); + cp2155_set (fd, 0x2c, 0x0d); + cp2155_set (fd, 0x3c, 0x0d); + cp2155_set (fd, 0x2d, 0x0d); + cp2155_set (fd, 0x3d, 0x0d); + cp2155_set (fd, 0x2e, 0x0d); + cp2155_set (fd, 0x3e, 0x0d); + cp2155_set (fd, 0x2f, 0x0d); + cp2155_set (fd, 0x3f, 0x0d); + cp2155_set (fd, 0x30, 0x0d); + cp2155_set (fd, 0x40, 0x0d); + cp2155_set (fd, 0x31, 0x0d); + cp2155_set (fd, 0x41, 0x0d); + cp2155_set (fd, 0x32, 0x0d); + cp2155_set (fd, 0x42, 0x0d); + cp2155_set (fd, 0xca, 0x00); + cp2155_set (fd, 0xca, 0x00); + cp2155_set (fd, 0xca, 0x00); + cp2155_set (fd, 0x18, 0x00); + + memcpy (buf + 0x00000000, + "\x04\x70\x00\x01\x80\x25\x80\x25\x80\x25\x80\x25\x80\x25\x80\x25", + 16); + memcpy (buf + 0x00000010, + "\x80\x25\x80\x25\x80\x25\x80\x25\x80\x25\x80\x25\x80\x25\x80\x25", + 16); + memcpy (buf + 0x00000020, + "\x80\x25\x80\x25\x80\x25\x80\x25\x80\x25\x80\x25\x80\x25\x80\x25", + 16); + memcpy (buf + 0x00000030, + "\x80\x25\x80\x25\x80\x25\x80\x25\x80\x25\x80\x25\x80\x25\x80\x25", + 16); + memcpy (buf + 0x00000040, + "\x80\x25\x80\x25\x80\x25\x80\x25\x80\x25\x80\x25\x80\x25\x80\x25", + 16); + memcpy (buf + 0x00000050, + "\x80\x25\x80\x25\x80\x25\x80\x25\x80\x25\x80\x25\x80\x25\x80\x25", + 16); + memcpy (buf + 0x00000060, + "\x80\x25\x80\x25\x80\x25\x80\x25\x80\x25\x80\x25\x80\x25\x80\x25", + 16); + memcpy (buf + 0x00000070, + "\x80\x25\x80\x25\x80\x25\x80\x25\x80\x25\x80\x25\x80\x25\x80\x25", + 16); + memcpy (buf + 0x00000080, + "\x80\x25\x80\x25\x80\x25\x32\x24\xfb\x22\xd9\x21\xc8\x20\xc9\x1f", + 16); + memcpy (buf + 0x00000090, + "\xd8\x1e\xf5\x1d\x1f\x1d\x54\x1c\x95\x1b\xdf\x1a\x32\x1a\x8d\x19", + 16); + memcpy (buf + 0x000000a0, + "\xf1\x18\x5c\x18\xce\x17\x46\x17\xc3\x16\x47\x16\xd0\x15\x5d\x15", + 16); + memcpy (buf + 0x000000b0, + "\xef\x14\x86\x14\x21\x14\xbf\x13\x61\x13\x07\x13\xaf\x12\x5b\x12", + 16); + memcpy (buf + 0x000000c0, + "\x0a\x12\xbb\x11\x6f\x11\x26\x11\xdf\x10\x9a\x10\x57\x10\x17\x10", + 16); + memcpy (buf + 0x000000d0, + "\xd8\x0f\x9c\x0f\x61\x0f\x27\x0f\xf0\x0e\xba\x0e\x85\x0e\x52\x0e", + 16); + memcpy (buf + 0x000000e0, + "\x21\x0e\xf0\x0d\xc1\x0d\x93\x0d\x67\x0d\x3b\x0d\x11\x0d\xe7\x0c", + 16); + memcpy (buf + 0x000000f0, + "\xbf\x0c\x98\x0c\x71\x0c\x4b\x0c\x27\x0c\x03\x0c\xe0\x0b\xbe\x0b", + 16); + memcpy (buf + 0x00000100, "\x9c\x0b\x7c\x0b", 4); + count = 260; + write_buf (fd, count, buf, 0x03, 0x00); + write_buf (fd, count, buf, 0x03, 0x02); + write_buf (fd, count, buf, 0x03, 0x06); + + memcpy (buf + 0x00000000, + "\x04\x70\x18\x00\x80\x25\x18\x1f\x8f\x1a\x2d\x17\x8f\x14\x79\x12", + 16); + memcpy (buf + 0x00000010, + "\xc6\x10\x5b\x0f\x2a\x0e\x24\x0d\x41\x0c\x7c\x0b\x80\x25\x80\x25", + 16); + memcpy (buf + 0x00000020, "\x80\x25\x80\x25", 4); + count = 36; + write_buf (fd, count, buf, 0x03, 0x04); + write_buf (fd, count, buf, 0x03, 0x08); + + general_motor_600 (fd); + +} + +void +startblob_600_0300 (CANON_Handle * chndl, unsigned char *buf) +{ + + int fd; + fd = chndl->fd; + size_t count; + + cp2155_set (fd, 0x90, 0xe8); + cp2155_set (fd, 0x9b, 0x06); + cp2155_set (fd, 0x9b, 0x04); + cp2155_set (fd, 0x90, 0xf8); + cp2155_set (fd, 0xb0, 0x01); + cp2155_set (fd, 0x07, 0x00); + cp2155_set (fd, 0x07, 0x00); + cp2155_set (fd, 0x08, chndl->value_08); + cp2155_set (fd, 0x09, chndl->value_09); + cp2155_set (fd, 0x0a, chndl->value_0a); + cp2155_set (fd, 0x0b, chndl->value_0b); + cp2155_set (fd, 0xa0, 0x1d); + cp2155_set (fd, 0xa1, 0x00); + cp2155_set (fd, 0xa2, 0x03); + cp2155_set (fd, 0xa3, 0x10); + cp2155_set (fd, 0x64, 0x00); + cp2155_set (fd, 0x65, 0x00); + cp2155_set (fd, 0x61, 0x00); + cp2155_set (fd, 0x62, 0x15); + cp2155_set (fd, 0x63, 0xe0); + cp2155_set (fd, 0x50, 0x04); + cp2155_set (fd, 0x50, 0x04); + cp2155_set (fd, 0x90, 0xf8); + cp2155_set (fd, 0x51, chndl->value_51); + cp2155_set (fd, 0x5a, 0xff); + cp2155_set (fd, 0x5b, 0xff); + cp2155_set (fd, 0x5c, 0xff); + cp2155_set (fd, 0x5d, 0xff); + cp2155_set (fd, 0x52, 0x0a); + cp2155_set (fd, 0x53, 0xf0); + cp2155_set (fd, 0x54, 0x0a); + cp2155_set (fd, 0x55, 0xf0); + cp2155_set (fd, 0x56, 0x0a); + cp2155_set (fd, 0x57, 0xf0); + cp2155_set (fd, 0x58, 0x00); + cp2155_set (fd, 0x59, 0x01); + cp2155_set (fd, 0x5e, 0x02); + cp2155_set (fd, 0x5f, 0x00); + cp2155_set (fd, 0x5f, 0x03); + cp2155_set (fd, 0x60, 0x01); + cp2155_set (fd, 0x60, 0x01); + cp2155_set (fd, 0x60, 0x01); + cp2155_set (fd, 0x60, 0x01); + cp2155_set (fd, 0x50, 0x04); + cp2155_set (fd, 0x51, chndl->value_51); + cp2155_set (fd, 0x81, 0x31); + cp2155_set (fd, 0x81, 0x31); + cp2155_set (fd, 0x82, 0x11); + cp2155_set (fd, 0x82, 0x11); + cp2155_set (fd, 0x83, 0x01); + cp2155_set (fd, 0x84, 0x05); + cp2155_set (fd, 0x80, 0x12); + cp2155_set (fd, 0x80, 0x12); + cp2155_set (fd, 0xb0, 0x01); + cp2155_set (fd, 0x10, 0x05); + cp2155_set (fd, 0x10, 0x05); + cp2155_set (fd, 0x10, 0x05); + cp2155_set (fd, 0x10, 0x05); + cp2155_set (fd, 0x11, 0x83); + cp2155_set (fd, 0x11, 0x83); + cp2155_set (fd, 0x11, 0xc3); + cp2155_set (fd, 0x11, 0xc3); + cp2155_set (fd, 0x11, 0xc3); + cp2155_set (fd, 0x11, 0xc1); + cp2155_set (fd, 0x11, 0xc1); + cp2155_set (fd, 0x12, 0x40); + cp2155_set (fd, 0x13, 0x00); + cp2155_set (fd, 0x16, 0x40); + cp2155_set (fd, 0x21, 0x06); + cp2155_set (fd, 0x22, 0x40); + cp2155_set (fd, 0x20, 0x06); + cp2155_set (fd, 0x1d, 0x00); + cp2155_set (fd, 0x1e, 0x00); + cp2155_set (fd, 0x1f, 0x04); + cp2155_set (fd, 0x66, 0x00); + cp2155_set (fd, 0x67, chndl->value_67); + cp2155_set (fd, 0x68, chndl->value_68); + cp2155_set (fd, 0x1a, 0x00); + cp2155_set (fd, 0x1b, 0x00); + cp2155_set (fd, 0x1c, 0x02); + cp2155_set (fd, 0x15, 0x01); + cp2155_set (fd, 0x14, 0x01); + cp2155_set (fd, 0x17, 0x01); + cp2155_set (fd, 0x43, 0x1c); + cp2155_set (fd, 0x44, 0x9c); + cp2155_set (fd, 0x45, 0x38); + cp2155_set (fd, 0x23, 0x0a); + cp2155_set (fd, 0x33, 0x0a); + cp2155_set (fd, 0x24, 0x0a); + cp2155_set (fd, 0x34, 0x0a); + cp2155_set (fd, 0x25, 0x0a); + cp2155_set (fd, 0x35, 0x0a); + cp2155_set (fd, 0x26, 0x0a); + cp2155_set (fd, 0x36, 0x0a); + cp2155_set (fd, 0x27, 0x0a); + cp2155_set (fd, 0x37, 0x0a); + cp2155_set (fd, 0x28, 0x0a); + cp2155_set (fd, 0x38, 0x0a); + cp2155_set (fd, 0x29, 0x0a); + cp2155_set (fd, 0x39, 0x0a); + cp2155_set (fd, 0x2a, 0x0a); + cp2155_set (fd, 0x3a, 0x0a); + cp2155_set (fd, 0x2b, 0x0a); + cp2155_set (fd, 0x3b, 0x0a); + cp2155_set (fd, 0x2c, 0x0a); + cp2155_set (fd, 0x3c, 0x0a); + cp2155_set (fd, 0x2d, 0x0a); + cp2155_set (fd, 0x3d, 0x0a); + cp2155_set (fd, 0x2e, 0x0a); + cp2155_set (fd, 0x3e, 0x0a); + cp2155_set (fd, 0x2f, 0x0a); + cp2155_set (fd, 0x3f, 0x0a); + cp2155_set (fd, 0x30, 0x0a); + cp2155_set (fd, 0x40, 0x0a); + cp2155_set (fd, 0x31, 0x0a); + cp2155_set (fd, 0x41, 0x0a); + cp2155_set (fd, 0x32, 0x0a); + cp2155_set (fd, 0x42, 0x0a); + cp2155_set (fd, 0xca, 0x00); + cp2155_set (fd, 0xca, 0x00); + cp2155_set (fd, 0xca, 0x00); + cp2155_set (fd, 0x18, 0x00); + + memcpy (buf + 0x0000, + "\x04\x70\x00\x01\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32", + 16); + memcpy (buf + 0x0010, + "\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32", + 16); + memcpy (buf + 0x0020, + "\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32", + 16); + memcpy (buf + 0x0030, + "\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32", + 16); + memcpy (buf + 0x0040, + "\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32", + 16); + memcpy (buf + 0x0050, + "\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32", + 16); + memcpy (buf + 0x0060, + "\x00\x32\x00\x32\x00\x32\xbc\x30\x89\x2f\x64\x2e\x4d\x2d\x43\x2c", + 16); + memcpy (buf + 0x0070, + "\x45\x2b\x52\x2a\x69\x29\x8a\x28\xb5\x27\xe8\x26\x23\x26\x66\x25", + 16); + memcpy (buf + 0x0080, + "\xaf\x24\x00\x24\x57\x23\xb5\x22\x17\x22\x80\x21\xee\x20\x60\x20", + 16); + memcpy (buf + 0x0090, + "\xd7\x1f\x53\x1f\xd3\x1e\x57\x1e\xde\x1d\x6a\x1d\xf9\x1c\x8b\x1c", + 16); + memcpy (buf + 0x00a0, + "\x20\x1c\xb9\x1b\x54\x1b\xf3\x1a\x93\x1a\x37\x1a\xdd\x19\x85\x19", + 16); + memcpy (buf + 0x00b0, + "\x30\x19\xdd\x18\x8c\x18\x3d\x18\xf0\x17\xa5\x17\x5c\x17\x14\x17", + 16); + memcpy (buf + 0x00c0, + "\xce\x16\x8a\x16\x47\x16\x06\x16\xc7\x15\x88\x15\x4b\x15\x10\x15", + 16); + memcpy (buf + 0x00d0, + "\xd6\x14\x9d\x14\x65\x14\x2e\x14\xf9\x13\xc4\x13\x91\x13\x5f\x13", + 16); + memcpy (buf + 0x00e0, + "\x2d\x13\xfd\x12\xce\x12\x9f\x12\x72\x12\x45\x12\x19\x12\xee\x11", + 16); + memcpy (buf + 0x00f0, + "\xc4\x11\x9a\x11\x71\x11\x49\x11\x22\x11\xfb\x10\xd5\x10\xb0\x10", + 16); + memcpy (buf + 0x0100, "\x8c\x10\x68\x10", 4); + count = 260; + write_buf (fd, count, buf, 0x03, 0x00); + write_buf (fd, count, buf, 0x03, 0x02); + write_buf (fd, count, buf, 0x03, 0x06); + + memcpy (buf + 0x0000, + "\x04\x70\x20\x00\x00\x32\x27\x2a\x6f\x24\x15\x20\xa8\x1c\xe5\x19", + 16); + memcpy (buf + 0x0010, + "\x9e\x17\xb5\x15\x16\x14\xb0\x12\x79\x11\x68\x10\x00\x00\x00\x00", + 16); + memcpy (buf + 0x0020, "\x00\x00\x00\x00", 4); + count = 36; + write_buf (fd, count, buf, 0x03, 0x04); + write_buf (fd, count, buf, 0x03, 0x08); + + general_motor_600 (fd); + +} + +void +startblob_600_0600 (CANON_Handle * chndl, unsigned char *buf) +{ + + int fd; + fd = chndl->fd; + size_t count; + + cp2155_set (fd, 0x90, 0xe8); + cp2155_set (fd, 0x9b, 0x06); + cp2155_set (fd, 0x9b, 0x04); + cp2155_set (fd, 0x90, 0xf8); + cp2155_set (fd, 0xb0, 0x00); + cp2155_set (fd, 0x07, 0x00); + cp2155_set (fd, 0x07, 0x00); + cp2155_set (fd, 0x08, chndl->value_08); + cp2155_set (fd, 0x09, chndl->value_09); + cp2155_set (fd, 0x0a, chndl->value_0a); + cp2155_set (fd, 0x0b, chndl->value_0b); + cp2155_set (fd, 0xa0, 0x1d); + cp2155_set (fd, 0xa1, 0x00); + cp2155_set (fd, 0xa2, 0x31); + cp2155_set (fd, 0xa3, 0xf0); + cp2155_set (fd, 0x64, 0x00); + cp2155_set (fd, 0x65, 0x00); + cp2155_set (fd, 0x61, 0x00); + cp2155_set (fd, 0x62, 0x55); + cp2155_set (fd, 0x63, 0x00); + cp2155_set (fd, 0x50, 0x04); + cp2155_set (fd, 0x50, 0x04); + cp2155_set (fd, 0x90, 0xf8); + cp2155_set (fd, 0x51, chndl->value_51); + cp2155_set (fd, 0x5a, 0xff); + cp2155_set (fd, 0x5b, 0xff); + cp2155_set (fd, 0x5c, 0xff); + cp2155_set (fd, 0x5d, 0xff); + cp2155_set (fd, 0x52, 0x0c); + cp2155_set (fd, 0x53, 0xda); + cp2155_set (fd, 0x54, 0x0c); + cp2155_set (fd, 0x55, 0x44); + cp2155_set (fd, 0x56, 0x08); + cp2155_set (fd, 0x57, 0xbb); + cp2155_set (fd, 0x58, 0x1d); + cp2155_set (fd, 0x59, 0xa1); + cp2155_set (fd, 0x5e, 0x02); + cp2155_set (fd, 0x5f, 0x00); + cp2155_set (fd, 0x5f, 0x03); + cp2155_set (fd, 0x60, 0x01); + cp2155_set (fd, 0x60, 0x01); + cp2155_set (fd, 0x60, 0x01); + cp2155_set (fd, 0x60, 0x01); + cp2155_set (fd, 0x50, 0x04); + cp2155_set (fd, 0x51, chndl->value_51); + cp2155_set (fd, 0x81, 0x31); + cp2155_set (fd, 0x81, 0x31); + cp2155_set (fd, 0x82, 0x11); + cp2155_set (fd, 0x82, 0x11); + cp2155_set (fd, 0x83, 0x01); + cp2155_set (fd, 0x84, 0x05); + cp2155_set (fd, 0x80, 0x12); + cp2155_set (fd, 0x80, 0x12); + cp2155_set (fd, 0xb0, 0x08); + + big_write (fd, 0x5694, buf); + + cp2155_set (fd, 0x10, 0x05); + cp2155_set (fd, 0x10, 0x05); + cp2155_set (fd, 0x10, 0x05); + cp2155_set (fd, 0x10, 0x05); + cp2155_set (fd, 0x11, 0x81); + cp2155_set (fd, 0x11, 0x81); + cp2155_set (fd, 0x11, 0x81); + cp2155_set (fd, 0x11, 0x81); + cp2155_set (fd, 0x11, 0x81); + cp2155_set (fd, 0x11, 0x81); + cp2155_set (fd, 0x11, 0x81); + cp2155_set (fd, 0x12, 0x06); + cp2155_set (fd, 0x13, 0x06); + cp2155_set (fd, 0x16, 0x06); + cp2155_set (fd, 0x21, 0x06); + cp2155_set (fd, 0x22, 0x06); + cp2155_set (fd, 0x20, 0x06); + cp2155_set (fd, 0x1d, 0x00); + cp2155_set (fd, 0x1e, 0x00); + cp2155_set (fd, 0x1f, 0x04); + cp2155_set (fd, 0x66, 0x00); + cp2155_set (fd, 0x67, chndl->value_67); + cp2155_set (fd, 0x68, chndl->value_68); + cp2155_set (fd, 0x1a, 0x00); + cp2155_set (fd, 0x1b, 0x00); + cp2155_set (fd, 0x1c, 0x02); + cp2155_set (fd, 0x15, 0x80); + cp2155_set (fd, 0x14, 0x7a); + cp2155_set (fd, 0x17, 0x02); + cp2155_set (fd, 0x43, 0x1c); + cp2155_set (fd, 0x44, 0x9c); + cp2155_set (fd, 0x45, 0x38); + cp2155_set (fd, 0x23, 0x0c); + cp2155_set (fd, 0x33, 0x0c); + cp2155_set (fd, 0x24, 0x0c); + cp2155_set (fd, 0x34, 0x0c); + cp2155_set (fd, 0x25, 0x0c); + cp2155_set (fd, 0x35, 0x0c); + cp2155_set (fd, 0x26, 0x0c); + cp2155_set (fd, 0x36, 0x0c); + cp2155_set (fd, 0x27, 0x0c); + cp2155_set (fd, 0x37, 0x0c); + cp2155_set (fd, 0x28, 0x0c); + cp2155_set (fd, 0x38, 0x0c); + cp2155_set (fd, 0x29, 0x0c); + cp2155_set (fd, 0x39, 0x0c); + cp2155_set (fd, 0x2a, 0x0c); + cp2155_set (fd, 0x3a, 0x0c); + cp2155_set (fd, 0x2b, 0x0c); + cp2155_set (fd, 0x3b, 0x0c); + cp2155_set (fd, 0x2c, 0x0c); + cp2155_set (fd, 0x3c, 0x0c); + cp2155_set (fd, 0x2d, 0x0c); + cp2155_set (fd, 0x3d, 0x0c); + cp2155_set (fd, 0x2e, 0x0c); + cp2155_set (fd, 0x3e, 0x0c); + cp2155_set (fd, 0x2f, 0x0c); + cp2155_set (fd, 0x3f, 0x0c); + cp2155_set (fd, 0x30, 0x0c); + cp2155_set (fd, 0x40, 0x0c); + cp2155_set (fd, 0x31, 0x0c); + cp2155_set (fd, 0x41, 0x0c); + cp2155_set (fd, 0x32, 0x0c); + cp2155_set (fd, 0x42, 0x0c); + cp2155_set (fd, 0xca, 0x00); + cp2155_set (fd, 0xca, 0x00); + cp2155_set (fd, 0xca, 0x00); + cp2155_set (fd, 0x18, 0x00); + memcpy (buf + 0x00000000, + "\x04\x70\x18\x00\x80\x7f\x80\x7f\x80\x7f\x80\x7f\x80\x7f\x80\x7f", + 16); + memcpy (buf + 0x00000010, + "\x80\x7f\x80\x7f\x80\x7f\x80\x7f\x80\x7f\x80\x7f\x00\x00\x00\x00", + 16); + memcpy (buf + 0x00000020, "\x00\x00\x00\x00", 4); + count = 36; + write_buf (fd, count, buf, 0x03, 0x00); + write_buf (fd, count, buf, 0x03, 0x02); + write_buf (fd, count, buf, 0x03, 0x06); + write_buf (fd, count, buf, 0x03, 0x04); + write_buf (fd, count, buf, 0x03, 0x08); + + general_motor_600 (fd); + +} + +void +startblob_600_1200 (CANON_Handle * chndl, unsigned char *buf) +{ + + int fd; + fd = chndl->fd; + size_t count; + + cp2155_set (fd, 0x90, 0xe8); + cp2155_set (fd, 0x9b, 0x06); + cp2155_set (fd, 0x9b, 0x04); + cp2155_set (fd, 0x9b, 0x06); + cp2155_set (fd, 0x9b, 0x04); + cp2155_set (fd, 0x90, 0xf8); + cp2155_set (fd, 0xb0, 0x00); + cp2155_set (fd, 0x07, 0x00); + cp2155_set (fd, 0x07, 0x00); + cp2155_set (fd, 0x08, chndl->value_08); + cp2155_set (fd, 0x09, chndl->value_09); + cp2155_set (fd, 0x0a, chndl->value_0a); + cp2155_set (fd, 0x0b, chndl->value_0b); + cp2155_set (fd, 0xa0, 0x1d); + cp2155_set (fd, 0xa1, 0x00); + cp2155_set (fd, 0xa2, 0x63); + cp2155_set (fd, 0xa3, 0xd0); + cp2155_set (fd, 0x64, 0x00); + cp2155_set (fd, 0x65, 0x00); + cp2155_set (fd, 0x61, 0x00); + cp2155_set (fd, 0x62, 0xaa); + cp2155_set (fd, 0x63, 0x00); + cp2155_set (fd, 0x50, 0x04); + cp2155_set (fd, 0x50, 0x04); + cp2155_set (fd, 0x90, 0xf8); + cp2155_set (fd, 0x51, chndl->value_51); + cp2155_set (fd, 0x5a, 0xff); + cp2155_set (fd, 0x5b, 0xff); + cp2155_set (fd, 0x5c, 0xff); + cp2155_set (fd, 0x5d, 0xff); + cp2155_set (fd, 0x52, 0x19); + cp2155_set (fd, 0x53, 0x5a); + cp2155_set (fd, 0x54, 0x17); + cp2155_set (fd, 0x55, 0x98); + cp2155_set (fd, 0x56, 0x11); + cp2155_set (fd, 0x57, 0xae); + cp2155_set (fd, 0x58, 0xa9); + cp2155_set (fd, 0x59, 0x01); + cp2155_set (fd, 0x5e, 0x02); + cp2155_set (fd, 0x5f, 0x00); + cp2155_set (fd, 0x5f, 0x03); + cp2155_set (fd, 0x60, 0x01); + cp2155_set (fd, 0x60, 0x01); + cp2155_set (fd, 0x60, 0x01); + cp2155_set (fd, 0x60, 0x01); + cp2155_set (fd, 0x50, 0x04); + cp2155_set (fd, 0x51, chndl->value_51); + cp2155_set (fd, 0x81, 0x31); + cp2155_set (fd, 0x81, 0x31); + cp2155_set (fd, 0x82, 0x11); + cp2155_set (fd, 0x82, 0x11); + cp2155_set (fd, 0x83, 0x01); + cp2155_set (fd, 0x84, 0x05); + cp2155_set (fd, 0x80, 0x12); + cp2155_set (fd, 0x80, 0x12); + cp2155_set (fd, 0xb0, 0x08); + + big_write (fd, 0xa714, buf); + + cp2155_set (fd, 0x10, 0x05); + cp2155_set (fd, 0x10, 0x05); + cp2155_set (fd, 0x10, 0x05); + cp2155_set (fd, 0x10, 0x05); + cp2155_set (fd, 0x11, 0x83); + cp2155_set (fd, 0x11, 0x83); + cp2155_set (fd, 0x11, 0x83); + cp2155_set (fd, 0x11, 0x83); + cp2155_set (fd, 0x11, 0x83); + cp2155_set (fd, 0x11, 0x81); + cp2155_set (fd, 0x11, 0x81); + cp2155_set (fd, 0x12, 0x50); + cp2155_set (fd, 0x13, 0x50); + cp2155_set (fd, 0x16, 0x50); + cp2155_set (fd, 0x21, 0x06); + cp2155_set (fd, 0x22, 0x50); + cp2155_set (fd, 0x20, 0x06); + cp2155_set (fd, 0x1d, 0x00); + cp2155_set (fd, 0x1e, 0x00); + cp2155_set (fd, 0x1f, 0x04); + cp2155_set (fd, 0x66, 0x00); + cp2155_set (fd, 0x67, chndl->value_67); + cp2155_set (fd, 0x68, chndl->value_68); + cp2155_set (fd, 0x1a, 0x00); + cp2155_set (fd, 0x1b, 0x00); + cp2155_set (fd, 0x1c, 0x02); + cp2155_set (fd, 0x15, 0x80); + cp2155_set (fd, 0x14, 0x7a); + cp2155_set (fd, 0x17, 0x02); + cp2155_set (fd, 0x43, 0x1c); + cp2155_set (fd, 0x44, 0x9c); + cp2155_set (fd, 0x45, 0x38); + cp2155_set (fd, 0x23, 0x01); + cp2155_set (fd, 0x33, 0x01); + cp2155_set (fd, 0x24, 0x03); + cp2155_set (fd, 0x34, 0x03); + cp2155_set (fd, 0x25, 0x05); + cp2155_set (fd, 0x35, 0x05); + cp2155_set (fd, 0x26, 0x07); + cp2155_set (fd, 0x36, 0x07); + cp2155_set (fd, 0x27, 0x09); + cp2155_set (fd, 0x37, 0x09); + cp2155_set (fd, 0x28, 0x0a); + cp2155_set (fd, 0x38, 0x0a); + cp2155_set (fd, 0x29, 0x0b); + cp2155_set (fd, 0x39, 0x0b); + cp2155_set (fd, 0x2a, 0x0c); + cp2155_set (fd, 0x3a, 0x0c); + cp2155_set (fd, 0x2b, 0x0c); + cp2155_set (fd, 0x3b, 0x0c); + cp2155_set (fd, 0x2c, 0x0b); + cp2155_set (fd, 0x3c, 0x0b); + cp2155_set (fd, 0x2d, 0x0a); + cp2155_set (fd, 0x3d, 0x0a); + cp2155_set (fd, 0x2e, 0x09); + cp2155_set (fd, 0x3e, 0x09); + cp2155_set (fd, 0x2f, 0x07); + cp2155_set (fd, 0x3f, 0x07); + cp2155_set (fd, 0x30, 0x05); + cp2155_set (fd, 0x40, 0x05); + cp2155_set (fd, 0x31, 0x03); + cp2155_set (fd, 0x41, 0x03); + cp2155_set (fd, 0x32, 0x01); + cp2155_set (fd, 0x42, 0x01); + cp2155_set (fd, 0xca, 0x00); + cp2155_set (fd, 0xca, 0x00); + cp2155_set (fd, 0xca, 0x00); + cp2155_set (fd, 0x18, 0x00); + + memcpy (buf + 0x00000000, + "\x04\x70\x40\x01\x80\x7f\x80\x7f\x80\x7f\x80\x7f\x80\x7f\x80\x7f", + 16); + memcpy (buf + 0x00000010, + "\x80\x7f\x80\x7f\x80\x7f\x80\x7f\x80\x7f\x80\x7f\x80\x7f\x80\x7f", + 16); + memcpy (buf + 0x00000020, + "\x80\x7f\x80\x7f\x80\x7f\x80\x7f\x80\x7f\x80\x7f\x80\x7f\x80\x7f", + 16); + memcpy (buf + 0x00000030, + "\x80\x7f\x80\x7f\x80\x7f\x80\x7f\x80\x7f\x80\x7f\x80\x7f\x80\x7f", + 16); + memcpy (buf + 0x00000040, + "\x80\x7f\x80\x7f\x80\x7f\x80\x7f\x80\x7f\x80\x7f\x80\x7f\x80\x7f", + 16); + memcpy (buf + 0x00000050, + "\x80\x7f\x80\x7f\x80\x7f\x80\x7f\x80\x7f\x80\x7f\x80\x7f\x80\x7f", + 16); + memcpy (buf + 0x00000060, + "\x80\x7f\x80\x7f\x80\x7f\x80\x7f\x80\x7f\x80\x7f\x80\x7f\x80\x7f", + 16); + memcpy (buf + 0x00000070, + "\x80\x7f\x80\x7f\x80\x7f\x80\x7f\x80\x7f\x80\x7f\x80\x7f\x80\x7f", + 16); + memcpy (buf + 0x00000080, + "\x80\x7f\x80\x7f\x80\x7f\x80\x7f\x80\x7f\x80\x7f\x80\x7f\x80\x7f", + 16); + memcpy (buf + 0x00000090, + "\x80\x7f\x80\x7f\x80\x7f\x80\x7f\x80\x7f\x80\x7f\x80\x7f\x80\x7f", + 16); + memcpy (buf + 0x000000a0, + "\x80\x7f\x80\x7f\x80\x7f\x80\x7f\x80\x7f\x80\x7f\x80\x7f\x80\x7f", + 16); + memcpy (buf + 0x000000b0, + "\x80\x7f\x80\x7f\x80\x7f\x80\x7f\x80\x7f\x80\x7f\x80\x7f\x80\x7f", + 16); + memcpy (buf + 0x000000c0, + "\x80\x7f\x80\x7f\x80\x7f\x80\x7f\x80\x7f\x80\x7f\x80\x7f\x80\x7f", + 16); + memcpy (buf + 0x000000d0, + "\x80\x7f\x80\x7f\x80\x7f\x80\x7f\x80\x7f\x80\x7f\x80\x7f\x80\x7f", + 16); + memcpy (buf + 0x000000e0, + "\x80\x7f\x80\x7f\x80\x7f\x80\x7f\x80\x7f\x80\x7f\x80\x7f\x80\x7f", + 16); + memcpy (buf + 0x000000f0, + "\x80\x7f\x80\x7f\x80\x7f\x80\x7f\x80\x7f\x80\x7f\x80\x7f\x80\x7f", + 16); + memcpy (buf + 0x00000100, + "\x80\x7f\x80\x7f\x80\x7f\x80\x7f\x80\x7f\x80\x7f\x80\x7f\x80\x7f", + 16); + memcpy (buf + 0x00000110, + "\x80\x7f\x80\x7f\x80\x7f\x80\x7f\x80\x7f\x80\x7f\x80\x7f\x80\x7f", + 16); + memcpy (buf + 0x00000120, + "\x80\x7f\x80\x7f\x80\x7f\x80\x7f\x80\x7f\x80\x7f\x80\x7f\x80\x7f", + 16); + memcpy (buf + 0x00000130, + "\x80\x7f\x80\x7f\x80\x7f\x80\x7f\x80\x7f\x80\x7f\x80\x7f\x80\x7f", + 16); + memcpy (buf + 0x00000140, "\x80\x7f\x80\x7f", 4); + count = 324; + + write_buf (fd, count, buf, 0x03, 0x00); + write_buf (fd, count, buf, 0x03, 0x02); + write_buf (fd, count, buf, 0x03, 0x06); + + memcpy (buf + 0x00000000, + "\x04\x70\x18\x00\x80\x7f\x80\x7f\x80\x7f\x80\x7f\x80\x7f\x80\x7f", + 16); + memcpy (buf + 0x00000010, + "\x80\x7f\x80\x7f\x80\x7f\x80\x7f\x80\x7f\x80\x7f\x80\x7f\x80\x7f", + 16); + memcpy (buf + 0x00000020, "\x80\x7f\x80\x7f", 4); + count = 36; + + write_buf (fd, count, buf, 0x03, 0x04); + write_buf (fd, count, buf, 0x03, 0x08); + + general_motor_600 (fd); + +} + void send_start_blob (CANON_Handle * chndl) { @@ -1554,7 +2608,7 @@ send_start_blob (CANON_Handle * chndl) } cp2155_block6 (fd, 0x12, 0x83); - cp2155_set (fd, 0x90, 0xf8); +/* cp2155_set (fd, 0x90, 0xf8); */ cp2155_block6 (fd, 0x12, 0x83); /* start preparing real scan */ cp2155_set (fd, 0x01, 0x29); @@ -1565,20 +2619,60 @@ send_start_blob (CANON_Handle * chndl) switch (chndl->val[opt_resolution].w) { case 75: - startblob0075 (chndl, buf); + if (chndl->productcode == 0x2225) + { + startblob0075 (chndl, buf); + } + else + { + startblob_600_0075 (chndl, buf); + } break; case 150: - startblob0150 (chndl, buf); + if (chndl->productcode == 0x2225) + { + startblob0150 (chndl, buf); + } + else + { + startblob_600_0150 (chndl, buf); + } break; case 300: - startblob0300 (chndl, buf); + if (chndl->productcode == 0x2225) + { + startblob0300 (chndl, buf); + } + else + { + cp2155_set_gamma600 (fd); + startblob_600_0300 (chndl, buf); + } break; case 600: - cp2155_set_gamma600 (fd); - startblob0600 (chndl, buf); + if (chndl->productcode == 0x2225) + { + cp2155_set_gamma600 (fd); + startblob0600 (chndl, buf); +/* + startblob0600_extra (chndl, buf); +*/ + } + else + { + startblob_600_0600 (chndl, buf); + } break; case 1200: - startblob1200 (chndl, buf); + if (chndl->productcode == 0x2225) + { + startblob1200 (chndl, buf); + } + else + { + startblob_600_1200 (chndl, buf); + } + break; } } @@ -1645,49 +2739,806 @@ wait_for_data (CANON_Handle * chndl) } } -static void -go_home_without_wait (int fd) +static int +init (CANON_Handle * chndl) { + int fd = chndl->fd; + byte value; + int result = 0; + + cp2155_get (fd, 0xd0, &value); + /* Detect if scanner is plugged in */ + if (value != 0x81 && value != 0x40) + { + DBG (1, "INIT: unexpected value: %x\n", value); + } + + if (value == 0x00) + { + return -1; + } + + cp2155_set (fd, 0x02, 0x01); + cp2155_set (fd, 0x02, 0x00); + cp2155_set (fd, 0x01, 0x00); + cp2155_set (fd, 0x01, 0x28); + cp2155_set (fd, 0xa0, 0x04); + cp2155_set (fd, 0xa0, 0x05); + cp2155_set (fd, 0x01, 0x28); + cp2155_set (fd, 0x04, 0x0c); + cp2155_set (fd, 0x05, 0x00); + cp2155_set (fd, 0x06, 0x00); + cp2155_set (fd, 0x90, 0x27); + cp2155_set (fd, 0x92, 0xf7); + cp2155_set (fd, 0x94, 0xf7); + cp2155_set (fd, 0x93, 0x00); + cp2155_set (fd, 0x91, 0x1f); + cp2155_set (fd, 0x95, 0x0f); + cp2155_set (fd, 0x97, 0x0f); + cp2155_set (fd, 0x9b, 0x00); + cp2155_set (fd, 0x9c, 0x07); + cp2155_set (fd, 0x90, 0xf0); + cp2155_set (fd, 0x9b, 0x04); + cp2155_set (fd, 0x98, 0x00); + cp2155_set (fd, 0x98, 0x00); + cp2155_set (fd, 0x98, 0x02); + cp2155_set (fd, 0x99, 0x3b); + cp2155_set (fd, 0x9a, 0x03); + cp2155_set (fd, 0x80, 0x10); + cp2155_set (fd, 0x8d, 0x00); + cp2155_set (fd, 0x8d, 0x04); + + DBG (1, "INIT state: %0d\n", result); + + return result; +} + +void +back2225 (int fd, unsigned char *buf) +{ + size_t count; + cp2155_set (fd, 0x90, 0xc8); + cp2155_set (fd, 0x90, 0xc8); + cp2155_set (fd, 0xb0, 0x03); + cp2155_set (fd, 0x07, 0x00); + cp2155_set (fd, 0x07, 0x00); + cp2155_set (fd, 0x08, 0x00); + cp2155_set (fd, 0x09, 0x69); + cp2155_set (fd, 0x0a, 0x00); + cp2155_set (fd, 0x0b, 0xe8); + cp2155_set (fd, 0xa0, 0x1d); + cp2155_set (fd, 0xa1, 0x00); + cp2155_set (fd, 0xa2, 0x00); + cp2155_set (fd, 0xa3, 0x70); + cp2155_set (fd, 0x64, 0x00); + cp2155_set (fd, 0x65, 0x00); + cp2155_set (fd, 0x61, 0x00); + cp2155_set (fd, 0x62, 0x2e); + cp2155_set (fd, 0x63, 0x00); + cp2155_set (fd, 0x50, 0x04); + cp2155_set (fd, 0x50, 0x04); + cp2155_set (fd, 0x51, 0x07); + cp2155_set (fd, 0x5a, 0x32); + cp2155_set (fd, 0x5b, 0x32); + cp2155_set (fd, 0x5c, 0x32); + cp2155_set (fd, 0x5d, 0x32); + cp2155_set (fd, 0x52, 0x00); + cp2155_set (fd, 0x53, 0x01); + cp2155_set (fd, 0x54, 0x00); + cp2155_set (fd, 0x55, 0x01); + cp2155_set (fd, 0x56, 0x00); + cp2155_set (fd, 0x57, 0x01); + cp2155_set (fd, 0x58, 0x00); + cp2155_set (fd, 0x59, 0x01); + cp2155_set (fd, 0x5e, 0x02); + cp2155_set (fd, 0x5f, 0x00); + cp2155_set (fd, 0x5f, 0x03); + cp2155_set (fd, 0x60, 0x15); + cp2155_set (fd, 0x60, 0x15); + cp2155_set (fd, 0x60, 0x15); + cp2155_set (fd, 0x60, 0x15); + cp2155_set (fd, 0x50, 0x04); + cp2155_set (fd, 0x51, 0x07); + cp2155_set (fd, 0x81, 0x29); + cp2155_set (fd, 0x81, 0x29); + cp2155_set (fd, 0x82, 0x09); + cp2155_set (fd, 0x82, 0x09); + cp2155_set (fd, 0x83, 0x02); + cp2155_set (fd, 0x84, 0x06); + cp2155_set (fd, 0x80, 0x12); + cp2155_set (fd, 0x80, 0x12); + cp2155_set (fd, 0xb0, 0x03); + cp2155_set (fd, 0x10, 0x05); + cp2155_set (fd, 0x10, 0x05); + cp2155_set (fd, 0x9b, 0x03); + cp2155_set (fd, 0x10, 0x05); + cp2155_set (fd, 0x11, 0x41); + cp2155_set (fd, 0x11, 0x61); + cp2155_set (fd, 0x11, 0x21); + cp2155_set (fd, 0x11, 0x21); + cp2155_set (fd, 0x11, 0x25); + cp2155_set (fd, 0x11, 0x25); + cp2155_set (fd, 0x11, 0x25); + cp2155_set (fd, 0x12, 0x40); + cp2155_set (fd, 0x13, 0x40); + cp2155_set (fd, 0x16, 0x40); + cp2155_set (fd, 0x21, 0x06); + cp2155_set (fd, 0x22, 0x40); + cp2155_set (fd, 0x20, 0x06); + cp2155_set (fd, 0x1d, 0x00); + cp2155_set (fd, 0x1e, 0x36); + cp2155_set (fd, 0x1f, 0xd0); + cp2155_set (fd, 0x66, 0x00); + cp2155_set (fd, 0x67, 0x00); + cp2155_set (fd, 0x68, 0x06); + cp2155_set (fd, 0x1a, 0x00); + cp2155_set (fd, 0x1b, 0x00); + cp2155_set (fd, 0x1c, 0x02); + cp2155_set (fd, 0x15, 0x83); + cp2155_set (fd, 0x14, 0x7c); + cp2155_set (fd, 0x17, 0x02); + cp2155_set (fd, 0x43, 0x1c); + cp2155_set (fd, 0x44, 0x9c); + cp2155_set (fd, 0x45, 0x38); + cp2155_set (fd, 0x23, 0x28); + cp2155_set (fd, 0x33, 0x28); + cp2155_set (fd, 0x24, 0x27); + cp2155_set (fd, 0x34, 0x27); + cp2155_set (fd, 0x25, 0x25); + cp2155_set (fd, 0x35, 0x25); + cp2155_set (fd, 0x26, 0x21); + cp2155_set (fd, 0x36, 0x21); + cp2155_set (fd, 0x27, 0x1c); + cp2155_set (fd, 0x37, 0x1c); + cp2155_set (fd, 0x28, 0x16); + cp2155_set (fd, 0x38, 0x16); + cp2155_set (fd, 0x29, 0x0f); + cp2155_set (fd, 0x39, 0x0f); + cp2155_set (fd, 0x2a, 0x08); + cp2155_set (fd, 0x3a, 0x08); + cp2155_set (fd, 0x2b, 0x00); + cp2155_set (fd, 0x3b, 0x00); + cp2155_set (fd, 0x2c, 0x08); + cp2155_set (fd, 0x3c, 0x08); + cp2155_set (fd, 0x2d, 0x0f); + cp2155_set (fd, 0x3d, 0x0f); + cp2155_set (fd, 0x2e, 0x16); + cp2155_set (fd, 0x3e, 0x16); + cp2155_set (fd, 0x2f, 0x1c); + cp2155_set (fd, 0x3f, 0x1c); + cp2155_set (fd, 0x30, 0x21); + cp2155_set (fd, 0x40, 0x21); + cp2155_set (fd, 0x31, 0x25); + cp2155_set (fd, 0x41, 0x25); + cp2155_set (fd, 0x32, 0x27); + cp2155_set (fd, 0x42, 0x27); + cp2155_set (fd, 0xca, 0x02); + cp2155_set (fd, 0xca, 0x02); + cp2155_set (fd, 0xca, 0x22); + cp2155_set (fd, 0x18, 0x00); + + memcpy (buf + 0x00000000, + "\x04\x70\x00\x01\x80\x25\x80\x25\x80\x25\x80\x25\x80\x25\x80\x25", + 16); + memcpy (buf + 0x00000010, + "\x80\x25\x80\x25\x80\x25\x80\x25\x80\x25\x80\x25\x80\x25\x80\x25", + 16); + memcpy (buf + 0x00000020, + "\x80\x25\x80\x25\x80\x25\x80\x25\x80\x25\x80\x25\x80\x25\x80\x25", + 16); + memcpy (buf + 0x00000030, + "\x80\x25\x80\x25\x80\x25\x80\x25\x80\x25\x80\x25\x80\x25\x80\x25", + 16); + memcpy (buf + 0x00000040, + "\x80\x25\x80\x25\x80\x25\x80\x25\x80\x25\x80\x25\x80\x25\x80\x25", + 16); + memcpy (buf + 0x00000050, + "\x80\x25\x80\x25\x80\x25\x80\x25\x80\x25\x80\x25\x80\x25\x80\x25", + 16); + memcpy (buf + 0x00000060, + "\x80\x25\x80\x25\x80\x25\x80\x25\x80\x25\xf0\x23\x80\x22\x2c\x21", + 16); + memcpy (buf + 0x00000070, + "\xf1\x1f\xcd\x1e\xbd\x1d\xc0\x1c\xd2\x1b\xf4\x1a\x22\x1a\x5e\x19", + 16); + memcpy (buf + 0x00000080, + "\xa4\x18\xf5\x17\x4f\x17\xb2\x16\x1d\x16\x90\x15\x09\x15\x89\x14", + 16); + memcpy (buf + 0x00000090, + "\x0e\x14\x9a\x13\x2a\x13\xc0\x12\x59\x12\xf8\x11\x9a\x11\x3f\x11", + 16); + memcpy (buf + 0x000000a0, + "\xe9\x10\x96\x10\x46\x10\xf8\x0f\xae\x0f\x66\x0f\x21\x0f\xde\x0e", + 16); + memcpy (buf + 0x000000b0, + "\x9e\x0e\x60\x0e\x23\x0e\xe9\x0d\xb0\x0d\x7a\x0d\x44\x0d\x11\x0d", + 16); + memcpy (buf + 0x000000c0, + "\xdf\x0c\xaf\x0c\x80\x0c\x52\x0c\x25\x0c\xfa\x0b\xd0\x0b\xa7\x0b", + 16); + memcpy (buf + 0x000000d0, + "\x80\x0b\x59\x0b\x33\x0b\x0e\x0b\xea\x0a\xc8\x0a\xa5\x0a\x84\x0a", + 16); + memcpy (buf + 0x000000e0, + "\x64\x0a\x44\x0a\x25\x0a\x07\x0a\xe9\x09\xcd\x09\xb0\x09\x95\x09", + 16); + memcpy (buf + 0x000000f0, + "\x7a\x09\x60\x09\x46\x09\x2c\x09\x14\x09\xfc\x08\xe4\x08\xcd\x08", + 16); + memcpy (buf + 0x00000100, "\xb6\x08\xa0\x08", 4); + count = 260; + write_buf (fd, count, buf, 0x03, 0x00); + write_buf (fd, count, buf, 0x03, 0x02); + write_buf (fd, count, buf, 0x03, 0x06); + + memcpy (buf + 0x00000000, + "\x04\x70\x18\x00\x80\x25\xc0\x1c\x4f\x17\x9a\x13\xe9\x10\xde\x0e", + 16); + memcpy (buf + 0x00000010, + "\x44\x0d\xfa\x0b\xea\x0a\x07\x0a\x46\x09\xa0\x08\x80\x25\x80\x25", + 16); + memcpy (buf + 0x00000020, "\x80\x25\x80\x25", 4); + count = 36; + write_buf (fd, count, buf, 0x03, 0x04); + write_buf (fd, count, buf, 0x03, 0x08); + + cp2155_motor (fd, 0x05, 0x35); + +} + +void +back2224 (int fd, unsigned char *buf) +{ + size_t count; + +/* cp2155_set (fd, 0x90, 0xe8); */ + cp2155_set (fd, 0x9b, 0x06); + cp2155_set (fd, 0x9b, 0x04); +/* cp2155_set (fd, 0x90, 0xf8); */ + cp2155_set (fd, 0xb0, 0x03); + cp2155_set (fd, 0x07, 0x00); + cp2155_set (fd, 0x07, 0x00); + cp2155_set (fd, 0x08, 0x01); + cp2155_set (fd, 0x09, 0xb3); + cp2155_set (fd, 0x0a, 0x02); + cp2155_set (fd, 0x0b, 0x32); + cp2155_set (fd, 0xa0, 0x1d); + cp2155_set (fd, 0xa1, 0x00); + cp2155_set (fd, 0xa2, 0x00); + cp2155_set (fd, 0xa3, 0x70); + cp2155_set (fd, 0x64, 0x00); + cp2155_set (fd, 0x65, 0x00); + cp2155_set (fd, 0x61, 0x00); + cp2155_set (fd, 0x62, 0x2e); + cp2155_set (fd, 0x63, 0x00); + cp2155_set (fd, 0x50, 0x04); + cp2155_set (fd, 0x50, 0x04); +/* cp2155_set (fd, 0x90, 0xf8); */ + cp2155_set (fd, 0x51, 0x07); + cp2155_set (fd, 0x5a, 0xff); + cp2155_set (fd, 0x5b, 0xff); + cp2155_set (fd, 0x5c, 0xff); + cp2155_set (fd, 0x5d, 0xff); + cp2155_set (fd, 0x52, 0x00); + cp2155_set (fd, 0x53, 0x01); + cp2155_set (fd, 0x54, 0x00); + cp2155_set (fd, 0x55, 0x01); + cp2155_set (fd, 0x56, 0x00); + cp2155_set (fd, 0x57, 0x01); + cp2155_set (fd, 0x58, 0x00); + cp2155_set (fd, 0x59, 0x01); + cp2155_set (fd, 0x5e, 0x02); + cp2155_set (fd, 0x5f, 0x00); + cp2155_set (fd, 0x5f, 0x03); + cp2155_set (fd, 0x60, 0x01); + cp2155_set (fd, 0x60, 0x01); + cp2155_set (fd, 0x60, 0x01); + cp2155_set (fd, 0x60, 0x01); + cp2155_set (fd, 0x50, 0x04); + cp2155_set (fd, 0x51, 0x07); + cp2155_set (fd, 0x81, 0x31); + cp2155_set (fd, 0x81, 0x31); + cp2155_set (fd, 0x82, 0x11); + cp2155_set (fd, 0x82, 0x11); + cp2155_set (fd, 0x83, 0x01); + cp2155_set (fd, 0x84, 0x05); + cp2155_set (fd, 0x80, 0x12); + cp2155_set (fd, 0x80, 0x12); + cp2155_set (fd, 0xb0, 0x03); + cp2155_set (fd, 0x10, 0x05); + cp2155_set (fd, 0x10, 0x05); + cp2155_set (fd, 0x10, 0x05); + cp2155_set (fd, 0x10, 0x05); + cp2155_set (fd, 0x11, 0x41); + cp2155_set (fd, 0x11, 0x61); + cp2155_set (fd, 0x11, 0x21); + cp2155_set (fd, 0x11, 0x21); + cp2155_set (fd, 0x11, 0x25); + cp2155_set (fd, 0x11, 0x25); + cp2155_set (fd, 0x11, 0x25); + cp2155_set (fd, 0x12, 0x7d); + cp2155_set (fd, 0x13, 0x7d); + cp2155_set (fd, 0x16, 0x7d); + cp2155_set (fd, 0x21, 0x06); + cp2155_set (fd, 0x22, 0x7d); + cp2155_set (fd, 0x20, 0x06); + cp2155_set (fd, 0x1d, 0x00); + cp2155_set (fd, 0x1e, 0x36); + cp2155_set (fd, 0x1f, 0xd0); + cp2155_set (fd, 0x66, 0x00); + cp2155_set (fd, 0x67, 0x00); + cp2155_set (fd, 0x68, 0x06); + cp2155_set (fd, 0x1a, 0x00); + cp2155_set (fd, 0x1b, 0x00); + cp2155_set (fd, 0x1c, 0x02); + cp2155_set (fd, 0x15, 0x83); + cp2155_set (fd, 0x14, 0x7c); + cp2155_set (fd, 0x17, 0x02); + cp2155_set (fd, 0x43, 0x1c); + cp2155_set (fd, 0x44, 0x9c); + cp2155_set (fd, 0x45, 0x38); + cp2155_set (fd, 0x23, 0x0d); + cp2155_set (fd, 0x33, 0x0d); + cp2155_set (fd, 0x24, 0x0d); + cp2155_set (fd, 0x34, 0x0d); + cp2155_set (fd, 0x25, 0x0d); + cp2155_set (fd, 0x35, 0x0d); + cp2155_set (fd, 0x26, 0x0d); + cp2155_set (fd, 0x36, 0x0d); + cp2155_set (fd, 0x27, 0x0d); + cp2155_set (fd, 0x37, 0x0d); + cp2155_set (fd, 0x28, 0x0d); + cp2155_set (fd, 0x38, 0x0d); + cp2155_set (fd, 0x29, 0x0d); + cp2155_set (fd, 0x39, 0x0d); + cp2155_set (fd, 0x2a, 0x0d); + cp2155_set (fd, 0x3a, 0x0d); + cp2155_set (fd, 0x2b, 0x0d); + cp2155_set (fd, 0x3b, 0x0d); + cp2155_set (fd, 0x2c, 0x0d); + cp2155_set (fd, 0x3c, 0x0d); + cp2155_set (fd, 0x2d, 0x0d); + cp2155_set (fd, 0x3d, 0x0d); + cp2155_set (fd, 0x2e, 0x0d); + cp2155_set (fd, 0x3e, 0x0d); + cp2155_set (fd, 0x2f, 0x0d); + cp2155_set (fd, 0x3f, 0x0d); + cp2155_set (fd, 0x30, 0x0d); + cp2155_set (fd, 0x40, 0x0d); + cp2155_set (fd, 0x31, 0x0d); + cp2155_set (fd, 0x41, 0x0d); + cp2155_set (fd, 0x32, 0x0d); + cp2155_set (fd, 0x42, 0x0d); + cp2155_set (fd, 0xca, 0x00); + cp2155_set (fd, 0xca, 0x00); + cp2155_set (fd, 0xca, 0x00); + cp2155_set (fd, 0x18, 0x00); + cp2155_set (fd, 0x71, 0x01); + cp2155_set (fd, 0x0230, 0x11); + cp2155_set (fd, 0x71, 0x14); + cp2155_set (fd, 0x72, 0x02); + cp2155_set (fd, 0x73, 0x00); + cp2155_set (fd, 0x74, 0x03); + cp2155_set (fd, 0x75, 0x00); + cp2155_set (fd, 0x76, 0x00); + cp2155_set (fd, 0x0239, 0x40); + cp2155_set (fd, 0x0238, 0x89); + cp2155_set (fd, 0x023c, 0x2f); + cp2155_set (fd, 0x0264, 0x20); + memcpy (buf + 0x0000, + "\x04\x70\xf4\x01\x80\x25\x00\x25\x84\x24\x0b\x24\x96\x23\x23\x23", + 16); + memcpy (buf + 0x0010, + "\xb3\x22\x46\x22\xdb\x21\x73\x21\x0e\x21\xab\x20\x4a\x20\xeb\x1f", + 16); + memcpy (buf + 0x0020, + "\x8f\x1f\x34\x1f\xdc\x1e\x85\x1e\x31\x1e\xde\x1d\x8d\x1d\x3e\x1d", + 16); + memcpy (buf + 0x0030, + "\xf0\x1c\xa4\x1c\x59\x1c\x10\x1c\xc9\x1b\x83\x1b\x3e\x1b\xfa\x1a", + 16); + memcpy (buf + 0x0040, + "\xb8\x1a\x77\x1a\x38\x1a\xf9\x19\xbc\x19\x80\x19\x44\x19\x0a\x19", + 16); + memcpy (buf + 0x0050, + "\xd1\x18\x99\x18\x62\x18\x2c\x18\xf7\x17\xc3\x17\x8f\x17\x5d\x17", + 16); + memcpy (buf + 0x0060, + "\x2b\x17\xfa\x16\xca\x16\x9b\x16\x6c\x16\x3e\x16\x11\x16\xe5\x15", + 16); + memcpy (buf + 0x0070, + "\xb9\x15\x8e\x15\x64\x15\x3a\x15\x11\x15\xe9\x14\xc1\x14\x9a\x14", + 16); + memcpy (buf + 0x0080, + "\x73\x14\x4d\x14\x27\x14\x02\x14\xde\x13\xba\x13\x96\x13\x74\x13", + 16); + memcpy (buf + 0x0090, + "\x51\x13\x2f\x13\x0d\x13\xec\x12\xcc\x12\xab\x12\x8c\x12\x6c\x12", + 16); + memcpy (buf + 0x00a0, + "\x4d\x12\x2f\x12\x11\x12\xf3\x11\xd5\x11\xb8\x11\x9c\x11\x80\x11", + 16); + memcpy (buf + 0x00b0, + "\x64\x11\x48\x11\x2d\x11\x12\x11\xf7\x10\xdd\x10\xc3\x10\xa9\x10", + 16); + memcpy (buf + 0x00c0, + "\x90\x10\x77\x10\x5e\x10\x46\x10\x2e\x10\x16\x10\xfe\x0f\xe7\x0f", + 16); + memcpy (buf + 0x00d0, + "\xd0\x0f\xb9\x0f\xa2\x0f\x8c\x0f\x76\x0f\x60\x0f\x4b\x0f\x35\x0f", + 16); + memcpy (buf + 0x00e0, + "\x20\x0f\x0b\x0f\xf7\x0e\xe2\x0e\xce\x0e\xba\x0e\xa6\x0e\x92\x0e", + 16); + memcpy (buf + 0x00f0, + "\x7f\x0e\x6c\x0e\x59\x0e\x46\x0e\x33\x0e\x21\x0e\x0f\x0e\xfd\x0d", + 16); + memcpy (buf + 0x0100, + "\xeb\x0d\xd9\x0d\xc8\x0d\xb6\x0d\xa5\x0d\x94\x0d\x83\x0d\x73\x0d", + 16); + memcpy (buf + 0x0110, + "\x62\x0d\x52\x0d\x41\x0d\x31\x0d\x22\x0d\x12\x0d\x02\x0d\xf3\x0c", + 16); + memcpy (buf + 0x0120, + "\xe3\x0c\xd4\x0c\xc5\x0c\xb6\x0c\xa7\x0c\x99\x0c\x8a\x0c\x7c\x0c", + 16); + memcpy (buf + 0x0130, + "\x6e\x0c\x60\x0c\x52\x0c\x44\x0c\x36\x0c\x28\x0c\x1b\x0c\x0d\x0c", + 16); + memcpy (buf + 0x0140, + "\x00\x0c\xf3\x0b\xe6\x0b\xd9\x0b\xcc\x0b\xbf\x0b\xb3\x0b\xa6\x0b", + 16); + memcpy (buf + 0x0150, + "\x9a\x0b\x8e\x0b\x81\x0b\x75\x0b\x69\x0b\x5d\x0b\x52\x0b\x46\x0b", + 16); + memcpy (buf + 0x0160, + "\x3a\x0b\x2f\x0b\x23\x0b\x18\x0b\x0d\x0b\x02\x0b\xf6\x0a\xeb\x0a", + 16); + memcpy (buf + 0x0170, + "\xe1\x0a\xd6\x0a\xcb\x0a\xc0\x0a\xb6\x0a\xab\x0a\xa1\x0a\x97\x0a", + 16); + memcpy (buf + 0x0180, + "\x8c\x0a\x82\x0a\x78\x0a\x6e\x0a\x64\x0a\x5a\x0a\x50\x0a\x47\x0a", + 16); + memcpy (buf + 0x0190, + "\x3d\x0a\x33\x0a\x2a\x0a\x20\x0a\x17\x0a\x0e\x0a\x04\x0a\xfb\x09", + 16); + memcpy (buf + 0x01a0, + "\xf2\x09\xe9\x09\xe0\x09\xd7\x09\xce\x09\xc6\x09\xbd\x09\xb4\x09", + 16); + memcpy (buf + 0x01b0, + "\xab\x09\xa3\x09\x9a\x09\x92\x09\x8a\x09\x81\x09\x79\x09\x71\x09", + 16); + memcpy (buf + 0x01c0, + "\x69\x09\x61\x09\x59\x09\x51\x09\x49\x09\x41\x09\x39\x09\x31\x09", + 16); + memcpy (buf + 0x01d0, + "\x29\x09\x22\x09\x1a\x09\x12\x09\x0b\x09\x03\x09\xfc\x08\xf5\x08", + 16); + memcpy (buf + 0x01e0, + "\xed\x08\xe6\x08\xdf\x08\xd8\x08\xd0\x08\xc9\x08\xc2\x08\xbb\x08", + 16); + memcpy (buf + 0x01f0, + "\xb4\x08\xad\x08\xa6\x08\xa0\x08\x00\x00\x00\x00\x00\x00\x00\x00", + 16); + memcpy (buf + 0x0200, "\x00\x00\x00\x00", 4); + count = 516; + sanei_usb_write_bulk (fd, buf, &count); + cp2155_set (fd, 0x71, 0x01); + cp2155_set (fd, 0x0230, 0x11); + cp2155_set (fd, 0x71, 0x14); + cp2155_set (fd, 0x72, 0x02); + cp2155_set (fd, 0x73, 0x00); + cp2155_set (fd, 0x74, 0x03); + cp2155_set (fd, 0x75, 0x02); + cp2155_set (fd, 0x76, 0x00); + cp2155_set (fd, 0x0239, 0x40); + cp2155_set (fd, 0x0238, 0x89); + cp2155_set (fd, 0x023c, 0x2f); + cp2155_set (fd, 0x0264, 0x20); + memcpy (buf + 0x0000, + "\x04\x70\xf4\x01\x80\x25\x00\x25\x84\x24\x0b\x24\x96\x23\x23\x23", + 16); + memcpy (buf + 0x0010, + "\xb3\x22\x46\x22\xdb\x21\x73\x21\x0e\x21\xab\x20\x4a\x20\xeb\x1f", + 16); + memcpy (buf + 0x0020, + "\x8f\x1f\x34\x1f\xdc\x1e\x85\x1e\x31\x1e\xde\x1d\x8d\x1d\x3e\x1d", + 16); + memcpy (buf + 0x0030, + "\xf0\x1c\xa4\x1c\x59\x1c\x10\x1c\xc9\x1b\x83\x1b\x3e\x1b\xfa\x1a", + 16); + memcpy (buf + 0x0040, + "\xb8\x1a\x77\x1a\x38\x1a\xf9\x19\xbc\x19\x80\x19\x44\x19\x0a\x19", + 16); + memcpy (buf + 0x0050, + "\xd1\x18\x99\x18\x62\x18\x2c\x18\xf7\x17\xc3\x17\x8f\x17\x5d\x17", + 16); + memcpy (buf + 0x0060, + "\x2b\x17\xfa\x16\xca\x16\x9b\x16\x6c\x16\x3e\x16\x11\x16\xe5\x15", + 16); + memcpy (buf + 0x0070, + "\xb9\x15\x8e\x15\x64\x15\x3a\x15\x11\x15\xe9\x14\xc1\x14\x9a\x14", + 16); + memcpy (buf + 0x0080, + "\x73\x14\x4d\x14\x27\x14\x02\x14\xde\x13\xba\x13\x96\x13\x74\x13", + 16); + memcpy (buf + 0x0090, + "\x51\x13\x2f\x13\x0d\x13\xec\x12\xcc\x12\xab\x12\x8c\x12\x6c\x12", + 16); + memcpy (buf + 0x00a0, + "\x4d\x12\x2f\x12\x11\x12\xf3\x11\xd5\x11\xb8\x11\x9c\x11\x80\x11", + 16); + memcpy (buf + 0x00b0, + "\x64\x11\x48\x11\x2d\x11\x12\x11\xf7\x10\xdd\x10\xc3\x10\xa9\x10", + 16); + memcpy (buf + 0x00c0, + "\x90\x10\x77\x10\x5e\x10\x46\x10\x2e\x10\x16\x10\xfe\x0f\xe7\x0f", + 16); + memcpy (buf + 0x00d0, + "\xd0\x0f\xb9\x0f\xa2\x0f\x8c\x0f\x76\x0f\x60\x0f\x4b\x0f\x35\x0f", + 16); + memcpy (buf + 0x00e0, + "\x20\x0f\x0b\x0f\xf7\x0e\xe2\x0e\xce\x0e\xba\x0e\xa6\x0e\x92\x0e", + 16); + memcpy (buf + 0x00f0, + "\x7f\x0e\x6c\x0e\x59\x0e\x46\x0e\x33\x0e\x21\x0e\x0f\x0e\xfd\x0d", + 16); + memcpy (buf + 0x0100, + "\xeb\x0d\xd9\x0d\xc8\x0d\xb6\x0d\xa5\x0d\x94\x0d\x83\x0d\x73\x0d", + 16); + memcpy (buf + 0x0110, + "\x62\x0d\x52\x0d\x41\x0d\x31\x0d\x22\x0d\x12\x0d\x02\x0d\xf3\x0c", + 16); + memcpy (buf + 0x0120, + "\xe3\x0c\xd4\x0c\xc5\x0c\xb6\x0c\xa7\x0c\x99\x0c\x8a\x0c\x7c\x0c", + 16); + memcpy (buf + 0x0130, + "\x6e\x0c\x60\x0c\x52\x0c\x44\x0c\x36\x0c\x28\x0c\x1b\x0c\x0d\x0c", + 16); + memcpy (buf + 0x0140, + "\x00\x0c\xf3\x0b\xe6\x0b\xd9\x0b\xcc\x0b\xbf\x0b\xb3\x0b\xa6\x0b", + 16); + memcpy (buf + 0x0150, + "\x9a\x0b\x8e\x0b\x81\x0b\x75\x0b\x69\x0b\x5d\x0b\x52\x0b\x46\x0b", + 16); + memcpy (buf + 0x0160, + "\x3a\x0b\x2f\x0b\x23\x0b\x18\x0b\x0d\x0b\x02\x0b\xf6\x0a\xeb\x0a", + 16); + memcpy (buf + 0x0170, + "\xe1\x0a\xd6\x0a\xcb\x0a\xc0\x0a\xb6\x0a\xab\x0a\xa1\x0a\x97\x0a", + 16); + memcpy (buf + 0x0180, + "\x8c\x0a\x82\x0a\x78\x0a\x6e\x0a\x64\x0a\x5a\x0a\x50\x0a\x47\x0a", + 16); + memcpy (buf + 0x0190, + "\x3d\x0a\x33\x0a\x2a\x0a\x20\x0a\x17\x0a\x0e\x0a\x04\x0a\xfb\x09", + 16); + memcpy (buf + 0x01a0, + "\xf2\x09\xe9\x09\xe0\x09\xd7\x09\xce\x09\xc6\x09\xbd\x09\xb4\x09", + 16); + memcpy (buf + 0x01b0, + "\xab\x09\xa3\x09\x9a\x09\x92\x09\x8a\x09\x81\x09\x79\x09\x71\x09", + 16); + memcpy (buf + 0x01c0, + "\x69\x09\x61\x09\x59\x09\x51\x09\x49\x09\x41\x09\x39\x09\x31\x09", + 16); + memcpy (buf + 0x01d0, + "\x29\x09\x22\x09\x1a\x09\x12\x09\x0b\x09\x03\x09\xfc\x08\xf5\x08", + 16); + memcpy (buf + 0x01e0, + "\xed\x08\xe6\x08\xdf\x08\xd8\x08\xd0\x08\xc9\x08\xc2\x08\xbb\x08", + 16); + memcpy (buf + 0x01f0, + "\xb4\x08\xad\x08\xa6\x08\xa0\x08\x00\x00\x00\x00\x00\x00\x00\x00", + 16); + memcpy (buf + 0x0200, "\x00\x00\x00\x00", 4); + count = 516; + sanei_usb_write_bulk (fd, buf, &count); + cp2155_set (fd, 0x71, 0x01); + cp2155_set (fd, 0x0230, 0x11); + cp2155_set (fd, 0x71, 0x14); + cp2155_set (fd, 0x72, 0x00); + cp2155_set (fd, 0x73, 0x20); + cp2155_set (fd, 0x74, 0x03); + cp2155_set (fd, 0x75, 0x04); + cp2155_set (fd, 0x76, 0x00); + cp2155_set (fd, 0x0239, 0x40); + cp2155_set (fd, 0x0238, 0x89); + cp2155_set (fd, 0x023c, 0x2f); + cp2155_set (fd, 0x0264, 0x20); + memcpy (buf + 0x0000, + "\x04\x70\x18\x00\x80\x25\xc0\x1c\x4f\x17\x9a\x13\xe9\x10\xde\x0e", + 16); + memcpy (buf + 0x0010, + "\x44\x0d\xfa\x0b\xea\x0a\x07\x0a\x46\x09\xa0\x08\x4a\x20\xeb\x1f", + 16); + memcpy (buf + 0x0020, "\x8f\x1f\x34\x1f", 4); + count = 36; + sanei_usb_write_bulk (fd, buf, &count); + cp2155_set (fd, 0x71, 0x01); + cp2155_set (fd, 0x0230, 0x11); + cp2155_set (fd, 0x71, 0x14); + cp2155_set (fd, 0x72, 0x02); + cp2155_set (fd, 0x73, 0x00); + cp2155_set (fd, 0x74, 0x03); + cp2155_set (fd, 0x75, 0x06); + cp2155_set (fd, 0x76, 0x00); + cp2155_set (fd, 0x0239, 0x40); + cp2155_set (fd, 0x0238, 0x89); + cp2155_set (fd, 0x023c, 0x2f); + cp2155_set (fd, 0x0264, 0x20); + memcpy (buf + 0x0000, + "\x04\x70\xf4\x01\x80\x25\x00\x25\x84\x24\x0b\x24\x96\x23\x23\x23", + 16); + memcpy (buf + 0x0010, + "\xb3\x22\x46\x22\xdb\x21\x73\x21\x0e\x21\xab\x20\x4a\x20\xeb\x1f", + 16); + memcpy (buf + 0x0020, + "\x8f\x1f\x34\x1f\xdc\x1e\x85\x1e\x31\x1e\xde\x1d\x8d\x1d\x3e\x1d", + 16); + memcpy (buf + 0x0030, + "\xf0\x1c\xa4\x1c\x59\x1c\x10\x1c\xc9\x1b\x83\x1b\x3e\x1b\xfa\x1a", + 16); + memcpy (buf + 0x0040, + "\xb8\x1a\x77\x1a\x38\x1a\xf9\x19\xbc\x19\x80\x19\x44\x19\x0a\x19", + 16); + memcpy (buf + 0x0050, + "\xd1\x18\x99\x18\x62\x18\x2c\x18\xf7\x17\xc3\x17\x8f\x17\x5d\x17", + 16); + memcpy (buf + 0x0060, + "\x2b\x17\xfa\x16\xca\x16\x9b\x16\x6c\x16\x3e\x16\x11\x16\xe5\x15", + 16); + memcpy (buf + 0x0070, + "\xb9\x15\x8e\x15\x64\x15\x3a\x15\x11\x15\xe9\x14\xc1\x14\x9a\x14", + 16); + memcpy (buf + 0x0080, + "\x73\x14\x4d\x14\x27\x14\x02\x14\xde\x13\xba\x13\x96\x13\x74\x13", + 16); + memcpy (buf + 0x0090, + "\x51\x13\x2f\x13\x0d\x13\xec\x12\xcc\x12\xab\x12\x8c\x12\x6c\x12", + 16); + memcpy (buf + 0x00a0, + "\x4d\x12\x2f\x12\x11\x12\xf3\x11\xd5\x11\xb8\x11\x9c\x11\x80\x11", + 16); + memcpy (buf + 0x00b0, + "\x64\x11\x48\x11\x2d\x11\x12\x11\xf7\x10\xdd\x10\xc3\x10\xa9\x10", + 16); + memcpy (buf + 0x00c0, + "\x90\x10\x77\x10\x5e\x10\x46\x10\x2e\x10\x16\x10\xfe\x0f\xe7\x0f", + 16); + memcpy (buf + 0x00d0, + "\xd0\x0f\xb9\x0f\xa2\x0f\x8c\x0f\x76\x0f\x60\x0f\x4b\x0f\x35\x0f", + 16); + memcpy (buf + 0x00e0, + "\x20\x0f\x0b\x0f\xf7\x0e\xe2\x0e\xce\x0e\xba\x0e\xa6\x0e\x92\x0e", + 16); + memcpy (buf + 0x00f0, + "\x7f\x0e\x6c\x0e\x59\x0e\x46\x0e\x33\x0e\x21\x0e\x0f\x0e\xfd\x0d", + 16); + memcpy (buf + 0x0100, + "\xeb\x0d\xd9\x0d\xc8\x0d\xb6\x0d\xa5\x0d\x94\x0d\x83\x0d\x73\x0d", + 16); + memcpy (buf + 0x0110, + "\x62\x0d\x52\x0d\x41\x0d\x31\x0d\x22\x0d\x12\x0d\x02\x0d\xf3\x0c", + 16); + memcpy (buf + 0x0120, + "\xe3\x0c\xd4\x0c\xc5\x0c\xb6\x0c\xa7\x0c\x99\x0c\x8a\x0c\x7c\x0c", + 16); + memcpy (buf + 0x0130, + "\x6e\x0c\x60\x0c\x52\x0c\x44\x0c\x36\x0c\x28\x0c\x1b\x0c\x0d\x0c", + 16); + memcpy (buf + 0x0140, + "\x00\x0c\xf3\x0b\xe6\x0b\xd9\x0b\xcc\x0b\xbf\x0b\xb3\x0b\xa6\x0b", + 16); + memcpy (buf + 0x0150, + "\x9a\x0b\x8e\x0b\x81\x0b\x75\x0b\x69\x0b\x5d\x0b\x52\x0b\x46\x0b", + 16); + memcpy (buf + 0x0160, + "\x3a\x0b\x2f\x0b\x23\x0b\x18\x0b\x0d\x0b\x02\x0b\xf6\x0a\xeb\x0a", + 16); + memcpy (buf + 0x0170, + "\xe1\x0a\xd6\x0a\xcb\x0a\xc0\x0a\xb6\x0a\xab\x0a\xa1\x0a\x97\x0a", + 16); + memcpy (buf + 0x0180, + "\x8c\x0a\x82\x0a\x78\x0a\x6e\x0a\x64\x0a\x5a\x0a\x50\x0a\x47\x0a", + 16); + memcpy (buf + 0x0190, + "\x3d\x0a\x33\x0a\x2a\x0a\x20\x0a\x17\x0a\x0e\x0a\x04\x0a\xfb\x09", + 16); + memcpy (buf + 0x01a0, + "\xf2\x09\xe9\x09\xe0\x09\xd7\x09\xce\x09\xc6\x09\xbd\x09\xb4\x09", + 16); + memcpy (buf + 0x01b0, + "\xab\x09\xa3\x09\x9a\x09\x92\x09\x8a\x09\x81\x09\x79\x09\x71\x09", + 16); + memcpy (buf + 0x01c0, + "\x69\x09\x61\x09\x59\x09\x51\x09\x49\x09\x41\x09\x39\x09\x31\x09", + 16); + memcpy (buf + 0x01d0, + "\x29\x09\x22\x09\x1a\x09\x12\x09\x0b\x09\x03\x09\xfc\x08\xf5\x08", + 16); + memcpy (buf + 0x01e0, + "\xed\x08\xe6\x08\xdf\x08\xd8\x08\xd0\x08\xc9\x08\xc2\x08\xbb\x08", + 16); + memcpy (buf + 0x01f0, + "\xb4\x08\xad\x08\xa6\x08\xa0\x08\x00\x00\x00\x00\x00\x00\x00\x00", + 16); + memcpy (buf + 0x0200, "\x00\x00\x00\x00", 4); + count = 516; + sanei_usb_write_bulk (fd, buf, &count); + cp2155_set (fd, 0x71, 0x01); + cp2155_set (fd, 0x0230, 0x11); + cp2155_set (fd, 0x71, 0x14); + cp2155_set (fd, 0x72, 0x00); + cp2155_set (fd, 0x73, 0x20); + cp2155_set (fd, 0x74, 0x03); + cp2155_set (fd, 0x75, 0x08); + cp2155_set (fd, 0x76, 0x00); + cp2155_set (fd, 0x0239, 0x40); + cp2155_set (fd, 0x0238, 0x89); + cp2155_set (fd, 0x023c, 0x2f); + cp2155_set (fd, 0x0264, 0x20); + memcpy (buf + 0x0000, + "\x04\x70\x18\x00\x80\x25\xc0\x1c\x4f\x17\x9a\x13\xe9\x10\xde\x0e", + 16); + memcpy (buf + 0x0010, + "\x44\x0d\xfa\x0b\xea\x0a\x07\x0a\x46\x09\xa0\x08\x4a\x20\xeb\x1f", + 16); + memcpy (buf + 0x0020, "\x8f\x1f\x34\x1f", 4); + count = 36; + sanei_usb_write_bulk (fd, buf, &count); + cp2155_set (fd, 0x10, 0x05); + cp2155_set (fd, 0x11, 0x35); + cp2155_set (fd, 0x60, 0x01); + cp2155_set (fd, 0x80, 0x12); + cp2155_set (fd, 0x03, 0x01); + +} + +static void +go_home_without_wait (CANON_Handle * chndl) +{ + unsigned char buf[0x400]; + int fd = chndl->fd; byte value; cp2155_get (fd, 0x46, &value); if (value == 0x08) { return; } - cp2155_block6 (fd, 0x12, 0xc1); - cp2155_set (fd, 0x01, 0x29); - cp2155_block8 (fd); - cp2155_set (fd, 0x01, 0x29); - cp2155_set_gamma (fd); - cp2155_block5 (fd, 0x03); - cp2155_set_regs (fd, cp2155_set_regs_data6); - cp2155_set_slope (fd, 0x030000, cp2155_slope09_back, 0x01f4); - cp2155_set_slope (fd, 0x030200, cp2155_slope09_back, 0x01f4); - cp2155_set_slope (fd, 0x030400, cp2155_slope10_back, 0x0018); - cp2155_set_slope (fd, 0x030600, cp2155_slope09_back, 0x01f4); - cp2155_set_slope (fd, 0x030800, cp2155_slope10_back, 0x0018); - cp2155_motor (fd, 0x05, 0x35); + DBG (1, "go_home_without_wait: product code: %x\n", chndl->productcode); + if (chndl->productcode == 0x2225) + { + back2225 (fd, buf); + } + else + { + back2224 (fd, buf); + } } static int -go_home (int fd) +go_home (CANON_Handle * chndl) { + int fd = chndl->fd; byte value; cp2155_get (fd, 0x46, &value); + DBG (1, "state sensor: %02x\n", value); if (value == 0x08) { return 0; } - go_home_without_wait (fd); + go_home_without_wait (chndl); while (1) { usleep (200 * MSEC); cp2155_get (fd, 0x46, &value); - DBG (1, "home sensor: %02x\n", value); + DBG (1, "state sensor: %02x\n", value); if (value == 0x08) { @@ -1704,72 +3555,6 @@ go_home (int fd) 0 afterward, and -1 on error. */ -static int -init (CANON_Handle * chndl) -{ - int fd = chndl->fd; - byte value; - int result = 0; - - cp2155_get (fd, 0xd0, &value); - /* Detect if scanner is plugged in */ - if (value != 0x81 && value != 0x40) - { - DBG (0, "INIT: unexpected value: %x\n", value); - } - - if (value == 0x00) - { - return -1; - } - - cp2155_set (fd, 0x02, 0x01); - cp2155_set (fd, 0x02, 0x00); - cp2155_set (fd, 0x01, 0x00); - cp2155_set (fd, 0x01, 0x28); - cp2155_set (fd, 0x90, 0x4f); - cp2155_set (fd, 0x92, 0xff); - cp2155_set (fd, 0x93, 0x00); - cp2155_set (fd, 0x91, 0x1f); - cp2155_set (fd, 0x95, 0x1f); - cp2155_set (fd, 0x97, 0x1f); - cp2155_set (fd, 0x9b, 0x00); - cp2155_set (fd, 0x9c, 0x07); - cp2155_set (fd, 0x90, 0x4d); - cp2155_set (fd, 0x90, 0xcd); - cp2155_set (fd, 0x90, 0xcc); - cp2155_set (fd, 0x9b, 0x01); - cp2155_set (fd, 0xa0, 0x04); - cp2155_set (fd, 0xa0, 0x05); - cp2155_set (fd, 0x01, 0x28); - cp2155_set (fd, 0x04, 0x0c); - cp2155_set (fd, 0x05, 0x00); - cp2155_set (fd, 0x06, 0x00); - cp2155_set (fd, 0x98, 0x00); - cp2155_set (fd, 0x98, 0x00); - cp2155_set (fd, 0x98, 0x02); - cp2155_set (fd, 0x99, 0x28); - cp2155_set (fd, 0x9a, 0x03); - cp2155_set (fd, 0x80, 0x10); - cp2155_set (fd, 0x8d, 0x00); - cp2155_set (fd, 0x8d, 0x04); - - cp2155_set (fd, 0x85, 0x00); - cp2155_set (fd, 0x87, 0x00); - cp2155_set (fd, 0x88, 0x70); - - cp2155_set (fd, 0x85, 0x03); - cp2155_set (fd, 0x87, 0x00); - cp2155_set (fd, 0x88, 0x28); - - cp2155_set (fd, 0x85, 0x06); - cp2155_set (fd, 0x87, 0x00); - cp2155_set (fd, 0x88, 0x28); - - - DBG (1, "INIT state: %0d\n", result); - return result; -} /* Scan and save the resulting image as r,g,b non-interleaved PPM file */ static SANE_Status @@ -1937,7 +3722,6 @@ do_scan (CANON_Handle * chndl) DBG (1, "err:%s when opening %s\n", strerror (errno), chndl->fname); return SANE_STATUS_IO_ERROR; } - int fd = chndl->fd; long width = chndl->params.pixels_per_line; if (chndl->val[opt_resolution].w < 600) { @@ -1958,10 +3742,24 @@ do_scan (CANON_Handle * chndl) case 150: case 300: case 600: - left_edge = 0x69; + if (chndl->productcode == 0x2224) + { + left_edge = 0x1b3; + } + else + { + left_edge = 0x69; + } break; case 1200: - left_edge = 0x87; + if (chndl->productcode == 0x2224) + { + left_edge = 0x1e3; + } + else + { + left_edge = 0x87; + } } x_start = left_edge + chndl->x1 * chndl->val[opt_resolution].w / 600; if (chndl->val[opt_resolution].w < 600) @@ -1988,7 +3786,7 @@ do_scan (CANON_Handle * chndl) { status = preread (chndl, outbuf, fp); } - go_home_without_wait (fd); + go_home_without_wait (chndl); if (status == SANE_STATUS_EOF) { @@ -2249,7 +4047,7 @@ CANON_start_scan (CANON_Handle * chndl) return SANE_STATUS_IO_ERROR; } - go_home (chndl->fd); + go_home (chndl); /* scan */ if ((status = scan (chndl)) != SANE_STATUS_GOOD) diff --git a/backend/canon_lide70.c b/backend/canon_lide70.c index 100a45fb3..11660f8f0 100644 --- a/backend/canon_lide70.c +++ b/backend/canon_lide70.c @@ -391,6 +391,10 @@ init_options (CANON_Handle * chndl) od->size = sizeof (SANE_Word); od->cap = SANE_CAP_SOFT_DETECT | SANE_CAP_SOFT_SELECT; od->constraint_type = SANE_CONSTRAINT_WORD_LIST; + if (chndl->productcode == 0x2224) + { + resolution_list[0] = 4; + } od->constraint.word_list = resolution_list; chndl->val[opt_resolution].w = init_resolution; diff --git a/doc/sane-canon_lide70.man b/doc/sane-canon_lide70.man index ae807a323..fc8e72775 100644 --- a/doc/sane-canon_lide70.man +++ b/doc/sane-canon_lide70.man @@ -1,12 +1,13 @@ -.TH sane\-canon_lide70 5 "26 Nov 2019" "@PACKAGEVERSION@" "SANE Scanner Access Now Easy" +.TH sane\-canon_lide70 5 "22 Aug 2020" "@PACKAGEVERSION@" "SANE Scanner Access Now Easy" .IX sane\-canon_lide70 .SH NAME -sane\-canon_lide70 \- SANE backend for the Canon LiDE 70 USB flatbed scanner +sane\-canon_lide70 \- SANE backend for the Canon LiDE 70 and 600(F) USB flatbed scanners .SH DESCRIPTION The .B canon_lide70 library implements a SANE (Scanner Access Now Easy) backend that -provides access to the Canon Inc. CanoScan LiDE 70 flatbed scanner. +provides access to the Canon Inc. CanoScan LiDE 70 and 600(F) +flatbed scanners. The film unit of the LiDE 600F is not supported. .PP Due to Canon's unwillingness to provide scanner documentation, this software was developed by analyzing the USB traffic of the Windows @@ -15,20 +16,14 @@ to the scanner is known only to a very limited extent. Some sophistication present in the Windows XP driver has been left out. There is, for example, no active calibration. .PP -TESTERS ARE WELCOME. Send your bug reports and comments to +Testers and reviewers are welcome. Send your bug reports and comments to the sane\-devel mailing list .PP -The -.B Canoscan LiDE 600 -(or 600f, with film unit) is closely related to the LiDE 70, but -it does not work with this backend. Support for the LiDE 600 will -be added by the end of 2020. -.PP .SH CONFIGURATION The .I @CONFIGDIR@/canon_lide70.conf file identifies the LiDE 70 by its vendor code 0x04a9 and its -product code 0x2225. For the LiDE 600(f) the product code would be 0x2224. +product code 0x2225. For the LiDE 600(f) the product code is 0x2224. .PP .SH BACKEND SPECIFIC OPTIONS .PP @@ -36,7 +31,8 @@ product code 0x2225. For the LiDE 600(f) the product code would be 0x2224. .TP \-\-resolution 75|150|300|600|1200 [default 600] .BR -Sets the resolution of the scanned image in dots per inch. Scanning at 1200 dpi is very slow. +Sets the resolution of the scanned image in dots per inch. Scanning at 1200 dpi +is not available on the LiDE 600(F) and it is very slow on the LiDE 70. .TP \-\-mode Color|Gray|Lineart [default: Color] .BR @@ -87,12 +83,13 @@ Example: SANE_DEBUG_CANON_LIDE70=128 scanimage > /dev/null .SH KNOWN PROBLEMS At low resolutions (75 and 150 dpi, implying high slider speeds) -the scanner misses the top one millimeter of the scan area. This can +the LiDE 70 misses the top one millimeter of the scan area. This can be remedied by shifting the document one millimeter downward, in cases where such precision matters. Note that xsane uses the 75 dpi mode for -prescans. +prescans. The problem is worse on the LiDE 600(F), where the +offset is five millimeters. .PP -It is recommended that in xsane the gamma value be set to approximately 1.5 +It is recommended that in xsane the gamma value be set to approximately 1.7 to get more realistic colors. This also wipes out some artifacts caused by the lack of real calibration. .SH "SEE ALSO"