PageRenderTime 77ms CodeModel.GetById 29ms RepoModel.GetById 0ms app.codeStats 2ms

/backend/avision.c

https://bitbucket.org/fhunleth/sane-backends-pl68xx
C | 8384 lines | 6077 code | 1415 blank | 892 comment | 1112 complexity | 5ce31aefcf994cdcea16ab127327f55a MD5 | raw file
Possible License(s): GPL-2.0, Unlicense

Large files files are truncated, but you can click here to view the full file

    

  1. /*******************************************************************************
    2. 

  2.  * SANE - Scanner Access Now Easy.
    3. 

    4. 

  4.    avision.c
    5. 

    6. 

  6.    This file is part of the SANE package.
    7. 

    8. 

  8.    This program is free software; you can redistribute it and/or
    9. 

  9.    modify it under the terms of the GNU General Public License as
    10. 

  10.    published by the Free Software Foundation; either version 2 of the
    11. 

  11.    License, or (at your option) any later version.
    12. 

    13. 

  13.    This program is distributed in the hope that it will be useful, but
    14. 

  14.    WITHOUT ANY WARRANTY; without even the implied warranty of
    15. 

  15.    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    16. 

  16.    General Public License for more details.
    17. 

    18. 

  18.    You should have received a copy of the GNU General Public License
    19. 

  19.    along with this program; if not, write to the Free Software
    20. 

  20.    Foundation, Inc., 59 Temple Place - Suite 330, Boston,
    21. 

  21.    MA 02111-1307, USA.
    22. 

    23. 

  23.    As a special exception, the authors of SANE give permission for
    24. 

  24.    additional uses of the libraries contained in this release of SANE.
    25. 

    26. 

  26.    The exception is that, if you link a SANE library with other files
    27. 

  27.    to produce an executable, this does not by itself cause the
    28. 

  28.    resulting executable to be covered by the GNU General Public
    29. 

  29.    License.  Your use of that executable is in no way restricted on
    30. 

  30.    account of linking the SANE library code into it.
    31. 

    32. 

  32.    This exception does not, however, invalidate any other reasons why
    33. 

  33.    the executable file might be covered by the GNU General Public
    34. 

  34.    License.
    35. 

    36. 

  36.    If you submit changes to SANE to the maintainers to be included in
    37. 

  37.    a subsequent release, you agree by submitting the changes that
    38. 

  38.    those changes may be distributed with this exception intact.
    39. 

    40. 

  40.    *****************************************************************************
    41. 

    42. 

  42.    This backend is based upon the Tamarack backend and adapted to the Avision
    43. 

  43.    scanners by René Rebe and Meino Cramer.
    44. 

  44.    
    45. 

  45.    This file implements a SANE backend for the Avision SCSI Scanners (like the
    46. 

  46.    AV 630 / 620 (CS) ...) and some Avision (OEM) USB scanners (like the HP 53xx,
    47. 

  47.    74xx, Minolta FS-V1 ...) or Fujitsu ScanPartner with the AVISION SCSI-2/3
    48. 

  48.    or USB command set.
    49. 

  49.    
    50. 

  50.    Copyright 1999, 2000, 2001 by
    51. 

  51.                 "René Rebe" <rene@exactcode.de>
    52. 

  52.                 "Meino Christian Cramer" <mccramer@s.netic.de>
    53. 

    54. 

  54.    Copyright 2002 by
    55. 

  55.                 "René Rebe" <rene@exactcode.de>
    56. 

  56.                 "Jose Paulo Moitinho de Almeida" <moitinho@civil.ist.utl.pt>
    57. 

  57.    
    58. 

  58.    Copyright 2003, 2004, 2005, 2006, 2007 by
    59. 

  59.                 "René Rebe" <rene@exactcode.de>
    60. 

  60.    
    61. 

  61.    Additional Contributers:
    62. 

  62.                 "Gunter Wagner"
    63. 

  63.                   (some fixes and the transparency option)
    64. 

  64.                 "Martin Jelínek" <mates@sirrah.troja.mff.cuni.cz>
    65. 

  65.                    nice attach debug output
    66. 

  66.                 "Marcin Siennicki" <m.siennicki@cloos.pl>
    67. 

  67.                    found some typos and contributed fixes for the HP 7400
    68. 

  68.                 "Frank Zago" <fzago@greshamstorage.com>
    69. 

  69.                    Mitsubishi IDs and report
    70. 

  70.                 Avision INC
    71. 

  71.                    example code to handle calibration and C5 ASIC specifics
    72. 

  72.                 "Franz Bakan" <fbakan@gmx.net>
    73. 

  73.                    OS/2 threading support
    74. 

  74.                 "Falk Rohsiepe"
    75. 

  75.                    Spelling and whitespace as well as HP5370 quirks
    76. 

  76.    
    77. 

  77.    Many additinoal special thanks to:
    78. 

  78.                 Avision INC for providing protocol documentation.
    79. 

  79.                 Avision INC for sponsoring an AV 8000S with ADF.
    80. 

  80.                 Avision Europe and BHS Binkert for sponsoring several more scanners.
    81. 

  81.                 Archivista GmbH, Switzerland, for sponsoring several features
    82. 

  82.                 Roberto Di Cosmo who sponsored a HP 5370 scanner.
    83. 

  83.                 Oliver Neukum who sponsored a HP 5300 USB scanner.
    84. 

  84.                 Matthias Wiedemann for lending his HP 7450C for some weeks.
    85. 

  85.                 Compusoft, C.A. Caracas / Venezuela for sponsoring a
    86. 

  86.                            HP 7450 scanner and so enhanced ADF support.
    87. 

  87.                 Chris Komatsu for the nice ADF scanning observartion.
    88. 

    89. 

  89.                 All the many other beta-tester and debug-log sender!
    90. 

    91. 

  91.                 Thanks to all the people and companies above. Without you
    92. 

  92.                 the Avision backend would not be in the shape it is today! ;-)
    93. 

  93.    
    94. 

  94. ********************************************************************************/
    95. 

  95. 

  96. /* SANE-FLOW-DIAGRAMM (from umax.c)
    97. 

  97.  *
    98. 

  98.  * - sane_init() : initialize backend, attach scanners(devicename,0)
    99. 

  99.  * . - sane_get_devices() : query list of scanner-devices
    100. 

  100.  * . - sane_open() : open a particular scanner-device and attach_scanner(devicename,&dev)
    101. 

  101.  * . . - sane_set_io_mode : set blocking-mode
    102. 

  102.  * . . - sane_get_select_fd : get scanner-fd
    103. 

  103.  * . . - sane_get_option_descriptor() : get option information
    104. 

  104.  * . . - sane_control_option() : change option values
    105. 

  105.  * . .
    106. 

  106.  * . . - sane_start() : start image aquisition
    107. 

  107.  * . .   - sane_get_parameters() : returns actual scan-parameters
    108. 

  108.  * . .   - sane_read() : read image-data (from pipe)
    109. 

  109.  *
    110. 

  110.  * in ADF mode this is done often:
    111. 

  111.  * . . - sane_start() : start image aquisition
    112. 

  112.  * . .   - sane_get_parameters() : returns actual scan-parameters
    113. 

  113.  * . .   - sane_read() : read image-data (from pipe)
    114. 

  114.  *
    115. 

  115.  * . . - sane_cancel() : cancel operation, kill reader_process
    116. 

  116.  *
    117. 

  117.  * . - sane_close() : close opened scanner-device, do_cancel, free buffer and handle
    118. 

  118.  * - sane_exit() : terminate use of backend, free devicename and device-struture
    119. 

  119.  */
    120. 

  120. 

  121. #include "../include/sane/config.h"
    122. 

  122. 

  123. #include <errno.h>
    124. 

  124. #include <fcntl.h>
    125. 

  125. #include <limits.h>
    126. 

  126. #include <signal.h>
    127. 

  127. #include <stdio.h>
    128. 

  128. #include <stdlib.h>
    129. 

  129. #include <string.h>
    130. 

  130. #include <sys/types.h>
    131. 

  131. #include <unistd.h>
    132. 

  132. #include <sys/time.h>
    133. 

  133. 

  134. #include <math.h>
    135. 

  135. 

  136. #define BACKEND_NAME avision
    137. 

  137. #define BACKEND_BUILD 290 /* avision backend BUILD version */
    138. 

  138. 

  139. #include <sane/sane.h>
    140. 

  140. #include <sane/sanei.h>
    141. 

  141. #include <sane/saneopts.h>
    142. 

  142. #include <sane/sanei_thread.h>
    143. 

  143. #include <sane/sanei_scsi.h>
    144. 

  144. #include <sane/sanei_usb.h>
    145. 

  145. #include <sane/sanei_config.h>
    146. 

  146. #include <sane/sanei_backend.h>
    147. 

  147. 

  148. #include <avision.h>
    149. 

  149. 

  150. /* For timeval... */
    151. 

  151. #ifdef DEBUG
    152. 

  152. #include <sys/time.h>
    153. 

  153. #endif
    154. 

  154. 

  155. /* Attention: The comments must stay as they are - they are automatially parsed
    156. 

  156.    to generate the SANE avision.desc file, as well as HTML online content! */
    157. 

  157. 

  158. /* Attention2: This device table is part of the source code and as such
    159. 

  159.    licensed under the terms of the license as listed above (GPL2+). By
    160. 

  160.    using this data you obviously create derived work! -ReneR */
    161. 

  161. 

  162. static Avision_HWEntry Avision_Device_List [] =
    163. 

  163.   {
    164. 

  164.     { "AVISION", "AV100CS",
    165. 

  165.       0, 0,
    166. 

  166.       "Avision", "AV100CS",
    167. 

  167.       0},
    168. 

  168.     /* status="untested" */
    169. 

  169.     
    170. 

  170.     { "AVISION", "AV100IIICS",
    171. 

  171.       0, 0,
    172. 

  172.       "Avision", "AV100IIICS",
    173. 

  173.       0},
    174. 

  174.     /* status="untested" */
    175. 

  175.     
    176. 

  176.     { "AVISION", "AV100S",
    177. 

  177.       0, 0,
    178. 

  178.       "Avision", "AV100S",
    179. 

  179.       0},
    180. 

  180.     /* status="untested" */
    181. 

  181. 

  182.     { NULL, NULL,
    183. 

  183.       0x0638, 0x0A27,
    184. 

  184.       "Avision", "AV120",
    185. 

  185.       AV_INT_STATUS},
    186. 

  186.     /* comment="sheetfed scanner" */
    187. 

  187.     /* status="complete" */
    188. 

  188. 

  189.     { NULL, NULL,
    190. 

  190.       0x0638, 0x0A3C,
    191. 

  191.       "Avision", "AV121",
    192. 

  192.       AV_INT_BUTTON | AV_DOES_KEEP_WINDOW | AV_DOES_KEEP_GAMMA},
    193. 

  193.     /* comment="sheetfed scanner" */
    194. 

  194.     /* status="good" */
    195. 

  195. 

  196.     { NULL, NULL,
    197. 

  197.       0x0638, 0x0A33,
    198. 

  198.       "Avision", "AV122",
    199. 

  199.       AV_INT_BUTTON | AV_2ND_LINE_INTERLACED | AV_NO_REAR | AV_SOFT_SCALE | AV_DOES_KEEP_WINDOW | AV_DOES_KEEP_GAMMA | AV_REAR_OFFSET},
    200. 

  200.     /* comment="sheetfed duplex scanner" */
    201. 

  201.     /* status="good" */
    202. 

  202.     
    203. 

  203.     { NULL, NULL,
    204. 

  204.       0x0638, 0x0A93,
    205. 

  205.       "Avision", "AV122 C2",
    206. 

  206.       AV_INT_BUTTON | AV_2ND_LINE_INTERLACED | AV_NO_REAR | AV_SOFT_SCALE | AV_DOES_KEEP_WINDOW | AV_DOES_KEEP_GAMMA | AV_REAR_OFFSET},
    207. 

  207.     /* comment="sheetfed duplex scanner" */
    208. 

  208.     /* status="good" */
    209. 

  209. 

  210.     { NULL, NULL,
    211. 

  211.       0x0638, 0x0A24,
    212. 

  212.       "Avision", "AV210",
    213. 

  213.       AV_INT_BUTTON  | AV_ACCEL_TABLE},
    214. 

  214.     /* comment="sheetfed scanner" */
    215. 

  215.     /* status="complete" */
    216. 

  216.     
    217. 

  217.     { NULL, NULL,
    218. 

  218.       0x0638, 0x0A25,
    219. 

  219.       "Avision", "AV210",
    220. 

  220.       AV_INT_BUTTON  | AV_ACCEL_TABLE | AV_NO_64BYTE_ALIGN},
    221. 

  221.     /* comment="sheetfed scanner" */
    222. 

  222.     /* status="complete" */
    223. 

  223. 

  224.     { NULL, NULL,
    225. 

  225.       0x0638, 0x0A3A,
    226. 

  226.       "Avision", "AV210C2",
    227. 

  227.       AV_INT_BUTTON | AV_GRAY_MODES},
    228. 

  228.     /* comment="sheetfed scanner" */
    229. 

  229.     /* status="complete" */
    230. 

  230. 

  231.     { NULL, NULL,
    232. 

  232.       0x0638, 0x0A2F,
    233. 

  233.       "Avision", "AV210C2-G",
    234. 

  234.       AV_INT_BUTTON | AV_GRAY_MODES},
    235. 

  235.     /* comment="sheetfed scanner" */
    236. 

  236.     /* status="complete" */
    237. 

  237. 

  238.     { NULL, NULL,
    239. 

  239.       0x0638, 0x0A3A,
    240. 

  240.       "Avision", "AV210C2",
    241. 

  241.       AV_INT_BUTTON | AV_GRAY_MODES},
    242. 

  242.     /* comment="sheetfed scanner" */
    243. 

  243.     /* status="complete" */
    244. 

  244. 

  245.     { NULL, NULL,
    246. 

  246.       0x0638, 0x0A23,
    247. 

  247.       "Avision", "AV220",
    248. 

  248.       AV_INT_BUTTON},
    249. 

  249.     /* comment="duplex! sheetfed scanner" */
    250. 

  250.     /* status="complete" */
    251. 

  251. 

  252.     { NULL, NULL,
    253. 

  253.       0x0638, 0x0A2A,
    254. 

  254.       "Avision", "AV220C2",
    255. 

  255.       AV_INT_BUTTON | AV_CANCEL_BUTTON},
    256. 

  256.     /* comment="duplex! sheetfed scanner" */
    257. 

  257.     /* status="complete" */
    258. 

  258. 

  259.     { NULL, NULL,
    260. 

  260.       0x0638, 0x0A2B,
    261. 

  261.       "Avision", "AV220D2",
    262. 

  262.       AV_INT_BUTTON | AV_CANCEL_BUTTON},
    263. 

  263.     /* comment="duplex! sheetfed scanner" */
    264. 

  264.     /* status="complete" */
    265. 

  265. 

  266.     { NULL, NULL,
    267. 

  267.       0x0638, 0x0A2C,
    268. 

  268.       "Avision", "AV220+",
    269. 

  269.       AV_INT_BUTTON | AV_CANCEL_BUTTON},
    270. 

  270.     /* comment="duplex! sheetfed scanner" */
    271. 

  271.     /* status="complete" */
    272. 

  272. 

  273.     { NULL, NULL,
    274. 

  274.       0x0638, 0x0A2D,
    275. 

  275.       "Avision", "AV220C2-G",
    276. 

  276.       AV_INT_BUTTON | AV_CANCEL_BUTTON},
    277. 

  277.     /* comment="duplex! sheetfed scanner" */
    278. 

  278.     /* status="complete" */
    279. 

  279. 

  280.     { NULL, NULL,
    281. 

  281.       0x0638, 0x0A2E,
    282. 

  282.       "Avision", "AV220C2-B",
    283. 

  283.       AV_INT_BUTTON | AV_CANCEL_BUTTON},
    284. 

  284.     /* comment="duplex! sheetfed scanner" */
    285. 

  285.     /* status="complete" */
    286. 

  286. 

  287.     { NULL, NULL,
    288. 

  288.       0x0638, 0x0A94,
    289. 

  289.       "Avision", "AV220-G",
    290. 

  290.       AV_INT_BUTTON},
    291. 

  291.     /* comment="duplex! sheetfed scanner" */
    292. 

  292.     /* status="complete" */
    293. 

  293. 

  294.     { "AVISION", "AV240SC",
    295. 

  295.       0, 0,
    296. 

  296.       "Avision", "AV240SC",
    297. 

  297.       0},
    298. 

  298.     /* status="untested" */
    299. 

  299.     
    300. 

  300.     { "AVISION", "AV260CS",
    301. 

  301.       0, 0,
    302. 

  302.       "Avision", "AV260CS",
    303. 

  303.       0},
    304. 

  304.     /* status="untested" */
    305. 

  305.     
    306. 

  306.     { "AVISION", "AV360CS",
    307. 

  307.       0, 0,
    308. 

  308.       "Avision", "AV360CS",
    309. 

  309.       0},
    310. 

  310.     /* status="untested" */
    311. 

  311.     
    312. 

  312.     { "AVISION", "AV363CS",
    313. 

  313.       0, 0,
    314. 

  314.       "Avision", "AV363CS",
    315. 

  315.       0},
    316. 

  316.     /* status="untested" */
    317. 

  317.     
    318. 

  318.     { "AVISION", "AV420CS",
    319. 

  319.       0, 0,
    320. 

  320.       "Avision", "AV420CS",
    321. 

  321.       0},
    322. 

  322.     /* status="untested" */
    323. 

  323.     
    324. 

  324.     { "AVISION", "AV6120",
    325. 

  325.       0, 0,
    326. 

  326.       "Avision", "AV6120",
    327. 

  327.       0},
    328. 

  328.     /* status="untested" */
    329. 

  329.     
    330. 

  330.     { NULL, "AV610",
    331. 

  331.       0x0638, 0x0a18,
    332. 

  332.       "Avision", "AV610",
    333. 

  333.       AV_GRAY_CALIB_BLUE | AV_ACCEL_TABLE | AV_NO_64BYTE_ALIGN | AV_INT_STATUS | AV_INT_BUTTON},
    334. 

  334.     /* status="good" */
    335. 

  335. 

  336.     { NULL, NULL,
    337. 

  337.       0x0638, 0x0a18,
    338. 

  338.       "Avision", "AV600U Plus",
    339. 

  339.       AV_GRAY_CALIB_BLUE | AV_ACCEL_TABLE | AV_NO_64BYTE_ALIGN | AV_INT_STATUS | AV_INT_BUTTON},
    340. 

  340.     /* status="good" */
    341. 

  341. 

  342.     { NULL, NULL,
    343. 

  343.       0x0638, 0x0a5e,
    344. 

  344.       "Avision", "AV610C2",
    345. 

  345.       AV_NO_BACKGROUND | AV_INT_BUTTON}, /* cancel button -> sense abort! */
    346. 

  346.     /* status="good" */
    347. 

  347. 

  348.    { NULL, NULL, 
    349. 

  349.      0x0638, 0x0a41,
    350. 

  350.      "Avision", "AM3000 Series",
    351. 

  351.       0},
    352. 

  352.     /* comment="MFD" */
    353. 

  353.     /* status="basic" */
    354. 

  354. 

  355.     { NULL, NULL,
    356. 

  356.       0x0638, 0x0a16,
    357. 

  357.       "Avision", "DS610CU Scancopier",
    358. 

  358.       AV_INT_STATUS},
    359. 

  359.     /* comment="1 pass, 600 dpi, A4" */
    360. 

  360.     /* status="good" */
    361. 

  361. 

  362.     { "AVISION", "AV620CS",
    363. 

  363.       0, 0,
    364. 

  364.       "Avision", "AV620CS",
    365. 

  365.       0},
    366. 

  366.     /* comment="1 pass, 600 dpi" */
    367. 

  367.     /* status="complete" */
    368. 

  368.     
    369. 

  369.     { "AVISION", "AV620CS Plus",
    370. 

  370.       0, 0,
    371. 

  371.       "Avision", "AV620CS Plus",
    372. 

  372.       0},
    373. 

  373.     /* comment="1 pass, 1200 dpi" */
    374. 

  374.     /* status="complete" */
    375. 

  375.     
    376. 

  376.     { "AVISION", "AV630CS",
    377. 

  377.       0, 0,
    378. 

  378.       "Avision", "AV630CS",
    379. 

  379.       0},
    380. 

  380.     /* comment="1 pass, 1200 dpi - regularly tested" */
    381. 

  381.     /* status="complete" */
    382. 

  382.     
    383. 

  383.     { "AVISION", "AV630CSL",
    384. 

  384.       0, 0,
    385. 

  385.       "Avision", "AV630CSL",
    386. 

  386.       0},
    387. 

  387.     /* comment="1 pass, 1200 dpi" */
    388. 

  388.     /* status="untested" */
    389. 

  389.     
    390. 

  390.     { "AVISION", "AV6240",
    391. 

  391.       0, 0,
    392. 

  392.       "Avision", "AV6240",
    393. 

  393.       0},
    394. 

  394.     /* comment="1 pass, ??? dpi" */
    395. 

  395.     /* status="complete" */
    396. 

  396.     
    397. 

  397.     { NULL, NULL,
    398. 

  398.       0x0638, 0x0A13,
    399. 

  399.       "Avision", "AV600U",
    400. 

  400.       AV_MULTI_CALIB_CMD | AV_ADF_BGR_ORDER_INVERT | AV_SOFT_SCALE | AV_INT_STATUS | AV_NO_BUTTON},
    401. 

  401.     /* comment="1 pass, 600 dpi" */
    402. 

  402.     /* status="good" */
    403. 

  403. 

  404.     { "AVISION", "AV660S",
    405. 

  405.       0, 0,
    406. 

  406.       "Avision", "AV660S",
    407. 

  407.       0},
    408. 

  408.     /* comment="1 pass, ??? dpi" */
    409. 

  409.     /* status="untested" */
    410. 

  410. 

  411.     { "AVISION", "AV680S",
    412. 

  412.       0, 0,
    413. 

  413.       "Avision", "AV680S",
    414. 

  414.       0},
    415. 

  415.     /* comment="1 pass, ??? dpi" */
    416. 

  416.     /* status="untested" */
    417. 

  417.     
    418. 

  418.     { "AVISION", "AV690U",
    419. 

  419.       0, 0,
    420. 

  420.       "Avision", "AV690U",
    421. 

  421.       0},
    422. 

  422.     /* comment="1 pass, 2400 dpi" */
    423. 

  423.     /* status="untested" */
    424. 

  424.     
    425. 

  425.     { "AVISION", "AV800S",
    426. 

  426.       0, 0,
    427. 

  427.       "Avision", "AV800S",
    428. 

  428.       0},
    429. 

  429.     /* comment="1 pass, ??? dpi" */
    430. 

  430.     /* status="untested" */
    431. 

  431.     
    432. 

  432.     { "AVISION", "AV810C",
    433. 

  433.       0, 0,
    434. 

  434.       "Avision", "AV810C",
    435. 

  435.       0},
    436. 

  436.     /* comment="1 pass, ??? dpi" */
    437. 

  437.     /* status="untested" */
    438. 

  438.     
    439. 

  439.     { "AVISION", "AV820",
    440. 

  440.       0, 0,
    441. 

  441.       "Avision", "AV820",
    442. 

  442.       0},
    443. 

  443.     /* comment="1 pass, ??? dpi" */
    444. 

  444.     /* status="untested" */
    445. 

  445.     
    446. 

  446.     { "AVISION", "AV820C",
    447. 

  447.       0, 0,
    448. 

  448.       "Avision", "AV820C",
    449. 

  449.       0},
    450. 

  450.     /* comment="1 pass, ??? dpi" */
    451. 

  451.     /* status="complete" */
    452. 

  452.     
    453. 

  453.     { "AVISION", "AV820C Plus",
    454. 

  454.       0, 0,
    455. 

  455.       "Avision", "AV820C Plus",
    456. 

  456.       0},
    457. 

  457.     /* comment="1 pass, ??? dpi" */
    458. 

  458.     /* status="complete" */
    459. 

  459.     
    460. 

  460.     { "AVISION", "AV830C",
    461. 

  461.       0, 0,
    462. 

  462.       "Avision", "AV830C",
    463. 

  463.       0},
    464. 

  464.     /* comment="1 pass, ??? dpi" */
    465. 

  465.     /* status="complete" */
    466. 

  466.     
    467. 

  467.     { "AVISION", "AV830C Plus",
    468. 

  468.       0, 0,
    469. 

  469.       "Avision", "AV830C Plus",
    470. 

  470.       0},
    471. 

  471.     /* comment="1 pass, ??? dpi" */
    472. 

  472.     /* status="untested" */
    473. 

  473.     
    474. 

  474.     { "AVISION", "AV880",
    475. 

  475.       0, 0,
    476. 

  476.       "Avision", "AV880",
    477. 

  477.       0},
    478. 

  478.     /* comment="1 pass, ??? dpi" */
    479. 

  479.     /* status="untested" */
    480. 

  480.     
    481. 

  481.     { "AVISION", "AV880C",
    482. 

  482.       0, 0,
    483. 

  483.       "Avision", "AV880C",
    484. 

  484.       0},
    485. 

  485.     /* comment="1 pass, ??? dpi" */
    486. 

  486.     /* status="untested" */
    487. 

  487. 

  488.     { "AVISION", "AV3200C",
    489. 

  489.       0, 0,
    490. 

  490.       "Avision", "AV3200C",
    491. 

  491.       AV_NON_INTERLACED_DUPLEX_300 | AV_FASTER_WITH_FILTER},
    492. 

  492.     /* comment="1 pass, ??? dpi" */
    493. 

  493.     /* status="complete" */
    494. 

  494. 

  495.     { "AVISION", "AV3200SU",
    496. 

  496.       0x0638, 0x0A4E,
    497. 

  497.       "Avision", "AV3200SU",
    498. 

  498.       0},
    499. 

  499.     /* comment="1 pass, ??? dpi" */
    500. 

  500.     /* status="complete" */
    501. 

  501. 

  502.     { "AVISION", "AV3730SU",
    503. 

  503.       0x0638, 0x0A4F,
    504. 

  504.       "Avision", "AV3730SU",
    505. 

  505.       0},
    506. 

  506.     /* comment="1 pass, ??? dpi" */
    507. 

  507.     /* status="complete" */
    508. 

  508. 

  509.     { "AVISION", "AV3750SU",
    510. 

  510.       0x0638, 0x0A65,
    511. 

  511.       "Avision", "AV3750SU",
    512. 

  512.       0},
    513. 

  513.     /* comment="1 pass, ??? dpi" */
    514. 

  514.     /* status="complete" */
    515. 

  515. 

  516.     { "AVISION", "AV3800C",
    517. 

  517.       0, 0,
    518. 

  518.       "Avision", "AV3800C",
    519. 

  519.       0},
    520. 

  520.     /* comment="1 pass, ??? dpi" */
    521. 

  521.     /* status="complete" */
    522. 

  522. 

  523.     { "AVISION", "AV3850SU",
    524. 

  524.       0x0638, 0x0a66,
    525. 

  525.       "Avision", "AV3850SU",
    526. 

  526.       0},
    527. 

  527.     /* comment="1 pass, ??? dpi" */
    528. 

  528.     /* status="complete" */
    529. 

  529. 

  530.     { "AVISION", "FB6000E",
    531. 

  531.       0, 0,
    532. 

  532.       "Avision", "FB6000E",
    533. 

  533.       AV_NON_INTERLACED_DUPLEX_300},
    534. 

  534.     /* comment="1 pass, 1200 dpi, A3 - duplex! - zero edge!" */
    535. 

  535.     /* status="complete" */
    536. 

  536. 

  537.     { NULL, NULL,
    538. 

  538.       0x0638, 0x0a82,
    539. 

  539.       "Avision", "FB6080E",
    540. 

  540.       AV_NON_INTERLACED_DUPLEX_300},
    541. 

  541.     /* comment="1 pass, 1200 dpi, A3 - duplex! - zero edge!" */
    542. 

  542.     /* status="complete" */
    543. 

  543. 

  544.     { NULL, NULL,
    545. 

  545.       0x0638, 0xa84,
    546. 

  546.       "Avision", "FB2080E",
    547. 

  547.       0},
    548. 

  548.     /* comment="1 pass, 600 dpi, zero-edge" ASIC 7 */
    549. 

  549.     /* status="basic" */
    550. 

  550. 

  551.     { "AVISION", "AV8000S",
    552. 

  552.       0, 0,
    553. 

  553.       "Avision", "AV8000S",
    554. 

  554.       AV_DOES_NOT_KEEP_WINDOW},
    555. 

  555.     /* comment="1 pass, 1200 dpi, A3 - regularly tested" */
    556. 

  556.     /* status="complete" */
    557. 

  557. 

  558.     { NULL, NULL,
    559. 

  559.       0x0638, 0x0a4d,
    560. 

  560.       "Avision", "AV8050U",
    561. 

  561.       AV_NON_INTERLACED_DUPLEX_300 | AV_DOES_NOT_KEEP_GAMMA},
    562. 

  562.     /* comment="1 pass, 1200 dpi, A3 - duplex!" */
    563. 

  563.     /* status="complete" */
    564. 

  564. 

  565.     { "AVISION", "AV8300",
    566. 

  566.       0x0638, 0x0A40,
    567. 

  567.       "Avision", "AV8300",
    568. 

  568.       AV_NON_INTERLACED_DUPLEX_300 | AV_DOES_NOT_KEEP_GAMMA},
    569. 

  569.     /* comment="1 pass, 1200 dpi, A3 - duplex!" */
    570. 

  570.     /* status="complete" */
    571. 

  571. 

  572.     { "AVISION", "AV8350",
    573. 

  573.       0x0638, 0x0A68,
    574. 

  574.       "Avision", "AV8350",
    575. 

  575.       AV_NON_INTERLACED_DUPLEX_300 | AV_DOES_NOT_KEEP_GAMMA},
    576. 

  576.     /* comment="1 pass, 1200 dpi, A3 - duplex!" */
    577. 

  577.     /* status="complete" */
    578. 

  578. 

  579.     { NULL, NULL,
    580. 

  580.       0x0638, 0x0A61,
    581. 

  581.       "Avision", "IT8300",
    582. 

  582.       AV_NON_INTERLACED_DUPLEX_300 | AV_ACCEL_TABLE},
    583. 

  583.     /* comment="1 pass, 1200 dpi, A3 - duplex!, LCD screen, paper sensors" */
    584. 

  584.     /* status="good" */
    585. 

  585. 

  586.     { NULL, NULL,
    587. 

  587.        0x0638, 0x0AA1,
    588. 

  588.       "Avision", "@V2500",
    589. 

  589.       0},
    590. 

  590.     /* comment="" */
    591. 

  591.     /* status="untested" */
    592. 

  592. 

  593.     { NULL, NULL,
    594. 

  594.       0x0638, 0x0A45,
    595. 

  595.       "Avision", "@V5100",
    596. 

  596.       0},
    597. 

  597.     /* comment="" */
    598. 

  598.     /* status="good" */
    599. 

  599. 

  600.     { "AVISION", "AVA3",
    601. 

  601.       0, 0,
    602. 

  602.       "Avision", "AVA3",
    603. 

  603.       AV_FORCE_A3},
    604. 

  604.     /* comment="1 pass, 600 dpi, A3" */
    605. 

  605.     /* status="basic" */
    606. 

  606. 

  607.     /* and possibly more avisions ;-) */
    608. 

  608.     
    609. 

  609.     { "HP",      "ScanJet 5300C",
    610. 

  610.       0x03f0, 0x0701,
    611. 

  611.       "Hewlett-Packard", "ScanJet 5300C",
    612. 

  612.       AV_INT_STATUS},
    613. 

  613.     /* comment="1 pass, 2400 dpi - regularly tested - some FW revisions have x-axis image scaling problems over 1200 dpi" */
    614. 

  614.     /* status="complete" */
    615. 

  615. 

  616.     { "HP",      "ScanJet 5370C",
    617. 

  617.       0x03f0, 0x0701,
    618. 

  618.       "Hewlett-Packard", "ScanJet 5370C",
    619. 

  619.       AV_MULTI_CALIB_CMD | AV_INT_STATUS},
    620. 

  620.     /* comment="1 pass, 2400 dpi - some FW revisions have x-axis image scaling problems over 1200 dpi" */
    621. 

  621.     /* status="good" */
    622. 

  622.     
    623. 

  623.     { "hp",      "scanjet 7400c",
    624. 

  624.       0x03f0, 0x0801,
    625. 

  625.       "Hewlett-Packard", "ScanJet 7400c",
    626. 

  626.       AV_LIGHT_CHECK_BOGUS | AV_NO_64BYTE_ALIGN | AV_INT_STATUS},
    627. 

  627.     /* comment="1 pass, 2400 dpi - dual USB/SCSI interface" */
    628. 

  628.     /* status="good" */
    629. 

  629.     
    630. 

  630. #ifdef FAKE_ENTRIES_FOR_DESC_GENERATION
    631. 

  631.     { "hp",      "scanjet 7450c",
    632. 

  632.       0x03f0, 0x0801,
    633. 

  633.       "Hewlett-Packard", "ScanJet 7450c",
    634. 

  634.       AV_NO_64BYTE_ALIGN | AV_INT_STATUS},
    635. 

  635.     /* comment="1 pass, 2400 dpi - dual USB/SCSI interface - regularly tested" */
    636. 

  636.     /* status="good" */
    637. 

  637.     
    638. 

  638.     { "hp",      "scanjet 7490c",
    639. 

  639.       0x03f0, 0x0801,
    640. 

  640.       "Hewlett-Packard", "ScanJet 7490c",
    641. 

  641.       AV_NO_64BYTE_ALIGN | AV_INT_STATUS},
    642. 

  642.     /* comment="1 pass, 1200 dpi - dual USB/SCSI interface" */
    643. 

  643.     /* status="good" */
    644. 

  644. 

  645. #endif
    646. 

  646.     { "HP",      "C9930A",
    647. 

  647.       0x03f0, 0x0b01,
    648. 

  648.       "Hewlett-Packard", "ScanJet 8200",
    649. 

  649.       0},
    650. 

  650.     /* comment="1 pass, 4800 (?) dpi - USB 2.0" */
    651. 

  651.     /* status="good" */
    652. 

  652. 

  653. #ifdef FAKE_ENTRIES_FOR_DESC_GENERATION
    654. 

  654.     { "HP",      "C9930A",
    655. 

  655.       0x03f0, 0x0b01,
    656. 

  656.       "Hewlett-Packard", "ScanJet 8250",
    657. 

  657.       0},
    658. 

  658.     /* comment="1 pass, 4800 (?) dpi - USB 2.0" */
    659. 

  659.     /* status="good" */
    660. 

  660. #endif
    661. 

  661. 

  662.     { "HP", "C9930A",
    663. 

  663.       0x03f0, 0x3905,
    664. 

  664.       "Hewlett-Packard", "ScanJet 8270",
    665. 

  665.       0},
    666. 

  666.     /* comment="1 pass, 4800 (?) dpi - USB 2.0" */
    667. 

  667.     /* status="good" */
    668. 

  668. 

  669. #ifdef FAKE_ENTRIES_FOR_DESC_GENERATION
    670. 

  670.     { "HP", "C9930A",
    671. 

  671.       0x03f0, 0x0b01,
    672. 

  672.       "Hewlett-Packard", "ScanJet 8290",
    673. 

  673.       0},
    674. 

  674.     /* comment="1 pass, 4800 (?) dpi - USB 2.0 and SCSI - only SCSI tested so far" */
    675. 

  675.     /* status="good" */
    676. 

  676.     
    677. 

  677. #endif 
    678. 

  678.     { "HP", "C9930A",
    679. 

  679.       0x03f0, 0x3805,
    680. 

  680.       "Hewlett-Packard", "ScanJet 8390",
    681. 

  681.       0},
    682. 

  682.     /* comment="1 pass, 4800 (?) dpi - USB 2.0" */
    683. 

  683.     /* status="good" */
    684. 

  684. 

  685.     { "Minolta", "#2882",
    686. 

  686.       0, 0,
    687. 

  687.       "Minolta", "Dimage Scan Dual I",
    688. 

  688.       AV_FORCE_FILM | AV_NO_START_SCAN}, /* not AV_FILMSCANNER (no frame control) */
    689. 

  689.     /* status="basic" */
    690. 

  690. 

  691.     { "Minolta", "#2887",
    692. 

  692.       0, 0,
    693. 

  693.       "Minolta", "Scan Multi Pro",
    694. 

  694.       AV_FORCE_FILM | AV_NO_START_SCAN}, /* AV_FILMSCANNER (rame control)? */
    695. 

  695.     /* status="untested" */
    696. 

  696.     
    697. 

  697.     { "MINOLTA", "FS-V1",
    698. 

  698.       0x0638, 0x026a,
    699. 

  699.       "Minolta", "Dimage Scan Dual II",
    700. 

  700.       AV_FILMSCANNER | AV_ONE_CALIB_CMD | AV_12_BIT_MODE},
    701. 

  701.     /* comment="1 pass, film-scanner" */
    702. 

  702.     /* status="good" */
    703. 

  703.     
    704. 

  704.     { "MINOLTA", "Elite II",
    705. 

  705.       0x0686, 0x4004,
    706. 

  706.       "Minolta", "Elite II",
    707. 

  707.       AV_FILMSCANNER | AV_ONE_CALIB_CMD},
    708. 

  708.     /* comment="1 pass, film-scanner" */
    709. 

  709.     /* status="untested" */
    710. 

  710.     
    711. 

  711.     { "MINOLTA", "FS-V3",
    712. 

  712.       0x0686, 0x400d,
    713. 

  713.       "Minolta", "Dimage Scan Dual III",
    714. 

  714.       AV_FILMSCANNER | AV_ONE_CALIB_CMD | AV_ACCEL_TABLE },
    715. 

  715.     /* comment="1 pass, film-scanner" */
    716. 

  716.     /* status="good" */
    717. 

  717. 

  718.     { "MINOLTA", "FS-V4",
    719. 

  719.       0x0686, 0x400e,
    720. 

  720.       "Minolta", "Dimage Scan Elite 5400",
    721. 

  721.       AV_FILMSCANNER | AV_ONE_CALIB_CMD | /*AV_ACCEL_TABLE |*/ AV_NO_START_SCAN},
    722. 

  722.     /* comment="1 pass, film-scanner" */
    723. 

  723.     /* status="good" */
    724. 

  724. 

  725.     { "QMS", "SC-110",
    726. 

  726.       0x0638, 0x0a15,
    727. 

  727.       "Minolta-QMS", "SC-110",
    728. 

  728.       0},
    729. 

  729.     /* comment="" */
    730. 

  730.     /* status="untested" */
    731. 

  731. 

  732.     { "QMS", "SC-215",
    733. 

  733.       0x0638, 0x0a16,
    734. 

  734.       "Minolta-QMS", "SC-215",
    735. 

  735.       0},
    736. 

  736.     /* comment="" */
    737. 

  737.     /* status="good" */
    738. 

  738.     
    739. 

  739.     { "MITSBISH", "MCA-ADFC",
    740. 

  740.       0, 0,
    741. 

  741.       "Mitsubishi", "MCA-ADFC",
    742. 

  742.       0},
    743. 

  743.     /* status="untested" */
    744. 

  744.     
    745. 

  745.     { "MITSBISH", "MCA-S1200C",
    746. 

  746.       0, 0,
    747. 

  747.       "Mitsubishi", "S1200C",
    748. 

  748.       0},
    749. 

  749.     /* status="untested" */
    750. 

  750.     
    751. 

  751.     { "MITSBISH", "MCA-S600C",
    752. 

  752.       0, 0,
    753. 

  753.       "Mitsubishi", "S600C",
    754. 

  754.       0},
    755. 

  755.     /* status="untested" */
    756. 

  756.     
    757. 

  757.     { "MITSBISH", "SS600",
    758. 

  758.       0, 0,
    759. 

  759.       "Mitsubishi", "SS600",
    760. 

  760.       0},
    761. 

  761.     /* status="good" */
    762. 

  762.     
    763. 

  763.     /* The next are all untested ... */
    764. 

  764.     
    765. 

  765.     { "FCPA", "ScanPartner",
    766. 

  766.       0, 0,
    767. 

  767.       "Fujitsu", "ScanPartner",
    768. 

  768.       AV_FUJITSU},
    769. 

  769.     /* status="untested" */
    770. 

  770. 

  771.     { "FCPA", "ScanPartner 10",
    772. 

  772.       0, 0,
    773. 

  773.       "Fujitsu", "ScanPartner 10",
    774. 

  774.       AV_FUJITSU},
    775. 

  775.     /* status="untested" */
    776. 

  776.     
    777. 

  777.     { "FCPA", "ScanPartner 10C",
    778. 

  778.       0, 0,
    779. 

  779.       "Fujitsu", "ScanPartner 10C",
    780. 

  780.       AV_FUJITSU},
    781. 

  781.     /* status="untested" */
    782. 

  782.     
    783. 

  783.     { "FCPA", "ScanPartner 15C",
    784. 

  784.       0, 0,
    785. 

  785.       "Fujitsu", "ScanPartner 15C",
    786. 

  786.       AV_FUJITSU},
    787. 

  787.     /* status="untested" */
    788. 

  788.     
    789. 

  789.     { "FCPA", "ScanPartner 300C",
    790. 

  790.       0, 0,
    791. 

  791.       "Fujitsu", "ScanPartner 300C",
    792. 

  792.       0},
    793. 

  793.     /* status="untested" */
    794. 

  794.     
    795. 

  795.     { "FCPA", "ScanPartner 600C",
    796. 

  796.       0, 0,
    797. 

  797.       "Fujitsu", "ScanPartner 600C",
    798. 

  798.       0},
    799. 

  799.     /* status="untested" */
    800. 

  800. 

  801.     { "FCPA", "ScanPartner 620C",
    802. 

  802.       0, 0,
    803. 

  803.       "Fujitsu", "ScanPartner 620C",
    804. 

  804.       0},
    805. 

  805.     /* status="good" */
    806. 

  806.     
    807. 

  807.     { "FCPA", "ScanPartner Jr",
    808. 

  808.       0, 0,
    809. 

  809.       "Fujitsu", "ScanPartner Jr",
    810. 

  810.       0},
    811. 

  811.     /* status="untested" */
    812. 

  812.     
    813. 

  813.     { "FCPA", "ScanStation",
    814. 

  814.       0, 0,
    815. 

  815.       "Fujitsu", "ScanStation",
    816. 

  816.       0},
    817. 

  817.     /* status="untested" */
    818. 

  818. 

  819.     { NULL, NULL,
    820. 

  820.       0x04c5, 0x1029,
    821. 

  821.       "Fujitsu", "fi-4010CU",
    822. 

  822.       0},
    823. 

  823.     /* status="untested" */
    824. 

  824. 

  825.     { NULL, NULL,
    826. 

  826.       0x040a, 0x6001,
    827. 

  827.       "Kodak", "i30",
    828. 

  828.       AV_INT_BUTTON},
    829. 

  829.     /* status="untested" */
    830. 

  830. 

  831.     { NULL, NULL,
    832. 

  832.       0x040a, 0x6002,
    833. 

  833.       "Kodak", "i40",
    834. 

  834.       AV_INT_BUTTON},
    835. 

  835.     /* status="basic" */
    836. 

  836.     
    837. 

  837.     { NULL, NULL,
    838. 

  838.       0x040a, 0x6003,
    839. 

  839.       "Kodak", "i50",
    840. 

  840.       AV_INT_BUTTON},
    841. 

  841.     /* status="untested" */
    842. 

  842.     
    843. 

  843.     { NULL, NULL,
    844. 

  844.       0x040a, 0x6003,
    845. 

  845.       "Kodak", "i55",
    846. 

  846.       AV_INT_BUTTON},
    847. 

  847.     /* status="untested" */
    848. 

  848.     
    849. 

  849.     { NULL, NULL,
    850. 

  850.       0x040a, 0x6004,
    851. 

  851.       "Kodak", "i60",
    852. 

  852.       AV_INT_BUTTON},
    853. 

  853.     /* status="untested" */
    854. 

  854.     
    855. 

  855.     { NULL, NULL,
    856. 

  856.       0x040a, 0x6004,
    857. 

  857.       "Kodak", "i65",
    858. 

  858.       AV_INT_BUTTON},
    859. 

  859.     /* status="untested" */
    860. 

  860.     
    861. 

  861.     { NULL, NULL,
    862. 

  862.       0x040a, 0x6005,
    863. 

  863.       "Kodak", "i80",
    864. 

  864.       AV_INT_BUTTON},
    865. 

  865.      /* status="good" */ 
    866. 

  866.     
    867. 

  867.     { "iVina", "1200U",
    868. 

  868.       0x0638, 0x0268,
    869. 

  869.       "iVina", "1200U",
    870. 

  870.       0},
    871. 

  871.     /* status="untested" */
    872. 

  872.     
    873. 

  873.     { NULL, NULL,
    874. 

  874.       0x04a7, 0x0424,
    875. 

  875.       "Visioneer", "Strobe XP 450",
    876. 

  876.       AV_INT_BUTTON  | AV_ACCEL_TABLE},
    877. 

  877.       /* comment="sheetfed scanner" */
    878. 

  878.       /* status="complete" */
    879. 

  879. 

  880.     { NULL, NULL,
    881. 

  881.       0x04a7, 0x0491,
    882. 

  882.       "Visioneer", "Strobe XP 450-G",
    883. 

  883.       AV_INT_BUTTON  | AV_ACCEL_TABLE},
    884. 

  884.       /* comment="sheetfed scanner" */
    885. 

  885.       /* status="complete" */
    886. 

  886.     
    887. 

  887.     { NULL, NULL,
    888. 

  888.       0x04a7, 0x0479,
    889. 

  889.       "Visioneer", "Strobe XP 470",
    890. 

  890.       AV_INT_BUTTON  | AV_ACCEL_TABLE},
    891. 

  891.       /* comment="sheetfed scanner" */
    892. 

  892.       /* status="complete" */
    893. 

  893. 

  894.     { NULL, NULL,
    895. 

  895.       0x04a7, 0x048F,
    896. 

  896.       "Visioneer", "Strobe XP 470-G",
    897. 

  897.       AV_INT_BUTTON  | AV_ACCEL_TABLE},
    898. 

  898.       /* comment="sheetfed scanner" */
    899. 

  899.       /* status="complete" */
    900. 

  900.     
    901. 

  901.     { NULL, NULL,
    902. 

  902.       0x04a7, 0x0420,
    903. 

  903.       "Visioneer", "9320",
    904. 

  904.       0},
    905. 

  905.       /* comment="sheetfed scanner" */
    906. 

  906.       /* status="complete" */
    907. 

  907. 

  908.     { NULL, NULL,
    909. 

  909.       0x04a7, 0x0421,
    910. 

  910.       "Visioneer", "9450",
    911. 

  911.       0},
    912. 

  912.       /* comment="sheetfed scanner" */
    913. 

  913.       /* status="complete" */
    914. 

  914. 

  915.     { NULL, NULL,
    916. 

  916.       0x04a7, 0x047A,
    917. 

  917.       "Visioneer", "9450-G",
    918. 

  918.       0},
    919. 

  919.       /* comment="sheetfed scanner" */
    920. 

  920.       /* status="complete" */
    921. 

  921. 

  922.     { NULL, NULL,
    923. 

  923.       0x04a7, 0x0422,
    924. 

  924.       "Visioneer", "9550",
    925. 

  925.       0},
    926. 

  926.       /* comment="sheetfed scanner" */
    927. 

  927.       /* status="complete" */
    928. 

  928. 

  929.     { NULL, NULL,
    930. 

  930.       0x04a7, 0x0390,
    931. 

  931.       "Visioneer", "9650",
    932. 

  932.       0},
    933. 

  933.       /* comment="sheetfed scanner" */
    934. 

  934.       /* status="complete" */
    935. 

  935. 

  936.     { NULL, NULL,
    937. 

  937.       0x04a7, 0x047B,
    938. 

  938.       "Visioneer", "9650-G",
    939. 

  939.       0},
    940. 

  940.       /* comment="sheetfed scanner" */
    941. 

  941.       /* status="complete" */
    942. 

  942.     
    943. 

  943.     { NULL, NULL,
    944. 

  944.       0x04a7, 0x0423,
    945. 

  945.       "Visioneer", "9750",
    946. 

  946.       AV_INT_BUTTON},
    947. 

  947.       /* comment="sheetfed scanner" */
    948. 

  948.       /* status="complete" */
    949. 

  949. 

  950.     { NULL, NULL,
    951. 

  951.       0x04a7, 0x0493,
    952. 

  952.       "Visioneer", "9750-G",
    953. 

  953.       AV_INT_BUTTON},
    954. 

  954.       /* comment="sheetfed scanner" */
    955. 

  955.       /* status="complete" */
    956. 

  956. 

  957.     { NULL, NULL,
    958. 

  958.       0x04a7, 0x0497,
    959. 

  959.       "Visioneer", "Patriot 430",
    960. 

  960.       AV_INT_BUTTON | AV_2ND_LINE_INTERLACED | AV_NO_REAR | AV_SOFT_SCALE | AV_DOES_KEEP_WINDOW | AV_DOES_KEEP_GAMMA | AV_REAR_OFFSET},
    961. 

  961.       /* comment="sheetfed scanner" */
    962. 

  962.       /* status="complete" */
    963. 

  963. 

  964.     { NULL, NULL,
    965. 

  965.       0x04a7, 0x048F,
    966. 

  966.       "Visioneer", "Patriot 470",
    967. 

  967.       AV_INT_BUTTON},
    968. 

  968.       /* comment="sheetfed scanner" */
    969. 

  969.       /* status="complete" */
    970. 

  970. 

  971.     { NULL, NULL,
    972. 

  972.       0x04a7, 0x0498,
    973. 

  973.       "Visioneer", "Patriot 680",
    974. 

  974.       AV_INT_BUTTON},
    975. 

  975.       /* comment="sheetfed scanner" */
    976. 

  976.       /* status="complete" */
    977. 

  977. 

  978.     { NULL, NULL,
    979. 

  979.       0x04a7, 0x0499,
    980. 

  980.       "Visioneer", "Patriot 780",
    981. 

  981.       AV_INT_BUTTON},
    982. 

  982.       /* comment="sheetfed scanner" */
    983. 

  983.       /* status="complete" */
    984. 

  984.     
    985. 

  985.     { NULL, NULL,
    986. 

  986.       0x04a7, 0x049C,
    987. 

  987.       "Xerox", "DocuMate150",
    988. 

  988.       AV_INT_BUTTON | AV_SOFT_SCALE | AV_DOES_KEEP_WINDOW | AV_DOES_KEEP_GAMMA | AV_BACKGROUND_QUIRK},
    989. 

  989.     /* status="good" */
    990. 

  990. 

  991.     { NULL, NULL,
    992. 

  992.       0x04a7, 0x0477,
    993. 

  993.       "Xerox", "DocuMate152",
    994. 

  994.       AV_INT_BUTTON | AV_2ND_LINE_INTERLACED | AV_NO_REAR | AV_SOFT_SCALE | AV_DOES_KEEP_WINDOW | AV_DOES_KEEP_GAMMA | AV_REAR_OFFSET | AV_BACKGROUND_QUIRK},
    995. 

  995.     /* status="good" */
    996. 

  996. 

  997.     { NULL, NULL,
    998. 

  998.       0x04a7, 0x049D,
    999. 

  999.       "Xerox", "DocuMate162",
    1000. 

  1000.       AV_INT_BUTTON | AV_2ND_LINE_INTERLACED | AV_NO_REAR | AV_SOFT_SCALE | AV_DOES_KEEP_WINDOW | AV_DOES_KEEP_GAMMA | AV_REAR_OFFSET | AV_BACKGROUND_QUIRK},
    1001. 

  1001.     /* status="good" */
    1002. 

  1002. 

  1003.     { NULL, NULL,
    1004. 

  1004.       0x04a7, 0x0448,
    1005. 

  1005.       "Xerox", "DocuMate250",
    1006. 

  1006.       AV_INT_BUTTON},
    1007. 

  1007.     /* status="good" */
    1008. 

  1008. 

  1009.     { NULL, NULL,
    1010. 

  1010.       0x04a7, 0x0490,
    1011. 

  1011.       "Xerox", "DocuMate250-G",
    1012. 

  1012.       AV_INT_BUTTON},
    1013. 

  1013.     /* status="good" */
    1014. 

  1014.     
    1015. 

  1015.     { NULL, NULL,
    1016. 

  1016.       0x04a7, 0x0449,
    1017. 

  1017.       "Xerox", "DocuMate252",
    1018. 

  1018.       AV_INT_BUTTON},
    1019. 

  1019.     /* status="good" */
    1020. 

  1020. 

  1021.     { NULL, NULL,
    1022. 

  1022.       0x04a7, 0x048C,
    1023. 

  1023.       "Xerox", "DocuMate252-G",
    1024. 

  1024.       AV_INT_BUTTON},
    1025. 

  1025.     /* status="good" */
    1026. 

  1026.     
    1027. 

  1027.     { NULL, NULL,
    1028. 

  1028.       0x04a7, 0x044c,
    1029. 

  1029.       "Xerox", "DocuMate262",
    1030. 

  1030.       AV_INT_BUTTON},
    1031. 

  1031.     /* status="good" */
    1032. 

  1032. 

  1033.     { NULL, NULL,
    1034. 

  1034.       0x04a7, 0x048D,
    1035. 

  1035.       "Xerox", "DocuMate262-G",
    1036. 

  1036.       AV_INT_BUTTON},
    1037. 

  1037.     /* status="good" */
    1038. 

  1038.     
    1039. 

  1039.     { NULL, NULL,
    1040. 

  1040.       0x04a7, 0x0475,
    1041. 

  1041.       "Xerox", "DocuMate272",
    1042. 

  1042.       AV_INT_BUTTON},
    1043. 

  1043.     /* status="untested" */
    1044. 

  1044. 

  1045.     { NULL, NULL,
    1046. 

  1046.       0x04a7, 0x048E,
    1047. 

  1047.       "Xerox", "DocuMate272-G",
    1048. 

  1048.       AV_INT_BUTTON},
    1049. 

  1049.     /* status="untested" */
    1050. 

  1050.     
    1051. 

  1051.     { NULL, NULL,
    1052. 

  1052.       0x04a7, 0x0446,
    1053. 

  1053.       "Xerox", "DocuMate510",
    1054. 

  1054.       AV_INT_BUTTON},
    1055. 

  1055.     /* status="untested" */
    1056. 

  1056. 

  1057.     { NULL, NULL,
    1058. 

  1058.       0x04a7, 0x0495,
    1059. 

  1059.       "Xerox", "DocuMate512",
    1060. 

  1060.       AV_INT_BUTTON},
    1061. 

  1061.     /* status="untested" */
    1062. 

  1062. 

  1063.     { NULL, NULL,
    1064. 

  1064.       0x04a7, 0x047c,
    1065. 

  1065.       "Xerox", "DocuMate510-G",
    1066. 

  1066.       AV_INT_BUTTON},
    1067. 

  1067.     /* status="untested" */
    1068. 

  1068. 

  1069.     { NULL, NULL,
    1070. 

  1070.       0x04a7, 0x0447,
    1071. 

  1071.       "Xerox", "DocuMate520",
    1072. 

  1072.       AV_INT_BUTTON},
    1073. 

  1073.     /* status="untested" */
    1074. 

  1074. 

  1075.     { NULL, NULL,
    1076. 

  1076.       0x04a7, 0x0492,
    1077. 

  1077.       "Xerox", "DocuMate520-G",
    1078. 

  1078.       AV_INT_BUTTON},
    1079. 

  1079.     /* status="untested" */
    1080. 

  1080. 

  1081.     { NULL, NULL,
    1082. 

  1082.       0x04a7, 0x0498,
    1083. 

  1083.       "Xerox", "DocuMate632",
    1084. 

  1084.       AV_INT_BUTTON},
    1085. 

  1085.     /* status="untested" */
    1086. 

  1086. 

  1087.     { NULL, NULL,
    1088. 

  1088.       0x04a7, 0x0478,
    1089. 

  1089.       "Xerox", "DocuMate752",
    1090. 

  1090.       AV_INT_BUTTON},
    1091. 

  1091.     /* status="untested" */
    1092. 

  1092. 

  1093.     { NULL, NULL,
    1094. 

  1094.       0x04a7, 0x049A,
    1095. 

  1095.       "Xerox", "DocuMate752",
    1096. 

  1096.       AV_INT_BUTTON},
    1097. 

  1097.     /* status="untested" */
    1098. 

  1098. 

  1099.     { NULL, NULL,
    1100. 

  1100.       0x0638, 0x0a16,
    1101. 

  1101.       "OKI", "S700 Scancopier",
    1102. 

  1102.       0},
    1103. 

  1103.     /* comment="1 pass, 600 dpi, A4" */
    1104. 

  1104.     /* status="good" */
    1105. 

  1105. 

  1106.     { "B+H", "2000F",
    1107. 

  1107.       0, 0,
    1108. 

  1108.       "Bell+Howell", "2000F",
    1109. 

  1109.       0},
    1110. 

  1110.     /* comment="1 pass, ??? dpi, A4" */
    1111. 

  1111.     /* status="basic" */
    1112. 

  1112. 

  1113.     { NULL, NULL,
    1114. 

  1114.       0x0482, 0x0335,
    1115. 

  1115.       "Kyocera", "FS-1016MFP",
    1116. 

  1116.       0},
    1117. 

  1117.     /* comment="1 pass, ??? dpi, A4" */
    1118. 

  1118.     /* status="untested" */
    1119. 

  1119. 

  1120.     /* More IDs from the Avision dll:
    1121. 

  1121.        ArtiScan ProA3
    1122. 

  1122.        FB1065
    1123. 

  1123.        FB1265
    1124. 

  1124.        PHI860S
    1125. 

  1125.        PSDC SCSI
    1126. 

  1126.        SCSI Scan 19200
    1127. 

  1127.        V6240 */
    1128. 

  1128. 

  1129.     /* Possibly:
    1130. 

  1130. Lexmark 4600 MFP Option MFP Options 
    1131. 

  1131. Lexmark 4600 MFP Option (C772n) MFP Options   
    1132. 

  1132. Lexmark X215
    1133. 

  1133. Lexmark Optra Image X242 
    1134. 

  1134. Lexmark X443
    1135. 

  1135. Lexmark 3100
    1136. 

  1136. Lexmark 3200 
    1137. 

  1137. Lexmark X340 MFP Multifunction   
    1138. 

  1138. Lexmark X342n MFP Multifunction   
    1139. 

  1139. Lexmark X522
    1140. 

  1140. Lexmark X630
    1141. 

  1141. Lexmark X632E
    1142. 

  1142. Lexmark X642e MFP Multifunction   
    1143. 

  1143. Lexmark X644e MFP Multifunction   
    1144. 

  1144. Lexmark X646dte MFP Multifunction   
    1145. 

  1145. Lexmark X646e MFP Multifunction   
    1146. 

  1146. Lexmark X646ef MFP Multifunction   
    1147. 

  1147. Lexmark X772e Multifunction   
    1148. 

  1148. Lexmark X850e MFP Multifunction   
    1149. 

  1149. Lexmark X852e MFP Multifunction   
    1150. 

  1150. Lexmark X854e MFP Multifunction   
    1151. 

  1151. Lexmark X4500 MFP
    1152. 

  1152.      */
    1153. 

  1153.     
    1154. 

  1154.     /* last entry detection */
    1155. 

  1155.     { NULL, NULL,
    1156. 

  1156.       0, 0,
    1157. 

  1157.       NULL, NULL,
    1158. 

  1158.       0} 
    1159. 

  1159.   };
    1160. 

  1160. 

  1161. #if 0
    1162. 

  1162.   struct timeval tv;
    1163. 

  1163.   #define TIMING(txt) gettimeofday (&tv, NULL);				\
    1164. 

  1164.   DBG (4, "%lu: " txt "\n", tv.tv_sec * 1000000 + tv.tv_usec)
    1165. 

  1165. #else
    1166. 

  1166.   #define TIMING(txt)
    1167. 

  1167. #endif
    1168. 

  1168. 

  1169. /* used when scanner returns invalid range fields ... */
    1170. 

  1170. #define A4_X_RANGE 8.5 /* or 8.25 ? */
    1171. 

  1171. #define A4_Y_RANGE 11.8
    1172. 

  1172. #define A3_X_RANGE 11.8
    1173. 

  1173. #define A3_Y_RANGE 16.5 /* or 17 ? */
    1174. 

  1174. #define FILM_X_RANGE 1.0 /* really ? */
    1175. 

  1175. #define FILM_Y_RANGE 1.0
    1176. 

  1176. #define SHEETFEED_Y_RANGE 14.0
    1177. 

  1177. 

  1178. #define AVISION_CONFIG_FILE "avision.conf"
    1179. 

  1179. 

  1180. #define STD_INQUIRY_SIZE 0x24
    1181. 

  1181. #define AVISION_INQUIRY_SIZE_V1 0x60
    1182. 

  1182. #define AVISION_INQUIRY_SIZE_V2 0x88
    1183. 

  1183. #define AVISION_INQUIRY_SIZE_MAX AVISION_INQUIRY_SIZE_V2
    1184. 

  1184. 

  1185. #define MM_PER_INCH 25.4
    1186. 

  1186. 

  1187. #define AVISION_BASE_RES 300
    1188. 

  1188. 

  1189. /* calibration (shading) defines */
    1190. 

  1190. 

  1191. #define INVALID_WHITE_SHADING   0x0000
    1192. 

  1192. #define DEFAULT_WHITE_SHADING   0xFFF0
    1193. 

  1193. 

  1194. #define MAX_WHITE_SHADING       0xFFFF
    1195. 

  1195. /* originally the WHITE_MAP_RANGE was 0x4000 - but this always
    1196. 

  1196.  * resulted in slightly too dark images - thus I have choosen
    1197. 

  1197.  * 0x4FFF ... */
    1198. 

  1198. #define WHITE_MAP_RANGE         0x4FFF
    1199. 

  1199. 

  1200. #define INVALID_DARK_SHADING    0xFFFF
    1201. 

  1201. #define DEFAULT_DARK_SHADING    0x0000
    1202. 

  1202. 

  1203. #define read_constrains(s,var) {\
    1204. 

  1204. 	if (s->hw->hw->feature_type & AV_NO_64BYTE_ALIGN) {\
    1205. 

  1205. 		if (var % 64 == 0) var /= 2;\
    1206. 

  1206. 		if (var % 64 == 0) var += 2;\
    1207. 

  1207. 	}\
    1208. 

  1208. }\
    1209. 

  1209. 

  1210. static int num_devices;
    1211. 

  1211. static Avision_Device* first_dev;
    1212. 

  1212. static Avision_Scanner* first_handle;
    1213. 

  1213. static const SANE_Device** devlist = 0;
    1214. 

  1214. 

  1215. /* this is a bit hacky to get extra information in the attach callback */
    1216. 

  1216. static Avision_HWEntry* attaching_hw = 0;
    1217. 

  1217. 

  1218. /* disable the usage of a custom gamma-table */
    1219. 

  1219. static SANE_Bool disable_gamma_table = SANE_FALSE;
    1220. 

  1220. 

  1221. /* disable the calibration */
    1222. 

  1222. static SANE_Bool disable_calibration = SANE_FALSE;
    1223. 

  1223. static SANE_Bool force_calibration = SANE_FALSE;
    1224. 

  1224. 

  1225. /* force scanable areas to ISO(DIN) A4/A3 */
    1226. 

  1226. static SANE_Bool force_a4 = SANE_FALSE;
    1227. 

  1227. static SANE_Bool force_a3 = SANE_FALSE;
    1228. 

  1228. 

  1229. /* hardware resolutions to interpolate from */
    1230. 

  1230. static const int  hw_res_list_c5[] =
    1231. 

  1231.   {
    1232. 

  1232.     /* tested on AV600U */
    1233. 

  1233.     75, 150, 300, 600, 1200, 2400, 4800, /* ... */ 0
    1234. 

  1234.   };
    1235. 

  1235. static const int  hw_res_list_generic[] =
    1236. 

  1236.   {
    1237. 

  1237.     50, /* slower than 150 on the AV122/DM152, left for USB 1 host's preview */
    1238. 

  1238.     75, /* slower than 150 on the AV122/DM152, left for USB 1 host's */
    1239. 

  1239.     150, 200, 300,
    1240. 

  1240.     /* 400,*/ /* AV122 simplex y-scaling and duplex interlacing corrupt */
    1241. 

  1241.     600, 1200, 2400, 4800,
    1242. 

  1242.     /* ... */
    1243. 

  1243.     0
    1244. 

  1244.   };
    1245. 

  1245. 

  1246. static SANE_Bool static_calib_list[3] =
    1247. 

  1247.   {
    1248. 

  1248.     SANE_FALSE, SANE_FALSE, SANE_FALSE
    1249. 

  1249.   };
    1250. 

  1250. 

  1251. static const SANE_Range u8_range =
    1252. 

  1252.   {
    1253. 

  1253.     0, /* minimum */
    1254. 

  1254.     255, /* maximum */
    1255. 

  1255.     0 /* quantization */
    1256. 

  1256.   };
    1257. 

  1257. 

  1258. static const SANE_Range percentage_range =
    1259. 

  1259.   {
    1260. 

  1260.     SANE_FIX (-100), /* minimum */
    1261. 

  1261.     SANE_FIX (100), /* maximum */
    1262. 

  1262.     SANE_FIX (1) /* quantization */
    1263. 

  1263.   };
    1264. 

  1264. 

  1265. static const SANE_Range abs_percentage_range =
    1266. 

  1266.   {
    1267. 

  1267.     SANE_FIX (0), /* minimum */
    1268. 

  1268.     SANE_FIX (100), /* maximum */
    1269. 

  1269.     SANE_FIX (1) /* quantization */
    1270. 

  1270.   };
    1271. 

  1271. 

  1272. static const SANE_Range exposure_range =
    1273. 

  1273.   {
    1274. 

  1274.     0, /* minimum */
    1275. 

  1275.     1000, /* maximum */
    1276. 

  1276.     1 /* quantization */
    1277. 

  1277.   };
    1278. 

  1278. 

  1279. static const SANE_Range overscan_range =
    1280. 

  1280.   {
    1281. 

  1281.     SANE_FIX (0), /* minimum */
    1282. 

  1282.     SANE_FIX (4), /* maximum */ /* 4mm, meassured on AV122, AV220C2, i40 */
    1283. 

  1283.     0 /* quantization */
    1284. 

  1284.   };
    1285. 

  1285. 

  1286. /* The 0x32 is a random guess based on USB logs. Might need a
    1287. 

  1287.    per-device value in the future - 0x32 was tested on the AV122,
    1288. 

  1288.    DM152, AV220. */
    1289. 

  1289. static const SANE_Range background_range =
    1290. 

  1290.   {
    1291. 

  1291.     0, /* minimum */
    1292. 

  1292.     0x32, /* maximum */
    1293. 

  1293.     0 /* quantization */
    1294. 

  1294.   };
    1295. 

  1295. 

  1296. static const uint8_t test_unit_ready[] =
    1297. 

  1297.   {
    1298. 

  1298.     AVISION_SCSI_TEST_UNIT_READY, 0x00, 0x00, 0x00, 0x00, 0x00
    1299. 

  1299.   };
    1300. 

  1300. 

  1301. static const uint8_t get_status[] =
    1302. 

  1302.   {
    1303. 

  1303.     AVISION_SCSI_GET_DATA_STATUS, 0x00, 0x00, 0x00, 0x00, 0x00, 
    1304. 

  1304.     0x00, 0x00, 0x0c, 0x00
    1305. 

  1305.   };
    1306. 

  1306. 

  1307. static size_t
    1308. 

  1308. max_string_size (const SANE_String_Const strings[])
    1309. 

  1309. {
    1310. 

  1310.   size_t size, max_size = 0;
    1311. 

  1311.   int i;
    1312. 

  1312.   
    1313. 

  1313.   DBG (3, "max_string_size:\n");
    1314. 

  1314.   
    1315. 

  1315.   for (i = 0; strings[i]; ++ i) {
    1316. 

  1316.     size = strlen (strings[i]) + 1;
    1317. 

  1317.     if (size > max_size)
    1318. 

  1318.       max_size = size;
    1319. 

  1319.   }
    1320. 

  1320.   return max_size;
    1321. 

  1321. }
    1322. 

  1322. 

  1323. static SANE_Status
    1324. 

  1324. constrain_value (Avision_Scanner* s, SANE_Int option, void* value,
    1325. 

  1325. 		 SANE_Int* info)
    1326. 

  1326. {
    1327. 

  1327.   DBG (3, "constrain_value:\n");
    1328. 

  1328.   return sanei_constrain_value (s->opt + option, value, info);
    1329. 

  1329. }
    1330. 

  1330. 

  1331. static void debug_print_raw (int dbg_level, char* info, const uint8_t* data,
    1332. 

  1332. 			     size_t count)
    1333. 

  1333. {
    1334. 

  1334.   size_t i;
    1335. 

  1335.   
    1336. 

  1336.   DBG (dbg_level, info);
    1337. 

  1337.   for (i = 0; i < count; ++ i) {
    1338. 

  1338.     DBG (dbg_level, "  [%lu] %1d%1d%1d%1d%1d%1d%1d%1db %3oo %3dd %2xx\n",
    1339. 

  1339. 	 (u_long) i,
    1340. 

  1340. 	 BIT(data[i],7), BIT(data[i],6), BIT(data[i],5), BIT(data[i],4),
    1341. 

  1341. 	 BIT(data[i],3), BIT(data[i],2), BIT(data[i],1), BIT(data[i],0),
    1342. 

  1342. 	 data[i], data[i], data[i]);
    1343. 

  1343.   }
    1344. 

  1344. }
    1345. 

  1345. 

  1346. static void debug_print_hex_raw (int dbg_level, char* info, const uint8_t* data,
    1347. 

  1347. 				 size_t count)
    1348. 

  1348. {
    1349. 

  1349.   int address = 0;
    1350. 

  1350.   char text [16*3+1];
    1351. 

  1351. 

  1352.   DBG (dbg_level, info);
    1353. 

  1353.   while (count) {
    1354. 

  1354.     char* t = text;
    1355. 

  1355.     int i = 0;
    1356. 

  1356.     while (i < 16 && count) {
    1357. 

  1357.       t += sprintf (t, "%02x ", *data++);
    1358. 

  1358.       count--; i++;
    1359. 

  1359.     }
    1360. 

  1360.     *--t = 0;
    1361. 

  1361.     
    1362. 

  1362.     DBG (dbg_level, "  [%08x] %s\n", address, text);
    1363. 

  1363.     address += 16;
    1364. 

  1364.   }
    1365. 

  1365. }
    1366. 

  1366. 

  1367. static void debug_print_nvram_data (int dbg_level, char* func,
    1368. 

  1368. 				    nvram_data* nvram)
    1369. 

  1369. {
    1370. 

  1370.   DBG (dbg_level, "%s: pad scans:             %d\n",
    1371. 

  1371.        func, get_quad(nvram->pad_scans));
    1372. 

  1372.   DBG (dbg_level, "%s: ADF simplex scans:     %d\n",
    1373. 

  1373.        func, get_quad(nvram->adf_simplex_scans));
    1374. 

  1374.   DBG (dbg_level, "%s: ADF duplex scans:      %d\n",
    1375. 

  1375.        func, get_quad(nvram->adf_duplex_scans));
    1376. 

  1376.   DBG (dbg_level, "%s: flatbed scans:         %d\n",
    1377. 

  1377.        func, get_quad(nvram->flatbed_scans));
    1378. 

  1378.   
    1379. 

  1379.   DBG (dbg_level, "%s: flatbed leading edge:  %d\n",
    1380. 

  1380.        func, (int16_t)get_double(nvram->flatbed_leading_edge));
    1381. 

  1381.   DBG (dbg_level, "%s: flatbed side edge:     %d\n",
    1382. 

  1382.        func, (int16_t)get_double(nvram->flatbed_side_edge));
    1383. 

  1383.   DBG (dbg_level, "%s: ADF leading edge:      %d\n",
    1384. 

  1384.        func, (int16_t)get_double(nvram->adf_leading_edge));
    1385. 

  1385.   DBG (dbg_level, "%s: ADF side edge:         %d\n",
    1386. 

  1386.        func, (int16_t)get_double(nvram->adf_side_edge));
    1387. 

  1387.   DBG (dbg_level, "%s: ADF rear leading edge: %d\n",
    1388. 

  1388.        func, (int16_t)get_double(nvram->adf_rear_leading_edge));
    1389. 

  1389.   DBG (dbg_level, "%s: ADF rear side edge:    %d\n",
    1390. 

  1390.        func, (int16_t)get_double(nvram->adf_rear_side_edge));
    1391. 

  1391.   
    1392. 

  1392.   DBG (dbg_level, "%s: born month:            %d\n",
    1393. 

  1393.        func, get_double(nvram->born_month));
    1394. 

  1394.   DBG (dbg_level, "%s: born day:              %d\n",
    1395. 

  1395.        func, get_double(nvram->born_day));
    1396. 

  1396.   DBG (dbg_level, "%s: born year:             %d\n",
    1397. 

  1397.        func, get_double(nvram->born_year));
    1398. 

  1398. 

  1399.   DBG (dbg_level, "%s: first scan month:      %d\n",
    1400. 

  1400.        func, get_double(nvram->first_scan_month));
    1401. 

  1401.   DBG (dbg_level, "%s: first scan day:        %d\n",
    1402. 

  1402.        func, get_double(nvram->first_scan_day));
    1403. 

  1403.   DBG (dbg_level, "%s: first scan year:       %d\n",
    1404. 

  1404.        func, get_double(nvram->first_scan_year));
    1405. 

  1405.   
    1406. 

  1406. 

  1407.   DBG (dbg_level, "%s: vert. magnification:   %d\n",
    1408. 

  1408.        func, get_double(nvram->vertical_magnification));
    1409. 

  1409.   DBG (dbg_level, "%s: horiz. magnification:  %d\n",
    1410. 

  1410.        func, get_double(nvram->horizontal_magnification));
    1411. 

  1411. 

  1412.   DBG (dbg_level, "%s: CCD type:              %d\n",
    1413. 

  1413.        func, nvram->ccd_type);
    1414. 

  1414.   DBG (dbg_level, "%s: scan speed:            %d\n",
    1415. 

  1415.        func, nvram->scan_speed);
    1416. 

  1416.   
    1417. 

  1417.   DBG (dbg_level, "%s: serial:                '%.24s'\n", /* 24 chars max */
    1418. 

  1418.        func, nvram->serial);
    1419. 

  1419.   
    1420. 

  1420.   DBG (dbg_level, "%s: power saving time:     %d\n",
    1421. 

  1421.        func, get_double(nvram->power_saving_time));
    1422. 

  1422. 

  1423.   DBG (dbg_level, "%s: auto feed:             %d\n",
    1424. 

  1424.        func, nvram->auto_feed);
    1425. 

  1425. 

  1426.   DBG (dbg_level, "%s: roller count:          %d\n",
    1427. 

  1427.        func, get_quad(nvram->roller_count));
    1428. 

  1428.   DBG (dbg_level, "%s: multifeed count:       %d\n",
    1429. 

  1429.        func, get_quad(nvram->multifeed_count));
    1430. 

  1430.   DBG (dbg_level, "%s: jam count:             %d\n",
    1431. 

  1431.        func, get_quad(nvram->jam_count));
    1432. 

  1432. 

  1433.   DBG (dbg_level, "%s: identify info:         '%.16s'\n", /* 16 chars max */
    1434. 

  1434.        func, nvram->identify_info);
    1435. 

  1435.   DBG (dbg_level, "%s: formal_name:           '%.16s'\n", /* 16 chars max */
    1436. 

  1436.        func, nvram->formal_name);
    1437. 

  1437. }
    1438. 

  1438. 

  1439. static void debug_print_avdimen (int dbg_level, char* func,
    1440. 

  1440. 				 Avision_Dimensions* avdimen)
    1441. 

  1441. {
    1442. 

  1442.   DBG (dbg_level, "%s: hw_xres: %d, hw_yres: %d, line_difference: %d\n",
    1443. 

  1443.        func, avdimen->hw_xres, avdimen->hw_yres, avdimen->line_difference);
    1444. 

  1444.   
    1445. 

  1445.   DBG (dbg_level, "%s: tlx: %ld, tly: %ld, brx: %ld, bry: %ld\n",
    1446. 

  1446.        func, avdimen->tlx, avdimen->tly,
    1447. 

  1447.        avdimen->brx, avdimen->bry);
    1448. 

  1448.   
    1449. 

  1449.   DBG (dbg_level, "%s: hw_pixel_per_line: %d, hw_lines: %d, hw_bytes_per_line: %d\n",
    1450. 

  1450.        func, avdimen->hw_pixels_per_line, avdimen->hw_lines, avdimen->hw_bytes_per_line);
    1451. 

  1451. 

  1452.   DBG (dbg_level, "%s: xres: %d, yres: %d\n",
    1453. 

  1453.        func, avdimen->xres, avdimen->yres);
    1454. 

  1454. }
    1455. 

  1455. 

  1456. static void debug_print_params (int dbg_level, char* func, SANE_Parameters* params)
    1457. 

  1457. {
    1458. 

  1458.   DBG (dbg_level, "%s: pixel_per_line: %d, lines: %d\n",
    1459. 

  1459.        func, params->pixels_per_line, params->lines);
    1460. 

  1460. 

  1461.   DBG (dbg_level, "%s: depth: %d, bytes_per_line: %d\n",
    1462. 

  1462.        func, params->depth, params->bytes_per_line);
    1463. 

  1463. }
    1464. 

  1464. 

  1465. static void debug_print_calib_format (int dbg_level, char* func,
    1466. 

  1466. 				      uint8_t* result)
    1467. 

  1467. {
    1468. 

  1468.   debug_print_raw (dbg_level + 2, "debug_print_calib_format:\n", result, 32);
    1469. 

  1469.   
    1470. 

  1470.   DBG (dbg_level, "%s: [0-1]  pixels per line: %d\n",
    1471. 

  1471.        func, get_double ( &(result[0]) ));
    1472. 

  1472.   DBG (dbg_level, "%s: [2]    bytes per channel: %d\n", func, result[2]);
    1473. 

  1473.   DBG (dbg_level, "%s: [3]    line count: %d\n", func, result[3]);
    1474. 

  1474.   
    1475. 

  1475.   DBG (dbg_level, "%s: [4]    FLAG:%s%s%s\n",
    1476. 

  1476.        func,
    1477. 

  1477.        result[4] == 1?" MUST_DO_CALIBRATION":"",
    1478. 

  1478.        result[4] == 2?" SCAN_IMAGE_DOES_CALIBRATION":"",
    1479. 

  1479.        result[4] == 3?" NEEDS_NO_CALIBRATION":"");
    1480. 

  1480.   
    1481. 

  1481.   DBG (dbg_level, "%s: [5]    Ability1:%s%s%s%s%s%s%s%s\n",
    1482. 

  1482.        func,
    1483. 

  1483.        BIT(result[5],7)?" NONE_PACKED":" PACKED",
    1484. 

  1484.        BIT(result[5],6)?" INTERPOLATED":"",
    1485. 

  1485.        BIT(result[5],5)?" SEND_REVERSED":"",
    1486. 

  1486.        BIT(result[5],4)?" PACKED_DATA":"",
    1487. 

  1487.        BIT(result[5],3)?" COLOR_CALIB":"",
    1488. 

  1488.        BIT(result[5],2)?" DARK_CALIB":"",
    1489. 

  1489.        BIT(result[5],1)?" NEEDS_WHITE_BLACK_SHADING_DATA":"",
    1490. 

  1490.        BIT(result[5],0)?" NEEDS_CALIB_TABLE_CHANNEL_BY_CHANNEL":"");
    1491. 

  1491.   
    1492. 

  1492.   DBG (dbg_level, "%s: [6]    R gain: %d\n", func, result[6]);
    1493. 

  1493.   DBG (dbg_level, "%s: [7]    G gain: %d\n", func, result[7]);
    1494. 

  1494.   DBG (dbg_level, "%s: [8]    B gain: %d\n", func, result[8]);
    1495. 

  1495.   
    1496. 

  1496.   DBG (dbg_level, "%s: [9-10] R shading target: %x\n",
    1497. 

  1497.        func, get_double ( &(result[9]) ) );
    1498. 

  1498.   DBG (dbg_level, "%s: [11-12] G shading target: %x\n",
    1499. 

  1499.        func, get_double ( &(result[11]) ) );
    1500. 

  1500.   DBG (dbg_level, "%s: [13-14] B shading target: %x\n",
    1501. 

  1501.        func, get_double ( &(result[13]) ) );
    1502. 

  1502.   
    1503. 

  1503.   DBG (dbg_level, "%s: [15-16] R dark shading target: %x\n",
    1504. 

  1504.        func, get_double ( &(result[15]) ) );
    1505. 

  1505.   DBG (dbg_level, "%s: [17-18] G dark shading target: %x\n",
    1506. 

  1506.        func, get_double ( &(result[17]) ) );
    1507. 

  1507.   DBG (dbg_level, "%s: [19-20] B dark shading target: %x\n",
    1508. 

  1508.        func, get_double ( &(result[19]) ) );
    1509. 

  1509. 

  1510.   DBG (dbg_level, "%s: [21]    true-gray gain: %d\n", func, result[21]);
    1511. 

  1511.   DBG (dbg_level, "%s: [22-23] true-gray shading target: %x\n",
    1512. 

  1512.        func, get_double ( &(result[22]) ) );
    1513. 

  1513.   
    1514. 

  1514.   DBG (dbg_level, "%s: [24-25] true-gray dark shading target: %x\n",
    1515. 

  1515.        func, get_double ( &(result[24]) ) );
    1516. 

  1516. }
    1517. 

  1517. 

  1518. static void debug_print_accel_info (int dbg_level, char* func,
    1519. 

  1519. 				    uint8_t* result)
    1520. 

  1520. {
    1521. 

  1521.   debug_print_raw (dbg_level + 2, "debug_print_accel_info:\n", result, 24);
    1522. 

  1522.   
    1523. 

  1523.   DBG (dbg_level, "%s: [0-1]   acceleration step count: %d\n",
    1524. 

  1524.        func, get_double ( &(result[0]) ));
    1525. 

  1525.   DBG (dbg_level, "%s: [2-3]   stable step count: %d\n",
    1526. 

  1526.        func, get_double ( &(result[2]) ));
    1527. 

  1527.   DBG (dbg_level, "%s: [4-7]   table units: %d\n",
    1528. 

  1528.        func, get_quad ( &(result[4]) ));
    1529. 

  1529.   DBG (dbg_level, "%s: [8-11]  base units: %d\n",
    1530. 

  1530.        func, get_quad ( &(result[8]) ));
    1531. 

  1531.   DBG (dbg_level, "%s: [12-13] start speed: %d\n",
    1532. 

  1532.        func, get_double ( &(result[12]) ));
    1533. 

  1533.   DBG (dbg_level, "%s: [14-15] target speed: %d\n",
    1534. 

  1534.        func, get_double ( &(result[14]) ));
    1535. 

  1535.   DBG (dbg_level, "%s: [16]    ability:%s%s\n",
    1536. 

  1536.        func,
    1537. 

  1537.        BIT(result[16],0)?" TWO_BYTES_PER_ELEM":" SINGLE_BYTE_PER_ELEM",
    1538. 

  1538.        BIT(result[16],1)?" LOW_HIGH_ORDER":" HIGH_LOW_ORDER");
    1539. 

  1539.   DBG (dbg_level, "%s: [17]    table count: %d\n", func, result[17]);
    1540. 

  1540.   
    1541. 

  1541. }
    1542. 

  1542. 

  1543. static void debug_print_window_descriptor (int dbg_level, char* func,
    1544. 

  1544. 					   command_set_window_window* window)
    1545. 

  1545. {
    1546. 

  1546.   debug_print_raw (dbg_level + 1, "window_data_header: \n",
    1547. 

  1547. 		   (uint8_t*)(&window->header),
    1548. 

  1548. 		   sizeof(window->header));
    1549. 

  1549. 

  1550.   debug_print_raw (dbg_level + 1, "window_descriptor: \n",
    1551. 

  1551. 		   (uint8_t*)(&window->descriptor),
    1552. 

  1552. 		   sizeof(*window) -
    1553. 

  1553. 		   sizeof(window->header));
    1554. 

  1554.   
    1555. 

  1555.   DBG (dbg_level, "%s: [0]     window_id: %d\n", func,
    1556. 

  1556.        window->descriptor.winid);
    1557. 

  1557.   DBG (dbg_level, "%s: [2-3]   x-axis res: %d\n", func,
    1558. 

  1558.        get_double (window->descriptor.xres));
    1559. 

  1559.   DBG (dbg_level, "%s: [4-5]   y-axis res: %d\n", func,
    1560. 

  1560.        get_double (window->descriptor.yres));
    1561. 

  1561.   DBG (dbg_level, "%s: [6-9]   x-axis upper left: %d\n",
    1562. 

  1562.        func, get_quad (window->descriptor.ulx));
    1563. 

  1563.   DBG (dbg_level, "%s: [10-13] y-axis upper left: %d\n",
    1564. 

  1564.        func, get_quad (window->descriptor.uly));
    1565. 

  1565.   DBG (dbg_level, "%s: [14-17] window width: %d\n", func,
    1566. 

  1566.        get_quad (window->descriptor.width));
    1567. 

  1567.   DBG (dbg_level, "%s: [18-21] window length: %d\n", func, 
    1568. 

  1568.        get_quad (window->descriptor.length));
    1569. 

  1569.   DBG (dbg_level, "%s: [22]    brightness: %d\n", func,
    1570. 

  1570.        window->descriptor.brightness);
    1571. 

  1571.   DBG (dbg_level, "%s: [23]    threshold: %d\n", func,
    1572. 

  1572.        window->descriptor.threshold);
    1573. 

  1573.   DBG (dbg_level, "%s: [24]    contrast: %d\n", func,
    1574. 

  1574.        window->descriptor.contrast);
    1575. 

  1575.   DBG (dbg_level, "%s: [25]    image composition: %x\n", func,
    1576. 

  1576.        window->descriptor.image_comp);
    1577. 

  1577.   DBG (dbg_level, "%s: [26]    bits per channel: %d\n", func,
    1578. 

  1578.        window->descriptor.bpc);
    1579. 

  1579.   DBG (dbg_level, "%s: [27-28] halftone pattern: %x\n", func,
    1580. 

  1580.        get_double (window->descriptor.halftone));
    1581. 

  1581.   DBG (dbg_level, "%s: [29]    padding_and_bitset: %x\n", func,
    1582. 

  1582.        window->descriptor.padding_and_bitset);
    1583. 

  1583.   DBG (dbg_level, "%s: [30-31] bit ordering: %x\n", func,
    1584. 

  1584.        get_double (window->descriptor.bitordering));
    1585. 

  1585.   DBG (dbg_level, "%s: [32]    compression type: %x\n", func,
    1586. 

  1586.        window->descriptor.compr_type);
    1587. 

  1587.   DBG (dbg_level, "%s: [33]    compression argument: %x\n", func,
    1588. 

  1588.        window->descriptor.compr_arg);
    1589. 

  1589.   DBG (dbg_level, "%s: [34-35] paper length: %x\n", func,
    1590. 

  1590.        get_double (window->descriptor.paper_length) );
    1591. 

  1591.   DBG (dbg_level, "%s: [40]    vendor id: %x\n", func,
    1592. 

  1592.        window->descriptor.vendor_specific);
    1593. 

  1593.   DBG (dbg_level, "%s: [41]    param lenght: %d\n", func,
    1594. 

  1594.        window->descriptor.paralen);
    1595. 

  1595.   DBG (dbg_level, "%s: [42]    bitset1: %x\n", func,
    1596. 

  1596.        window->avision.bitset1);
    1597. 

  1597.   DBG (dbg_level, "%s: [43]    highlight: %d\n", func,
    1598. 

  1598.        window->avision.highlight);
    1599. 

  1599.   DBG (dbg_level, "%s: [44]    shadow: %d\n", func,
    1600. 

  1600.        window->avision.shadow);
    1601. 

  1601.   DBG (dbg_level, "%s: [45-46] line-width: %d\n", func,
    1602. 

  1602.        get_double (window->avision.line_width));
    1603. 

  1603.   DBG (dbg_level, "%s: [47-48] line-count: %d\n", func,
    1604. 

  1604.        get_double (window->avision.line_count));
    1605. 

  1605.   DBG (dbg_level, "%s: [49]    bitset2: %x\n", func,
    1606. 

  1606.        window->avision.type.normal.bitset2);
    1607. 

  1607.   DBG (dbg_level, "%s: [50]    ir exposure time: %x\n",
    1608. 

  1608.        func, window->avision.type.normal.ir_exposure_time);
    1609. 

  1609.   
    1610. 

  1610.   DBG (dbg_level, "%s: [51-52] r exposure: %x\n", func,
    1611. 

  1611.        get_double (window->avision.type.normal.r_exposure_time));
    1612. 

  1612.   DBG (dbg_level, "%s: [53-54] g exposure: %x\n", func,
    1613. 

  1613.        get_double (window->avision.type.normal.g_exposure_time));
    1614. 

  1614.   DBG (dbg_level, "%s: [55-56] b exposure: %x\n", func,
    1615. 

  1615.        get_double (window->avision.type.normal.b_exposure_time));
    1616. 

  1616.   
    1617. 

  1617.   DBG (dbg_level, "%s: [57]    bitset3: %x\n", func,
    1618. 

  1618.        window->avision.type.normal.bitset3);
    1619. 

  1619.   DBG (dbg_level, "%s: [58]    auto focus: %d\n", func,
    1620. 

  1620.        window->avision.type.normal.auto_focus);
    1621. 

  1621.   DBG (dbg_level, "%s: [59]    line-width (MSB): %d\n",
    1622. 

  1622.        func, window->avision.type.normal.line_width_msb);
    1623. 

  1623.   DBG (dbg_level, "%s: [60]    line-count (MSB): %d\n",
    1624. 

  1624.        func, window->avision.type.normal.line_count_msb);
    1625. 

  1625.   DBG (dbg_level, "%s: [61]    background lines: %d\n",
    1626. 

  1626.        func, window->avision.type.normal.background_lines);
    1627. 

  1627. }
    1628. 

  1628. 

  1629. static int write_pnm_header (FILE* f, color_mode m, int depth, int width, int height)
    1630. 

  1630. {
    1631. 

  1631.   int maxval = (1 << depth) - 1;
    1632. 

  1632.   const char* hdr_str = NULL;
    1633. 

  1633.   /* construct PNM header */
    1634. 

  1634.   
    1635. 

  1635.   switch (m) {
    1636. 

  1636.   case AV_THRESHOLDED:
    1637. 

  1637.   case AV_DITHERED:
    1638. 

  1638.     hdr_str = "P4\n%d %d\n";
    1639. 

  1639.     break;
    1640. 

  1640.   case AV_GRAYSCALE:
    1641. 

  1641.   case AV_GRAYSCALE12:
    1642. 

  1642.   case AV_GRAYSCALE16:
    1643. 

  1643.     hdr_str = "P5\n%d %d\n%d\n";
    1644. 

  1644.     break;
    1645. 

  1645.   case AV_TRUECOLOR:
    1646. 

  1646.   case AV_TRUECOLOR12:
    1647. 

  1647.   case AV_TRUECOLOR16:
    1648. 

  1648.     hdr_str = "P6\n%d %d\n%d\n";
    1649. 

  1649.     break;
    1650. 

  1650.   case  AV_COLOR_MODE_LAST:
    1651. 

  1651.     ; /* silence compiler warning */
    1652. 

  1652.   }
    1653. 

  1653.   
    1654. 

  1654.   return fprintf (f, hdr_str, width, height, maxval);
    1655. 

  1655. }
    1656. 

  1656. 

  1657. static SANE_Status
    1658. 

  1658. sense_handler (int fd, u_char* sense, void* arg)
    1659. 

  1659. {
    1660. 

  1660.   SANE_Status status = SANE_STATUS_IO_ERROR; /* default case */
    1661. 

  1661.   
    1662. 

  1662.   char* text;
    1663. 

  1663.   char textbuf[64];
    1664. 

  1664.   
    1665. 

  1665.   uint8_t error_code = sense[0] & 0x7f;
    1666. 

  1666.   uint8_t sense_key = sense[2] & 0xf;
    1667. 

  1667.   uint8_t additional_sense = sense[7];
    1668. 

  1668.   
    1669. 

  1669.   fd = fd; /* silence gcc */
    1670. 

  1670.   arg = arg; /* silence gcc */
    1671. 

  1671.   
    1672. 

  1672.   DBG (3, "sense_handler:\n");
    1673. 

  1673.   
    1674. 

  1674.   switch (error_code)
    1675. 

  1675.     {
    1676. 

  1676.     case 0x70:
    1677. 

  1677.       text = "standard sense";
    1678. 

  1678.       break;
    1679. 

  1679.     case 0x7f:
    1680. 

  1680.       text = "Avision-specific sense";
    1681. 

  1681.       break;
    1682. 

  1682.     default:
    1683. 

  1683.       text = "unknown sense";
    1684. 

  1684.     }
    1685. 

  1685.   
    1686. 

  1686.   debug_print_raw (1, "sense_handler: data:\n", sense, 8 + additional_sense);
    1687. 

  1687.   
    1688. 

  1688.   /* request valid? */
    1689. 

  1689.   if (! sense[0] & (1<<7)) {
    1690. 

  1690.     DBG (1, "sense_handler: sense not vaild ...\n");
    1691. 

  1691.     return status;
    1692. 

  1692.   }
    1693. 

  1693.   
    1694. 

  1694.   switch (sense_key)
    1695. 

  1695.     {
    1696. 

  1696.     case 0x00:
    1697. 

  1697.       status = SANE_STATUS_GOOD;
    1698. 

  1698.       text = "ok ?!?";
    1699. 

  1699.       break;
    1700. 

  1700.     case 0x02:
    1701. 

  1701.       text = "NOT READY";
    1702. 

  1702.       break;
    1703. 

  1703.     case 0x03:
    1704. 

  1704.       text = "MEDIUM ERROR (mostly ADF)";
    1705. 

  1705.       status = SANE_STATUS_JAMMED;
    1706. 

  1706.       break;
    1707. 

  1707.     case 0x04:
    1708. 

  1708.       text = "HARDWARE ERROR";
    1709. 

  1709.       break;
    1710. 

  1710.     case 0x05:
    1711. 

  1711.       text = "ILLEGAL REQUEST";
    1712. 

  1712.       break;
    1713. 

  1713.     case 0x06:
    1714. 

  1714.       text = "UNIT ATTENTION";
    1715. 

  1715.       break;
    1716. 

  1716.     case 0x09:
    1717. 

  1717.       text = "VENDOR SPECIFIC";
    1718. 

  1718.       break;
    1719. 

  1719.     case 0x0b:
    1720. 

  1720.       text = "ABORTED COMMAND";
    1721. 

  1721.       status = SANE_STATUS_CANCELLED; /* AV610C2 cancel button */
    1722. 

  1722.       break;
    1723. 

  1723.     default:
    1724. 

  1724.       sprintf (textbuf, "got unknown sense code 0x%02x", (int)sense_key);
    1725. 

  1725.       text = textbuf;
    1726. 

  1726.     }
    1727. 

  1727.   
    1728. 

  1728.   DBG (1, "sense_handler: sense code: %s\n", text);
    1729. 

  1729.   
    1730. 

  1730.   if (sense[2] & (1<<6))
    1731. 

  1731.     DBG (1, "sense_handler: end of scan\n");   
    1732. 

  1732.   else 
    1733. 

  1733.     DBG (1, "sense_handler: scan has not yet been completed\n");
    1734. 

  1734.   
    1735. 

  1735.   if (sense[2] & (1<<5))
    1736. 

  1736.     DBG (1, "sense_handler: incorrect logical length\n");
    1737. 

  1737.   else 
    1738. 

  1738.     DBG (1, "sense_handler: correct logical length\n");
    1739. 

  1739. 

  1740.   {  
    1741. 

  1741.     uint8_t asc = sense[12];
    1742. 

  1742.     uint8_t ascq = sense[13];
    1743. 

  1743.     
    1744. 

  1744. #define ADDITIONAL_SENSE(asc,ascq,txt)			\
    1745. 

  1745.     case ( (asc << 8) + ascq): text = txt; break
    1746. 

  1746.     
    1747. 

  1747.     switch ( (asc << 8) + ascq )
    1748. 

  1748.       {
    1749. 

  1749. 	/* normal */
    1750. 

  1750. 	ADDITIONAL_SENSE (0x00,0x00, "No additional sense information");
    1751. 

  1751. 	ADDITIONAL_SENSE (0x00,0x06, "I/O process terminated");
    1752. 

  1752. 	ADDITIONAL_SENSE (0x15,0x01, "Mechanical positioning error");
    1753. 

  1753. 

  1754. 	ADDITIONAL_SENSE (0x15,0x02, "Flatbed Home Sensor Error (OKI only");
    1755. 

  1755. 	ADDITIONAL_SENSE (0x15,0x03, "ADF Home Sensor Error (OKI only)");
    1756. 

  1756. 	ADDITIONAL_SENSE (0x15,0x04, "Lock Error (OKI only)");
    1757. 

  1757. 	
    1758. 

  1758. 	ADDITIONAL_SENSE (0x1a,0x00, "parameter list lenght error");
    1759. 

  1759. 	
    1760. 

  1760. 	ADDITIO…
    1761.

Large files files are truncated, but you can click here to view the full file