1 /* sane - Scanner Access Now Easy.
2 Copyright (C) 1998 F.W. Dillema (dillema@acm.org)
3
4 This file is part of the SANE package.
5
6 This program is free software; you can redistribute it and/or
7 modify it under the terms of the GNU General Public License as
8 published by the Free Software Foundation; either version 2 of the
9 License, or (at your option) any later version.
10
11 This program is distributed in the hope that it will be useful, but
12 WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 General Public License for more details.
15
16 You should have received a copy of the GNU General Public License
17 along with this program. If not, see <https://www.gnu.org/licenses/>.
18
19 As a special exception, the authors of SANE give permission for
20 additional uses of the libraries contained in this release of SANE.
21
22 The exception is that, if you link a SANE library with other files
23 to produce an executable, this does not by itself cause the
24 resulting executable to be covered by the GNU General Public
25 License. Your use of that executable is in no way restricted on
26 account of linking the SANE library code into it.
27
28 This exception does not, however, invalidate any other reasons why
29 the executable file might be covered by the GNU General Public
30 License.
31
32 If you submit changes to SANE to the maintainers to be included in
33 a subsequent release, you agree by submitting the changes that
34 those changes may be distributed with this exception intact.
35
36 If you write modifications of your own for SANE, it is your choice
37 whether to permit this exception to apply to your modifications.
38 If you do not wish that, delete this exception notice.
39 */
40
41 /*
42 This file implements the low-level scsi-commands.
43 */
44
45 /* SCSI commands that the Ricoh scanners understand: */
46 #define RICOH_SCSI_TEST_UNIT_READY 0x00
47 #define RICOH_SCSI_SET_WINDOW 0x24
48 #define RICOH_SCSI_GET_WINDOW 0x25
49 #define RICOH_SCSI_READ_SCANNED_DATA 0x28
50 #define RICOH_SCSI_INQUIRY 0x12
51 #define RICOH_SCSI_MODE_SELECT 0x15
52 #define RICOH_SCSI_START_SCAN 0x1b
53 #define RICOH_SCSI_MODE_SENSE 0x1a
54 #define RICOH_SCSI_GET_BUFFER_STATUS 0x34
55 #define RICOH_SCSI_OBJECT_POSITION 0x31
56
57 /* How long do we wait for scanner to have data for us */
58 #define MAX_WAITING_TIME 15
59
60 struct scsi_window_cmd {
61 SANE_Byte opcode;
62 SANE_Byte byte2;
63 SANE_Byte reserved[4];
64 SANE_Byte len[3];
65 SANE_Byte control;
66 };
67
68 struct scsi_mode_select_cmd {
69 SANE_Byte opcode;
70 SANE_Byte byte2;
71 #define SMS_SP 0x01
72 #define SMS_PF 0x10
73 SANE_Byte page_code; /* for mode_sense, reserved for mode_select */
74 SANE_Byte unused[1];
75 SANE_Byte len;
76 SANE_Byte control;
77 };
78
79 struct scsi_mode_header {
80 SANE_Byte data_length; /* Sense data length */
81 SANE_Byte medium_type;
82 SANE_Byte dev_spec;
83 SANE_Byte blk_desc_len;
84 };
85
86 struct scsi_get_buffer_status_cmd {
87 SANE_Byte opcode;
88 SANE_Byte byte2;
89 SANE_Byte res[5];
90 SANE_Byte len[2];
91 SANE_Byte control;
92 };
93
94 struct scsi_status_desc {
95 SANE_Byte window_id;
96 SANE_Byte byte2;
97 SANE_Byte available[3];
98 SANE_Byte filled[3];
99 };
100
101 struct scsi_status_data {
102 SANE_Byte len[3];
103 SANE_Byte byte4;
104 struct scsi_status_desc desc;
105 };
106
107 struct scsi_start_scan_cmd {
108 SANE_Byte opcode;
109 SANE_Byte byte2;
110 SANE_Byte unused[2];
111 SANE_Byte len;
112 SANE_Byte control;
113 };
114
115 struct scsi_read_scanner_cmd {
116 SANE_Byte opcode;
117 SANE_Byte byte2;
118 SANE_Byte data_type;
119 SANE_Byte byte3;
120 SANE_Byte data_type_qualifier[2];
121 SANE_Byte len[3];
122 SANE_Byte control;
123 };
124
125 static SANE_Status
test_unit_ready(int fd)126 test_unit_ready (int fd)
127 {
128 static SANE_Byte cmd[6];
129 SANE_Status status;
130 DBG (11, ">> test_unit_ready\n");
131
132 cmd[0] = RICOH_SCSI_TEST_UNIT_READY;
133 memset (cmd, 0, sizeof (cmd));
134 status = sanei_scsi_cmd (fd, cmd, sizeof (cmd), 0, 0);
135
136 DBG (11, "<< test_unit_ready\n");
137 return (status);
138 }
139
140 static SANE_Status
inquiry(int fd, void *buf, size_t * buf_size)141 inquiry (int fd, void *buf, size_t * buf_size)
142 {
143 static SANE_Byte cmd[6];
144 SANE_Status status;
145 DBG (11, ">> inquiry\n");
146
147 memset (cmd, 0, sizeof (cmd));
148 cmd[0] = RICOH_SCSI_INQUIRY;
149 cmd[4] = *buf_size;
150 status = sanei_scsi_cmd (fd, cmd, sizeof (cmd), buf, buf_size);
151
152 DBG (11, "<< inquiry\n");
153 return (status);
154 }
155
156 static SANE_Status
mode_select(int fd, struct mode_pages *mp)157 mode_select (int fd, struct mode_pages *mp)
158 {
159 static struct {
160 struct scsi_mode_select_cmd cmd;
161 struct scsi_mode_header smh;
162 struct mode_pages mp;
163 } select_cmd;
164 SANE_Status status;
165 DBG (11, ">> mode_select\n");
166
167 memset (&select_cmd, 0, sizeof (select_cmd));
168 select_cmd.cmd.opcode = RICOH_SCSI_MODE_SELECT;
169 select_cmd.cmd.byte2 |= SMS_PF;
170 select_cmd.cmd.len = sizeof(select_cmd.smh) + sizeof(select_cmd.mp);
171 memcpy (&select_cmd.mp, mp, sizeof(*mp));
172 status = sanei_scsi_cmd (fd, &select_cmd, sizeof (select_cmd), 0, 0);
173
174 DBG (11, "<< mode_select\n");
175 return (status);
176 }
177
178 #if 0
179 static SANE_Status
180 mode_sense (int fd, struct mode_pages *mp, SANE_Byte page_code)
181 {
182 static struct scsi_mode_select_cmd cmd; /* no type, we can reuse it for sensing */
183 static struct {
184 struct scsi_mode_header smh;
185 struct mode_pages mp;
186 } select_data;
187 static size_t select_size = sizeof(select_data);
188 SANE_Status status;
189 DBG (11, ">> mode_sense\n");
190
191 memset (&cmd, 0, sizeof (cmd));
192 cmd.opcode = RICOH_SCSI_MODE_SENSE;
193 cmd.page_code = page_code;
194 cmd.len = sizeof(select_data);
195 status = sanei_scsi_cmd (fd, &cmd, sizeof (cmd), &select_data, &select_size);
196 memcpy (mp, &select_data.mp, sizeof(*mp));
197
198 DBG (11, "<< mode_sense\n");
199 return (status);
200 }
201 #endif
202
203 static SANE_Status
trigger_scan(int fd)204 trigger_scan (int fd)
205 {
206 static struct scsi_start_scan_cmd cmd;
207 static char window_id_list[1] = { '\0' }; /* scan start data out */
208 static size_t wl_size = 1;
209 SANE_Status status;
210 DBG (11, ">> trigger scan\n");
211
212 memset (&cmd, 0, sizeof (cmd));
213 cmd.opcode = RICOH_SCSI_START_SCAN;
214 cmd.len = wl_size;
215 if (wl_size)
216 status = sanei_scsi_cmd (fd, &cmd, sizeof (cmd), &window_id_list, &wl_size);
217 else
218 status = sanei_scsi_cmd (fd, &cmd, sizeof (cmd), 0, 0);
219
220 DBG (11, "<< trigger scan\n");
221 return (status);
222 }
223
224 static SANE_Status
set_window(int fd, struct ricoh_window_data *rwd)225 set_window (int fd, struct ricoh_window_data *rwd)
226 {
227
228 static struct {
229 struct scsi_window_cmd cmd;
230 struct ricoh_window_data rwd;
231 } win;
232
233 SANE_Status status;
234 DBG (11, ">> set_window\n");
235
236 memset (&win, 0, sizeof (win));
237 win.cmd.opcode = RICOH_SCSI_SET_WINDOW;
238 _lto3b(sizeof(*rwd), win.cmd.len);
239 memcpy (&win.rwd, rwd, sizeof(*rwd));
240 status = sanei_scsi_cmd (fd, &win, sizeof (win), 0, 0);
241
242 DBG (11, "<< set_window\n");
243 return (status);
244 }
245
246 static SANE_Status
get_window(int fd, struct ricoh_window_data *rwd)247 get_window (int fd, struct ricoh_window_data *rwd)
248 {
249
250 static struct scsi_window_cmd cmd;
251 static size_t rwd_size;
252 SANE_Status status;
253
254 rwd_size = sizeof(*rwd);
255 DBG (11, ">> get_window datalen = %lu\n", (unsigned long) rwd_size);
256
257 memset (&cmd, 0, sizeof (cmd));
258 cmd.opcode = RICOH_SCSI_GET_WINDOW;
259 #if 0
260 cmd.byte2 |= (SANE_Byte)0x01; /* set Single bit to get one window desc. */
261 #endif
262 _lto3b(rwd_size, cmd.len);
263 status = sanei_scsi_cmd (fd, &cmd, sizeof (cmd), rwd, &rwd_size);
264
265 DBG (11, "<< get_window, datalen = %lu\n", (unsigned long) rwd_size);
266 return (status);
267 }
268
269 static SANE_Status
read_data(int fd, void *buf, size_t * buf_size)270 read_data (int fd, void *buf, size_t * buf_size)
271 {
272 static struct scsi_read_scanner_cmd cmd;
273 SANE_Status status;
274 DBG (11, ">> read_data %lu\n", (unsigned long) *buf_size);
275
276 memset (&cmd, 0, sizeof (cmd));
277 cmd.opcode = RICOH_SCSI_READ_SCANNED_DATA;
278 _lto3b(*buf_size, cmd.len);
279 status = sanei_scsi_cmd (fd, &cmd, sizeof (cmd), buf, buf_size);
280
281 DBG (11, "<< read_data %lu\n", (unsigned long) *buf_size);
282 return (status);
283 }
284
285 static SANE_Status
object_position(int fd)286 object_position (int fd)
287 {
288 static SANE_Byte cmd[10];
289 SANE_Status status;
290 DBG (11, ">> object_position\n");
291
292 memset (cmd, 0, sizeof (cmd));
293 cmd[0] = RICOH_SCSI_OBJECT_POSITION;
294 status = sanei_scsi_cmd (fd, cmd, sizeof (cmd), 0, 0);
295
296 DBG (11, "<< object_position\n");
297 return (status);
298 }
299
300 static SANE_Status
get_data_status(int fd, struct scsi_status_desc *dbs)301 get_data_status (int fd, struct scsi_status_desc *dbs)
302 {
303 static struct scsi_get_buffer_status_cmd cmd;
304 static struct scsi_status_data ssd;
305 size_t ssd_size = sizeof(ssd);
306 SANE_Status status;
307 DBG (11, ">> get_data_status %lu\n", (unsigned long) ssd_size);
308
309 memset (&cmd, 0, sizeof (cmd));
310 cmd.opcode = RICOH_SCSI_GET_BUFFER_STATUS;
311 _lto2b(ssd_size, cmd.len);
312 status = sanei_scsi_cmd (fd, &cmd, sizeof (cmd), &ssd, &ssd_size);
313
314 memcpy (dbs, &ssd.desc, sizeof(*dbs));
315 if (status == SANE_STATUS_GOOD &&
316 (((unsigned int) _3btol(ssd.len)) <= sizeof(*dbs) || _3btol(ssd.desc.filled) == 0)) {
317 DBG (11, "get_data_status: busy\n");
318 status = SANE_STATUS_DEVICE_BUSY;
319 }
320
321 DBG (11, "<< get_data_status %lu\n", (unsigned long) ssd_size);
322 return (status);
323 }
324
325 #if 0
326 static SANE_Status
327 ricoh_wait_ready_tur (int fd)
328 {
329 struct timeval now, start;
330 SANE_Status status;
331
332 gettimeofday (&start, 0);
333
334 while (1)
335 {
336 DBG(3, "scsi_wait_ready: sending TEST_UNIT_READY\n");
337
338 status = sanei_scsi_cmd (fd, test_unit_ready, sizeof (test_unit_ready),
339 0, 0);
340 switch (status)
341 {
342 default:
343 /* Ignore errors while waiting for scanner to become ready.
344 Some SCSI drivers return EIO while the scanner is
345 returning to the home position. */
346 DBG(1, "scsi_wait_ready: test unit ready failed (%s)\n",
347 sane_strstatus (status));
348 /* fall through */
349 case SANE_STATUS_DEVICE_BUSY:
350 gettimeofday (&now, 0);
351 if (now.tv_sec - start.tv_sec >= MAX_WAITING_TIME)
352 {
353 DBG(1, "ricoh_wait_ready: timed out after %lu seconds\n",
354 (u_long) (now.tv_sec - start.tv_sec));
355 return SANE_STATUS_INVAL;
356 }
357 usleep (100000); /* retry after 100ms */
358 break;
359
360 case SANE_STATUS_GOOD:
361 return status;
362 }
363 }
364 return SANE_STATUS_INVAL;
365 }
366 #endif
367
368 static SANE_Status
ricoh_wait_ready(Ricoh_Scanner * s)369 ricoh_wait_ready (Ricoh_Scanner * s)
370 {
371 struct scsi_status_desc dbs;
372 time_t now, start;
373 SANE_Status status;
374
375 start = time(NULL);
376
377 while (1)
378 {
379 status = get_data_status (s->fd, &dbs);
380
381 switch (status)
382 {
383 default:
384 /* Ignore errors while waiting for scanner to become ready.
385 Some SCSI drivers return EIO while the scanner is
386 returning to the home position. */
387 DBG(1, "scsi_wait_ready: get datat status failed (%s)\n",
388 sane_strstatus (status));
389 /* fall through */
390 case SANE_STATUS_DEVICE_BUSY:
391 now = time(NULL);
392 if (now - start >= MAX_WAITING_TIME)
393 {
394 DBG(1, "ricoh_wait_ready: timed out after %lu seconds\n",
395 (u_long) (now - start));
396 return SANE_STATUS_INVAL;
397 }
398 break;
399
400 case SANE_STATUS_GOOD:
401 DBG(11, "ricoh_wait_ready: %d bytes ready\n", _3btol(dbs.filled));
402 return status;
403 break;
404 }
405 usleep (1000000); /* retry after 100ms */
406 }
407 return SANE_STATUS_INVAL;
408 }
409