1 /* $NetBSD: ss_mustek.c,v 1.30 2005/02/01 00:19:34 reinoud Exp $ */
2
3 /*
4 * Copyright (c) 1995 Joachim Koenig-Baltes. All rights reserved.
5 *
6 * Redistribution and use in source and binary forms, with or without
7 * modification, are permitted provided that the following conditions
8 * are met:
9 * 1. Redistributions of source code must retain the above copyright
10 * notice, this list of conditions and the following disclaimer.
11 * 2. Redistributions in binary form must reproduce the above copyright
12 * notice, this list of conditions and the following disclaimer in the
13 * documentation and/or other materials provided with the distribution.
14 * 3. All advertising materials mentioning features or use of this software
15 * must display the following acknowledgement:
16 * This product includes software developed by Joachim Koenig-Baltes.
17 * 4. The name of the author may not be used to endorse or promote products
18 * derived from this software without specific prior written permission.
19 *
20 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
21 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
22 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
23 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
24 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
25 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
26 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
27 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
28 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
29 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
30 */
31
32 /*
33 * special driver for MUSTEK flatbed scanners MFS 06000CX and MFS 12000CX
34 * these scanners come with their own scsi card, containing an NCR53C400
35 * SCSI controller chip. I'm in the progress of writing a driver for this
36 * card to work under NetBSD-current. I've hooked it up to a Seagate ST01
37 * hostadapter in the meantime, giving 350KB/sec for higher resolutions!
38 *
39 * I tried to connect it to my Adaptec 1542B, but with no success. It seems,
40 * it does not like synchronous negotiation between Hostadapter and other
41 * targets, but I could not turn this off for the 1542B.
42 *
43 * There is also an other reason why you would not like to connect it to your
44 * favourite SCSI host adapter: The Mustek DOES NOT DISCONNECT. It will block
45 * other traffic from the bus while a transfer is active.
46 */
47
48 #include <sys/cdefs.h>
49 __KERNEL_RCSID(0, "$NetBSD: ss_mustek.c,v 1.30 2005/02/01 00:19:34 reinoud Exp $");
50
51 #include <sys/param.h>
52 #include <sys/kernel.h>
53 #include <sys/systm.h>
54 #include <sys/fcntl.h>
55 #include <sys/errno.h>
56 #include <sys/ioctl.h>
57 #include <sys/malloc.h>
58 #include <sys/buf.h>
59 #include <sys/bufq.h>
60 #include <sys/proc.h>
61 #include <sys/user.h>
62 #include <sys/device.h>
63 #include <sys/conf.h> /* for cdevsw */
64 #include <sys/scanio.h>
65
66 #include <dev/scsipi/scsipi_all.h>
67 #include <dev/scsipi/scsi_all.h>
68 #include <dev/scsipi/scsi_scanner.h>
69 #include <dev/scsipi/scsipiconf.h>
70 #include <dev/scsipi/scsipi_base.h>
71 #include <dev/scsipi/ssvar.h>
72 #include <dev/scsipi/ss_mustek.h>
73
74 #define MUSTEK_RETRIES 4
75
76 static int mustek_get_params(struct ss_softc *);
77 static int mustek_set_params(struct ss_softc *, struct scan_io *);
78 static int mustek_trigger_scanner(struct ss_softc *);
79 static void mustek_minphys(struct ss_softc *, struct buf *);
80 static int mustek_read(struct ss_softc *, struct buf *);
81 static int mustek_rewind_scanner(struct ss_softc *);
82
83 /* only used internally */
84 static int mustek_get_status(struct ss_softc *, int, int);
85 static void mustek_compute_sizes(struct ss_softc *);
86
87 /*
88 * structure for the special handlers
89 */
90 static struct ss_special mustek_special = {
91 mustek_set_params,
92 mustek_trigger_scanner,
93 mustek_get_params,
94 mustek_minphys,
95 mustek_read,
96 mustek_rewind_scanner,
97 NULL, /* no adf support right now */
98 NULL /* no adf support right now */
99 };
100
101 /*
102 * mustek_attach: attach special functions to ss
103 */
104 void
105 mustek_attach(struct ss_softc *ss, struct scsipibus_attach_args *sa)
106 {
107 #ifdef SCSIPI_DEBUG
108 struct scsipi_periph *periph = sa->sa_periph;
109 #endif
110
111 SC_DEBUG(periph, SCSIPI_DB1, ("mustek_attach: start\n"));
112 ss->sio.scan_scanner_type = 0;
113
114 printf("\n%s: ", ss->sc_dev.dv_xname);
115
116 /* first, check the model which determines resolutions */
117 if (!memcmp(sa->sa_inqbuf.product, "MFS-06000CX", 11)) {
118 ss->sio.scan_scanner_type = MUSTEK_06000CX;
119 printf("Mustek 6000CX Flatbed 3-pass color scanner, 3 - 600 dpi\n");
120 }
121 if (!memcmp(sa->sa_inqbuf.product, "MFS-12000CX", 11)) {
122 ss->sio.scan_scanner_type = MUSTEK_12000CX;
123 printf("Mustek 12000CX Flatbed 3-pass color scanner, 6 - 1200 dpi\n");
124 }
125
126 SC_DEBUG(periph, SCSIPI_DB1, ("mustek_attach: scanner_type = %d\n",
127 ss->sio.scan_scanner_type));
128
129 /* install special handlers */
130 ss->special = &mustek_special;
131
132 /*
133 * populate the scanio struct with legal values
134 * the default should come from user space
135 */
136 ss->sio.scan_width = 1200;
137 ss->sio.scan_height = 1200;
138 ss->sio.scan_x_resolution = 99;
139 ss->sio.scan_y_resolution = 99;
140 ss->sio.scan_x_origin = 0;
141 ss->sio.scan_y_origin = 0;
142 ss->sio.scan_brightness = 100;
143 ss->sio.scan_contrast = 100;
144 ss->sio.scan_quality = 100;
145 ss->sio.scan_image_mode = SIM_GRAYSCALE;
146
147 mustek_compute_sizes(ss);
148 }
149
150 static int
151 mustek_get_params (struct ss_softc *ss)
152 {
153
154 return (0);
155 }
156
157 /*
158 * check the parameters if the mustek is capable of fulfilling it
159 * but don't send the command to the scanner in case the user wants
160 * to change parameters by more than one call
161 */
162 static int
163 mustek_set_params(struct ss_softc *ss, struct scan_io *sio)
164 {
165 int error;
166
167 /*
168 * if the scanner is triggered, then rewind it
169 */
170 if (ss->flags & SSF_TRIGGERED) {
171 error = mustek_rewind_scanner(ss);
172 if (error)
173 return (error);
174 }
175
176 /* size constraints: 8.5" horizontally and 14" vertically */
177 #ifdef MUSTEK_INCH_SPEC
178 /* sizes must be a multiple of 1/8" */
179 sio->scan_x_origin -= sio->scan_x_origin % 150;
180 sio->scan_y_origin -= sio->scan_y_origin % 150;
181 sio->scan_width -= sio->scan_width % 150;
182 sio->scan_height -= sio->scan_height % 150;
183 #endif
184 if (sio->scan_width == 0 ||
185 sio->scan_x_origin + sio->scan_width > 10200 ||
186 sio->scan_height == 0 ||
187 sio->scan_y_origin + sio->scan_height > 16800)
188 return (EINVAL);
189
190 /*
191 * for now, only realize the values for the MUSTEK_06000CX
192 * in the future, values for the MUSTEK_12000CX will be implemented
193 */
194
195 /*
196 * resolution (dpi) must be <= 300 and a multiple of 3 or
197 * between 300 and 600 and a multiple of 30
198 */
199 sio->scan_x_resolution -= sio->scan_x_resolution <= 300 ?
200 sio->scan_x_resolution % 3 : sio->scan_x_resolution % 30;
201 sio->scan_y_resolution -= sio->scan_y_resolution <= 300 ?
202 sio->scan_y_resolution % 3 : sio->scan_y_resolution % 30;
203 if (sio->scan_x_resolution < 3 || sio->scan_x_resolution > 600 ||
204 sio->scan_x_resolution != sio->scan_y_resolution)
205 return (EINVAL);
206
207 /* assume brightness values are between 64 and 136 in steps of 3 */
208 sio->scan_brightness -= (sio->scan_brightness - 64) % 3;
209 if (sio->scan_brightness < 64 || sio->scan_brightness > 136)
210 return (EINVAL);
211
212 /* contrast values must be between 16 and 184 in steps of 7 */
213 sio->scan_contrast -= (sio->scan_contrast - 16) % 7;
214 if (sio->scan_contrast < 16 || sio->scan_contrast > 184)
215 return (EINVAL);
216
217 /*
218 * velocity: between 0 (fast) and 4 (slow) which will be mapped
219 * to 100% = 4, 80% = 3, 60% = 2, 40% = 1, 20% = 0
220 * must be a multiple of 20
221 */
222 sio->scan_quality -= sio->scan_quality % 20;
223 if (sio->scan_quality < 20 || sio->scan_quality > 100)
224 return (EINVAL);
225
226 switch (sio->scan_image_mode) {
227 case SIM_BINARY_MONOCHROME:
228 case SIM_DITHERED_MONOCHROME:
229 case SIM_GRAYSCALE:
230 case SIM_RED:
231 case SIM_GREEN:
232 case SIM_BLUE:
233 break;
234 default:
235 return (EINVAL);
236 }
237
238 /* change ss_softc to the new values, but save ro-variables */
239 sio->scan_scanner_type = ss->sio.scan_scanner_type;
240 memcpy(&ss->sio, sio, sizeof(struct scan_io));
241
242 mustek_compute_sizes(ss);
243
244 return (0);
245 }
246
247 /*
248 * trim the requested transfer to a multiple of the line size
249 * this is called only from ssread() which guarantees, scanner is triggered
250 * In the future, it will trim the transfer to not read to much at a time
251 * because the mustek cannot disconnect. It will be calculated by the
252 * resolution, the velocity and the number of bytes per line.
253 */
254 static void
255 mustek_minphys(struct ss_softc *ss, struct buf *bp)
256 {
257 #ifdef SCSIPI_DEBUG
258 struct scsipi_periph *periph = ss->sc_periph;
259 #endif
260
261 SC_DEBUG(periph, SCSIPI_DB1, ("mustek_minphys: before: %d\n",
262 bp->b_bcount));
263 bp->b_bcount -= bp->b_bcount %
264 ((ss->sio.scan_pixels_per_line * ss->sio.scan_bits_per_pixel) / 8);
265 SC_DEBUG(periph, SCSIPI_DB1, ("mustek_minphys: after: %d\n",
266 bp->b_bcount));
267 }
268
269 /*
270 * trigger the scanner to start a scan operation
271 * this includes sending the mode- and window-data, starting the scanner
272 * and getting the image size info
273 */
274 static int
275 mustek_trigger_scanner(struct ss_softc *ss)
276 {
277 struct mustek_mode_select_cmd mode_cmd;
278 struct mustek_mode_select_data mode_data;
279 struct mustek_set_window_cmd window_cmd;
280 struct mustek_set_window_data window_data;
281 struct mustek_start_scan_cmd start_scan_cmd;
282 struct scsipi_periph *periph = ss->sc_periph;
283 int pixel_tlx, pixel_tly, pixel_brx, pixel_bry, paperlength;
284 int error;
285
286 mustek_compute_sizes(ss);
287
288 SC_DEBUG(periph, SCSIPI_DB1, ("mustek_trigger_scanner\n"));
289
290 /*
291 * set the window params and send the scsi command
292 */
293 memset(&window_cmd, 0, sizeof(window_cmd));
294 window_cmd.opcode = MUSTEK_SET_WINDOW;
295 window_cmd.length = sizeof(window_data);
296
297 memset(&window_data, 0, sizeof(window_data));
298 window_data.frame.header = MUSTEK_LINEART_BACKGROUND | MUSTEK_UNIT_SPEC;
299 #ifdef MUSTEK_INCH_SPEC
300 /* the positional values are all 1 byte because 256 / 8 = 32" */
301 pixel_tlx = ss->sio.scan_x_origin / 150;
302 pixel_tly = ss->sio.scan_y_origin / 150;
303 pixel_brx = pixel_tlx + ss->sio.scan_width / 150;
304 pixel_bry = pixel_tly + ss->sio.scan_height / 150;
305 #else
306 pixel_tlx = (ss->sio.scan_x_origin * ss->sio.scan_x_resolution) / 1200;
307 pixel_tly = (ss->sio.scan_y_origin * ss->sio.scan_y_resolution) / 1200;
308 pixel_brx = pixel_tlx +
309 (ss->sio.scan_width * ss->sio.scan_x_resolution) / 1200;
310 pixel_bry = pixel_tly +
311 (ss->sio.scan_height * ss->sio.scan_y_resolution) / 1200;
312 #endif
313 _lto2l(pixel_tlx, window_data.frame.tl_x);
314 _lto2l(pixel_tly, window_data.frame.tl_y);
315 _lto2l(pixel_brx, window_data.frame.br_x);
316 _lto2l(pixel_bry, window_data.frame.br_y);
317
318 #if MUSTEK_WINDOWS >= 1
319 window_data.window1 = window_data.frame;
320 window_data.window1.header = MUSTEK_WINDOW_MASK | MUSTEK_UNIT_SPEC;
321 #endif
322
323 /* send the set window command to the scanner */
324 SC_DEBUG(periph, SCSIPI_DB1, ("mustek_set_parms: set_window\n"));
325 error = scsipi_command(periph, (void *)&window_cmd, sizeof(window_cmd),
326 (void *)&window_data, sizeof(window_data),
327 MUSTEK_RETRIES, 5000, NULL, XS_CTL_DATA_OUT | XS_CTL_DATA_ONSTACK);
328 if (error)
329 return (error);
330
331 /*
332 * do what it takes to actualize the mode
333 */
334 memset(&mode_cmd, 0, sizeof(mode_cmd));
335 mode_cmd.opcode = MUSTEK_MODE_SELECT;
336 _lto2b(sizeof(mode_data), mode_cmd.length);
337
338 memset(&mode_data, 0, sizeof(mode_data));
339 mode_data.mode =
340 MUSTEK_MODE_MASK | MUSTEK_HT_PATTERN_BUILTIN | MUSTEK_UNIT_SPEC;
341 if (ss->sio.scan_x_resolution <= 300) {
342 mode_data.resolution = ss->sio.scan_x_resolution / 3;
343 } else {
344 /*
345 * the resolution values is computed by modulo 100, but not
346 * for 600dpi, where the value is 100 (a bit tricky, but ...)
347 */
348 mode_data.resolution =
349 ((ss->sio.scan_x_resolution - 1) % 100) + 1;
350 }
351 mode_data.brightness = (ss->sio.scan_brightness - 64) / 3;
352 mode_data.contrast = (ss->sio.scan_contrast - 16) / 7;
353 mode_data.grain = 0;
354 mode_data.velocity = ss->sio.scan_quality / 20 - 1;
355 #ifdef MUSTEK_INCH_SPEC
356 paperlength = 14 * 8; /* 14" */
357 #else
358 paperlength = 14 * ss->sio.scan_y_resolution; /* 14" */
359 #endif
360 _lto2l(paperlength, mode_data.paperlength);
361
362 SC_DEBUG(periph, SCSIPI_DB1, ("mustek_trigger_scanner: mode_select\n"));
363 /* send the command to the scanner */
364 error = scsipi_command(periph, (void *)&mode_cmd, sizeof(mode_cmd),
365 (void *)&mode_data, sizeof(mode_data),
366 MUSTEK_RETRIES, 5000, NULL, XS_CTL_DATA_OUT | XS_CTL_DATA_ONSTACK);
367 if (error)
368 return (error);
369
370 /*
371 * now construct and send the start command
372 */
373 memset(&start_scan_cmd, 0, sizeof(start_scan_cmd));
374 start_scan_cmd.opcode = MUSTEK_START_STOP;
375 start_scan_cmd.mode = MUSTEK_SCAN_START;
376 if (ss->sio.scan_x_resolution <= 300)
377 start_scan_cmd.mode |= MUSTEK_RES_STEP_1;
378 else
379 start_scan_cmd.mode |= MUSTEK_RES_STEP_10;
380 switch (ss->sio.scan_image_mode) {
381 case SIM_BINARY_MONOCHROME:
382 case SIM_DITHERED_MONOCHROME:
383 start_scan_cmd.mode |= MUSTEK_BIT_MODE | MUSTEK_GRAY_FILTER;
384 break;
385 case SIM_GRAYSCALE:
386 start_scan_cmd.mode |= MUSTEK_GRAY_MODE | MUSTEK_GRAY_FILTER;
387 break;
388 case SIM_RED:
389 start_scan_cmd.mode |= MUSTEK_GRAY_MODE | MUSTEK_RED_FILTER;
390 break;
391 case SIM_GREEN:
392 start_scan_cmd.mode |= MUSTEK_GRAY_MODE | MUSTEK_GREEN_FILTER;
393 break;
394 case SIM_BLUE:
395 start_scan_cmd.mode |= MUSTEK_GRAY_MODE | MUSTEK_BLUE_FILTER;
396 break;
397 }
398
399 /* send the command to the scanner */
400 SC_DEBUG(periph, SCSIPI_DB1, ("mustek_trigger_scanner: start_scan\n"));
401 error = scsipi_command(periph,
402 (void *)&start_scan_cmd, sizeof(start_scan_cmd),
403 NULL, 0,
404 MUSTEK_RETRIES, 5000, NULL, 0);
405 if (error)
406 return (error);
407
408 /*
409 * now check if scanner ready this time with update of size info
410 * we wait here so that if the user issues a read directly afterwards,
411 * the scanner will respond directly (otherwise we had to sleep with
412 * a buffer locked in memory)
413 */
414 SC_DEBUG(periph, SCSIPI_DB1, ("mustek_trigger_scanner: get_status\n"));
415 error = mustek_get_status(ss, 60, 1);
416 if (error)
417 return (error);
418
419 return (0);
420 }
421
422 /*
423 * stop a scan operation in progress
424 */
425 static int
426 mustek_rewind_scanner(struct ss_softc *ss)
427 {
428 struct mustek_start_scan_cmd cmd;
429 struct scsipi_periph *periph = ss->sc_periph;
430 int error;
431
432 if (ss->sio.scan_window_size != 0) {
433 /*
434 * only if not all data has been read, the scanner has to be
435 * stopped
436 */
437 memset(&cmd, 0, sizeof(cmd));
438 cmd.opcode = MUSTEK_START_STOP;
439 cmd.mode = MUSTEK_SCAN_STOP;
440
441 /* send the command to the scanner */
442 SC_DEBUG(periph, SCSIPI_DB1,
443 ("mustek_rewind_scanner: stop_scan\n"));
444 error = scsipi_command(periph,
445 (void *)&cmd, sizeof(cmd),
446 NULL, 0,
447 MUSTEK_RETRIES, 5000, NULL, 0);
448 if (error)
449 return (error);
450 }
451
452 SC_DEBUG(periph, SCSIPI_DB1, ("mustek_rewind_scanner: end\n"));
453
454 return (0);
455 }
456
457 /*
458 * read the requested number of bytes/lines from the scanner
459 */
460 static int
461 mustek_read(struct ss_softc *ss, struct buf *bp)
462 {
463 struct mustek_read_cmd cmd;
464 struct scsipi_xfer *xs;
465 struct scsipi_periph *periph = ss->sc_periph;
466 u_long lines_to_read;
467 int error;
468
469 SC_DEBUG(periph, SCSIPI_DB1, ("mustek_read: start\n"));
470
471 memset(&cmd, 0, sizeof(cmd));
472 cmd.opcode = MUSTEK_READ;
473
474 /* instead of the bytes, the mustek wants the number of lines */
475 lines_to_read = bp->b_bcount /
476 ((ss->sio.scan_pixels_per_line * ss->sio.scan_bits_per_pixel) / 8);
477 SC_DEBUG(periph, SCSIPI_DB1, ("mustek_read: read %ld lines\n",
478 lines_to_read));
479 _lto3b(lines_to_read, cmd.length);
480
481 /*
482 * go ask the adapter to do all this for us
483 */
484 xs = scsipi_make_xs(periph,
485 (struct scsipi_generic *) &cmd, sizeof(cmd),
486 (u_char *) bp->b_data, bp->b_bcount,
487 MUSTEK_RETRIES, 10000, bp,
488 XS_CTL_NOSLEEP | XS_CTL_ASYNC | XS_CTL_DATA_IN);
489 if (xs == NULL) {
490 /*
491 * out of memory. Keep this buffer in the queue, and
492 * retry later.
493 */
494 callout_reset(&ss->sc_callout, hz / 2, ssrestart,
495 periph);
496 return(0);
497 }
498 #ifdef DIAGNOSTIC
499 if (BUFQ_GET(&ss->buf_queue) != bp)
500 panic("ssstart(): dequeued wrong buf");
501 #else
502 BUFQ_GET(&ss->buf_queue);
503 #endif
504 error = scsipi_execute_xs(xs);
505 /* with a scsipi_xfer preallocated, scsipi_command can't fail */
506 KASSERT(error == 0);
507 ss->sio.scan_lines -= lines_to_read;
508 if (ss->sio.scan_lines < 0)
509 ss->sio.scan_lines = 0;
510 ss->sio.scan_window_size -= bp->b_bcount;
511 if (ss->sio.scan_window_size < 0)
512 ss->sio.scan_window_size = 0;
513 return (0);
514 }
515
516 /*
517 * check if the scanner is ready to take commands
518 * wait timeout seconds and try only every second
519 * if update, then update picture size info
520 *
521 * returns EBUSY if scanner not ready
522 */
523 static int
524 mustek_get_status(struct ss_softc *ss, int timeout, int update)
525 {
526 struct mustek_get_status_cmd cmd;
527 struct mustek_get_status_data data;
528 struct scsipi_periph *periph = ss->sc_periph;
529 int error, lines, bytes_per_line;
530
531 memset(&cmd, 0, sizeof(cmd));
532 cmd.opcode = MUSTEK_GET_STATUS;
533 cmd.length = sizeof(data);
534
535 while (1) {
536 SC_DEBUG(periph, SCSIPI_DB1, ("mustek_get_status: stat_cmd\n"));
537 error = scsipi_command(periph, (void *)&cmd, sizeof(cmd),
538 (void *)&data, sizeof(data),
539 MUSTEK_RETRIES, 5000, NULL, XS_CTL_DATA_IN | XS_CTL_DATA_ONSTACK);
540 if (error)
541 return (error);
542 if ((data.ready_busy == MUSTEK_READY) ||
543 (timeout-- <= 0))
544 break;
545 /* please wait a second */
546 tsleep((caddr_t)mustek_get_status, PRIBIO + 1, "mtkrdy", hz);
547 }
548
549 if (update) {
550 bytes_per_line = _2ltol(data.bytes_per_line);
551 lines = _3ltol(data.lines);
552 if (lines != ss->sio.scan_lines) {
553 printf("mustek: lines actual(%d) != computed(%ld)\n",
554 lines, ss->sio.scan_lines);
555 return (EIO);
556 }
557 if (bytes_per_line * lines != ss->sio.scan_window_size) {
558 printf("mustek: win-size actual(%d) != computed(%ld)\n",
559 bytes_per_line * lines, ss->sio.scan_window_size);
560 return (EIO);
561 }
562
563 SC_DEBUG(periph, SCSIPI_DB1,
564 ("mustek_get_size: bpl=%ld, lines=%ld\n",
565 (ss->sio.scan_pixels_per_line * ss->sio.scan_bits_per_pixel) / 8,
566 ss->sio.scan_lines));
567 SC_DEBUG(periph, SCSIPI_DB1, ("window size = %ld\n",
568 ss->sio.scan_window_size));
569 }
570
571 SC_DEBUG(periph, SCSIPI_DB1, ("mustek_get_status: end\n"));
572 if (data.ready_busy == MUSTEK_READY)
573 return (0);
574 else
575 return (EBUSY);
576 }
577
578 /*
579 * mustek_compute_sizes: compute window_size and lines for the picture
580 * this function is called from different places in the code
581 */
582 static void
583 mustek_compute_sizes(struct ss_softc *ss)
584 {
585
586 switch (ss->sio.scan_image_mode) {
587 case SIM_BINARY_MONOCHROME:
588 case SIM_DITHERED_MONOCHROME:
589 ss->sio.scan_bits_per_pixel = 1;
590 break;
591 case SIM_GRAYSCALE:
592 case SIM_RED:
593 case SIM_GREEN:
594 case SIM_BLUE:
595 ss->sio.scan_bits_per_pixel = 8;
596 break;
597 }
598
599 /*
600 * horizontal number of bytes is always a multiple of 2,
601 * in 8-bit mode at least
602 */
603 ss->sio.scan_pixels_per_line =
604 (ss->sio.scan_width * ss->sio.scan_x_resolution) / 1200;
605 if (ss->sio.scan_bits_per_pixel == 1)
606 /* make it a multiple of 16, and thus of 2 bytes */
607 ss->sio.scan_pixels_per_line =
608 (ss->sio.scan_pixels_per_line + 15) & 0xfffffff0;
609 else
610 ss->sio.scan_pixels_per_line =
611 (ss->sio.scan_pixels_per_line + 1) & 0xfffffffe;
612
613 ss->sio.scan_lines =
614 (ss->sio.scan_height * ss->sio.scan_y_resolution) / 1200;
615 ss->sio.scan_window_size = ss->sio.scan_lines *
616 ((ss->sio.scan_pixels_per_line * ss->sio.scan_bits_per_pixel) / 8);
617 }
Cache object: 8e088ef7c328ad597bde2bd86e602c46
|