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