24b5990f327e2484ac9992b3d3f5d471d161de2c
[dragonfly.git] / sys / dev / video / gsc / gsc.c
1 /* gsc.c - device driver for handy scanners
2  *
3  * Current version supports:
4  *
5  *      - Genius GS-4500
6  *
7  * Copyright (c) 1995 Gunther Schadow.  All rights reserved.
8  *
9  * Redistribution and use in source and binary forms, with or without
10  * modification, are permitted provided that the following conditions
11  * are met:
12  * 1. Redistributions of source code must retain the above copyright
13  *    notice, this list of conditions and the following disclaimer.
14  * 2. Redistributions in binary form must reproduce the above copyright
15  *    notice, this list of conditions and the following disclaimer in the
16  *    documentation and/or other materials provided with the distribution.
17  * 3. All advertising materials mentioning features or use of this software
18  *    must display the following acknowledgement:
19  *      This product includes software developed by Gunther Schadow.
20  * 4. The name of the author may not be used to endorse or promote products
21  *    derived from this software without specific prior written permission.
22  *
23  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
24  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
25  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
26  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
27  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
28  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
29  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
30  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
31  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
32  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
33  *
34  * $FreeBSD: src/sys/i386/isa/gsc.c,v 1.35.2.1 2000/08/08 19:49:53 peter Exp $
35  * $DragonFly: src/sys/dev/video/gsc/gsc.c,v 1.17 2008/08/02 01:14:43 dillon Exp $
36  *
37  */
38
39 #include "use_gsc.h"
40 #include <sys/param.h>
41 #include <sys/systm.h>
42 #include <sys/conf.h>
43 #include <sys/buf.h>
44 #include <sys/malloc.h>
45 #include <sys/kernel.h>
46 #include <sys/uio.h>
47 #include <sys/thread2.h>
48 #include <sys/bus.h>
49
50 #include <machine/gsc.h>
51
52 #include <bus/isa/isa.h>
53 #include <bus/isa/isa_device.h>
54 #include <bus/isa/isavar.h>
55 #include "gscreg.h"
56
57 /***********************************************************************
58  *
59  * CONSTANTS & DEFINES
60  *
61  ***********************************************************************/
62
63 #define PROBE_FAIL    0
64 #define PROBE_SUCCESS IO_GSCSIZE
65 #define ATTACH_FAIL   0
66 #define ATTACH_SUCCESS 1
67 #define SUCCESS       0
68 #define FAIL         -1
69 #define INVALID       FAIL
70
71 #define DMA1_READY  0x08
72
73 #ifdef GSCDEBUG
74 #define lprintf(args)                                           \
75                 do {                                            \
76                         if (scu->flags & FLAG_DEBUG)            \
77                                 kprintf args;                   \
78                 } while (0)
79 #else
80 #define lprintf(args)
81 #endif
82
83 #define TIMEOUT (hz*15)  /* timeout while reading a buffer - default value */
84 #define LONG    (hz/60)  /* timesteps while reading a buffer */
85
86 /***********************************************************************
87  *
88  * LAYOUT OF THE MINOR NUMBER
89  *
90  ***********************************************************************/
91
92 #define UNIT_MASK 0xc0    /* unit gsc0 .. gsc3 */
93 #define UNIT(x)   (x >> 6)
94 #define DBUG_MASK 0x20
95 #define FRMT_MASK 0x18    /* output format */
96 #define FRMT_RAW  0x00    /* output bits as read from scanner */
97 #define FRMT_GRAY 0x10    /* output graymap (not implemented yet) */
98 #define FRMT_PBM  0x08    /* output pbm format */
99 #define FRMT_PGM  0x18
100
101 /***********************************************************************
102  *
103  * THE GEMOMETRY TABLE
104  *
105  ***********************************************************************/
106
107 #define GEOMTAB_SIZE 7
108
109 static const struct gsc_geom {
110   int dpi;     /* dots per inch */
111   int dpl;     /* dots per line */
112   int g_res;   /* get resolution value (status flag) */
113   int s_res;   /* set resolution value (control register) */
114 } geomtab[GEOMTAB_SIZE] = {
115   { 100,  424, GSC_RES_100, GSC_CNT_424},
116   { 200,  840, GSC_RES_200, GSC_CNT_840},
117   { 300, 1264, GSC_RES_300, GSC_CNT_1264},
118   { 400, 1648, GSC_RES_400, GSC_CNT_1648},
119   {  -1, 1696,          -1, GSC_CNT_1696},
120   {  -2, 2644,          -2, GSC_CNT_2544},
121   {  -3, 3648,          -3, GSC_CNT_3648},
122 };
123
124 #define NEW_GEOM { INVALID, INVALID, INVALID, INVALID }
125
126 /***********************************************************************
127  *
128  * THE TABLE OF UNITS
129  *
130  ***********************************************************************/
131
132 struct _sbuf {
133   size_t  size;
134   size_t  poi;
135   char   *base;
136 };
137
138 struct gsc_unit {
139   int channel;            /* DMA channel */
140   int data;               /* - video port */
141   int stat;               /* - status port */
142   int ctrl;               /* - control port */
143   int clrp;               /* - clear port */
144   int flags;
145 #define ATTACHED 0x01
146 #define OPEN     0x02
147 #define READING  0x04
148 #define EOF      0x08
149 #define FLAG_DEBUG  0x10
150 #define PBM_MODE 0x20
151   int     geometry;       /* resolution as geomtab index */
152   int     blen;           /* length of buffer in lines */
153   int     btime;          /* timeout of buffer in seconds/hz */
154   struct  _sbuf sbuf;
155   char    ctrl_byte;      /* the byte actually written to ctrl port */
156   int     height;         /* height, for pnm modes */
157   size_t  bcount;         /* bytes to read, for pnm modes */
158   struct  _sbuf hbuf;     /* buffer for pnm header data */
159 };
160
161 static struct gsc_unit unittab[NGSC];
162
163 /* I could not find a reasonable buffer size limit other than by
164  * experiments. MAXPHYS is obviously too much, while DEV_BSIZE and
165  * PAGE_SIZE are really too small. There must be something wrong
166  * with isa_dmastart/isa_dmarangecheck HELP!!!
167  */
168 #define MAX_BUFSIZE 0x3000
169 #define DEFAULT_BLEN 59
170
171 /***********************************************************************
172  *
173  * THE PER-DRIVER RECORD FOR ISA.C
174  *
175  ***********************************************************************/
176
177 static  int gscprobe (struct isa_device *isdp);
178 static  int gscattach(struct isa_device *isdp);
179
180 struct isa_driver gscdriver = { gscprobe, gscattach, "gsc" };
181
182 static  d_open_t        gscopen;
183 static  d_close_t       gscclose;
184 static  d_read_t        gscread;
185 static  d_ioctl_t       gscioctl;
186
187 #define CDEV_MAJOR 47
188 static struct dev_ops gsc_ops = {
189         { "gsc", CDEV_MAJOR, 0 },
190         .d_open =       gscopen,
191         .d_close =      gscclose,
192         .d_read =       gscread,
193         .d_ioctl =      gscioctl,
194 };
195
196
197 /***********************************************************************
198  *
199  * LOCALLY USED SUBROUTINES
200  *
201  ***********************************************************************/
202
203 /***********************************************************************
204  *
205  * lookup_geometry -- lookup a record in the geometry table by pattern
206  *
207  * The caller supplies a geometry record pattern, where INVALID
208  * matches anything. Returns the index in the table or INVALID if
209  * lookup fails.
210  */
211
212 static int
213 lookup_geometry(struct gsc_geom geom, const struct gsc_unit *scu)
214 {
215   struct gsc_geom tab;
216   int i;
217
218   for(i=0; i<GEOMTAB_SIZE; i++)
219     {
220       tab = geomtab[i];
221
222       if ( ( ( geom.dpi   != INVALID ) && ( tab.dpi   == geom.dpi   ) ) ||
223            ( ( geom.dpl   != INVALID ) && ( tab.dpl   == geom.dpl   ) ) ||
224            ( ( geom.g_res != INVALID ) && ( tab.g_res == geom.g_res ) ) ||
225            ( ( geom.s_res != INVALID ) && ( tab.s_res == geom.s_res ) ) )
226         {
227           lprintf(("gsc.lookup_geometry: "
228                  "geometry lookup found: %ddpi, %ddpl\n",
229                  tab.dpi, tab.dpl));
230           return i;
231         }
232     }
233
234   lprintf(("gsc.lookup_geometry: "
235          "geometry lookup failed on {%d, %d, 0x%02x, 0x%02x}\n",
236          geom.dpi, geom.dpl, geom.g_res, geom.s_res));
237
238   return INVALID;
239 }
240
241 /***********************************************************************
242  *
243  * get_geometry -- read geometry from status port
244  *
245  * Returns the index into geometry table or INVALID if it fails to
246  * either read the status byte or lookup the record.
247  */
248
249 static int
250 get_geometry(const struct gsc_unit *scu)
251 {
252   struct gsc_geom geom = NEW_GEOM;
253
254   lprintf(("gsc.get_geometry: get geometry at 0x%03x\n", scu->stat));
255
256   if ( ( geom.g_res = inb(scu->stat) ) == FAIL )
257     return INVALID;
258
259   geom.g_res &= GSC_RES_MASK;
260
261   return lookup_geometry(geom, scu);
262 }
263
264 /***********************************************************************
265  *
266  * buffer_allocate -- allocate/reallocate a buffer
267  * Now just checks that the preallocated buffer is large enough.
268  */
269
270 static int
271 buffer_allocate(struct gsc_unit *scu)
272 {
273   size_t size;
274
275   size = scu->blen * geomtab[scu->geometry].dpl / 8;
276
277   lprintf(("gsc.buffer_allocate: need 0x%x bytes\n", size));
278
279   if ( size > MAX_BUFSIZE )
280     {
281       lprintf(("gsc.buffer_allocate: 0x%x bytes are too much\n", size));
282       return ENOMEM;
283     }
284
285   scu->sbuf.size = size;
286   scu->sbuf.poi  = size;
287
288   lprintf(("gsc.buffer_allocate: ok\n"));
289
290   return SUCCESS;
291 }
292
293 /***********************************************************************
294  *
295  * buffer_read -- scan a buffer
296  */
297
298 static int
299 buffer_read(struct gsc_unit *scu)
300 {
301   int stb;
302   int res = SUCCESS;
303   int chan_bit;
304   char *p;
305   int delay;
306
307   lprintf(("gsc.buffer_read: begin\n"));
308
309   if (scu->ctrl_byte == INVALID)
310     {
311       lprintf(("gsc.buffer_read: invalid ctrl_byte\n"));
312       return EIO;
313     }
314
315   crit_enter();
316
317   outb( scu->ctrl, scu->ctrl_byte | GSC_POWER_ON );
318   outb( scu->clrp, 0 );
319   stb = inb( scu->stat );
320
321   isa_dmastart(BUF_CMD_READ, scu->sbuf.base, scu->sbuf.size, scu->channel);
322
323   chan_bit = 0x01 << scu->channel;
324
325   for(delay=0; !(inb(DMA1_READY) & 0x01 << scu->channel); delay += LONG)
326     {
327       if(delay >= scu->btime)
328         {
329           crit_exit();
330           lprintf(("gsc.buffer_read: timeout\n"));
331           res = EWOULDBLOCK;
332           break;
333         }
334       res = tsleep((caddr_t)scu, PCATCH, "gscread", LONG);
335       if ( ( res == 0 ) || ( res == EWOULDBLOCK ) )
336         res = SUCCESS;
337       else
338         break;
339     }
340   crit_exit();
341   isa_dmadone(BUF_CMD_READ, scu->sbuf.base, scu->sbuf.size, scu->channel);
342   outb( scu->clrp, 0 );
343
344   if(res != SUCCESS)
345     {
346       lprintf(("gsc.buffer_read: aborted with %d\n", res));
347       return res;
348     }
349
350   lprintf(("gsc.buffer_read: invert buffer\n"));
351   for(p = scu->sbuf.base + scu->sbuf.size - 1; p >= scu->sbuf.base; p--)
352     *p = ~*p;
353
354   scu->sbuf.poi = 0;
355   lprintf(("gsc.buffer_read: ok\n"));
356   return SUCCESS;
357 }
358
359 /***********************************************************************
360  *
361  * the main functions
362  *
363  ***********************************************************************/
364
365 /***********************************************************************
366  *
367  * gscprobe
368  *
369  * read status port and check for proper configuration:
370  *  - if address group matches (status byte has reasonable value)
371  *  - if DMA channel matches   (status byte has correct value)
372  */
373
374 static int
375 gscprobe (struct isa_device *isdp)
376 {
377   int unit = isdp->id_unit;
378   struct gsc_unit *scu = unittab + unit;
379   int stb;
380   struct gsc_geom geom = NEW_GEOM;
381
382   scu->flags = FLAG_DEBUG;
383
384   lprintf(("gsc%d.probe "
385          "on iobase 0x%03x, irq %d, drq %d, addr %p, size %d\n",
386          unit,
387          isdp->id_iobase,
388          isdp->id_irq,
389          isdp->id_drq,
390          isdp->id_maddr,
391          isdp->id_msize));
392
393   if ( isdp->id_iobase < 0 )
394     {
395       lprintf(("gsc%d.probe: no iobase given\n", unit));
396       return PROBE_FAIL;
397     }
398
399   stb = inb( GSC_STAT(isdp->id_iobase) );
400   if (stb == FAIL)
401     {
402       lprintf(("gsc%d.probe: get status byte failed\n", unit));
403       return PROBE_FAIL;
404     }
405
406   scu->data = GSC_DATA(isdp->id_iobase);
407   scu->stat = GSC_STAT(isdp->id_iobase);
408   scu->ctrl = GSC_CTRL(isdp->id_iobase);
409   scu->clrp = GSC_CLRP(isdp->id_iobase);
410
411   outb(scu->clrp,stb);
412   stb = inb(scu->stat);
413
414   switch(stb & GSC_CNF_MASK) {
415   case GSC_CNF_DMA1:
416     lprintf(("gsc%d.probe: DMA 1\n", unit));
417     scu->channel = 1;
418     break;
419
420   case GSC_CNF_DMA3:
421     lprintf(("gsc%d.probe: DMA 3\n", unit));
422     scu->channel = 3;
423     break;
424
425   case GSC_CNF_IRQ3:
426     lprintf(("gsc%d.probe: IRQ 3\n", unit));
427     goto probe_noirq;
428   case GSC_CNF_IRQ5:
429     lprintf(("gsc%d.probe: IRQ 5\n", unit));
430   probe_noirq:
431     lprintf(("gsc%d.probe: sorry, can't use IRQ yet\n", unit));
432     return PROBE_FAIL;
433   default:
434     lprintf(("gsc%d.probe: invalid status byte 0x%02x\n", unit, (u_char) stb));
435     return PROBE_FAIL;
436   }
437
438   if (isdp->id_drq < 0)
439     isdp->id_drq = scu->channel;
440   if (scu->channel != isdp->id_drq)
441     {
442       lprintf(("gsc%d.probe: drq mismatch: config: %d; hardware: %d\n",
443               unit, isdp->id_drq, scu->channel));
444       return PROBE_FAIL;
445     }
446
447   geom.g_res = stb & GSC_RES_MASK;
448   scu->geometry = lookup_geometry(geom, scu);
449   if (scu->geometry == INVALID)
450     {
451       lprintf(("gsc%d.probe: geometry lookup failed\n", unit));
452       return PROBE_FAIL;
453     }
454   else
455     {
456       scu->ctrl_byte = geomtab[scu->geometry].s_res;
457       outb(scu->ctrl, scu->ctrl_byte | GSC_POWER_ON);
458
459       lprintf(("gsc%d.probe: status 0x%02x, %ddpi\n",
460              unit, stb, geomtab[scu->geometry].dpi));
461
462       outb(scu->ctrl, scu->ctrl_byte & ~GSC_POWER_ON);
463     }
464
465   lprintf(("gsc%d.probe: ok\n", unit));
466
467   scu->flags &= ~FLAG_DEBUG;
468
469   return PROBE_SUCCESS;
470 }
471
472 /***********************************************************************
473  *
474  * gscattach
475  *
476  * finish initialization of unit structure
477  * get geometry value
478  */
479
480 static int
481 gscattach(struct isa_device *isdp)
482 {
483   int unit = isdp->id_unit;
484   struct gsc_unit *scu = unittab + unit;
485
486   scu->flags |= FLAG_DEBUG;
487
488   lprintf(("gsc%d.attach: "
489          "iobase 0x%03x, irq %d, drq %d, addr %p, size %d\n",
490          unit,
491          isdp->id_iobase,
492          isdp->id_irq,
493          isdp->id_drq,
494          isdp->id_maddr,
495          isdp->id_msize));
496
497   kprintf("gsc%d: GeniScan GS-4500 at %ddpi\n",
498          unit, geomtab[scu->geometry].dpi);
499
500   /*
501    * Initialize buffer structure.
502    * XXX this must be done early to give a good chance of getting a
503    * contiguous buffer.  This wastes memory.
504    */
505   scu->sbuf.base = contigmalloc((unsigned long)MAX_BUFSIZE, M_DEVBUF, M_NOWAIT,
506                                 0ul, 0xfffffful, 1ul, 0x10000ul);
507   if ( scu->sbuf.base == NULL )
508     {
509       lprintf(("gsc%d.attach: buffer allocation failed\n", unit));
510       return ATTACH_FAIL;       /* XXX attach must not fail */
511     }
512   scu->sbuf.size = INVALID;
513   scu->sbuf.poi  = INVALID;
514
515   scu->blen = DEFAULT_BLEN;
516   scu->btime = TIMEOUT;
517
518   scu->flags |= ATTACHED;
519   lprintf(("gsc%d.attach: ok\n", unit));
520   scu->flags &= ~FLAG_DEBUG;
521 #define GSC_UID 0
522 #define GSC_GID 13
523   dev_ops_add(&gsc_ops, 0xc0, unit << 6);
524   make_dev(&gsc_ops, unit<<6, GSC_UID, GSC_GID, 0666, "gsc%d", unit);
525   make_dev(&gsc_ops, ((unit<<6) + FRMT_PBM),
526      GSC_UID,  GSC_GID, 0666, "gsc%dp", unit);
527   make_dev(&gsc_ops, ((unit<<6) + DBUG_MASK),
528      GSC_UID,  GSC_GID, 0666, "gsc%dd", unit);
529   make_dev(&gsc_ops, ((unit<<6) + DBUG_MASK+FRMT_PBM),
530      GSC_UID,  GSC_GID, 0666, "gsc%dpd", unit);
531
532   return ATTACH_SUCCESS;
533 }
534
535 /***********************************************************************
536  *
537  * gscopen
538  *
539  * set open flag
540  * set modes according to minor number
541  * don't switch scanner on, wait until first read ioctls go before
542  */
543
544 static  int
545 gscopen  (struct dev_open_args *ap)
546 {
547   cdev_t dev = ap->a_head.a_dev;
548   struct gsc_unit *scu;
549   int unit;
550
551   unit = UNIT(minor(dev)) & UNIT_MASK;
552   if ( unit >= NGSC )
553     {
554 #ifdef GSCDEBUG
555       /* XXX lprintf isn't valid here since there is no scu. */
556       kprintf("gsc%d.open: unconfigured unit number (max %d)\n", unit, NGSC);
557 #endif
558       return ENXIO;
559     }
560   scu = unittab + unit;
561   if ( !( scu->flags & ATTACHED ) )
562     {
563       lprintf(("gsc%d.open: unit was not attached successfully 0x%04x\n",
564              unit, scu->flags));
565       return ENXIO;
566     }
567
568   if ( minor(dev) & DBUG_MASK )
569     scu->flags |= FLAG_DEBUG;
570   else
571     scu->flags &= ~FLAG_DEBUG;
572
573   switch(minor(dev) & FRMT_MASK) {
574   case FRMT_PBM:
575     scu->flags |= PBM_MODE;
576     lprintf(("gsc%d.open: pbm mode\n", unit));
577     break;
578   case FRMT_RAW:
579     lprintf(("gsc%d.open: raw mode\n", unit));
580     scu->flags &= ~PBM_MODE;
581     break;
582   default:
583     lprintf(("gsc%d.open: gray maps are not yet supported", unit));
584     return ENXIO;
585   }
586
587   lprintf(("gsc%d.open: minor %d\n",
588          unit, minor(dev)));
589
590   if ( scu->flags & OPEN )
591     {
592       lprintf(("gsc%d.open: already open", unit));
593       return EBUSY;
594     }
595
596   if (isa_dma_acquire(scu->channel))
597       return(EBUSY);
598
599   scu->flags |= OPEN;
600
601   return SUCCESS;
602 }
603
604 /***********************************************************************
605  *
606  * gscclose
607  *
608  * turn off scanner
609  * release the buffer
610  */
611
612 static  int
613 gscclose (struct dev_close_args *ap)
614 {
615   cdev_t dev = ap->a_head.a_dev;
616   int unit = UNIT(minor(dev));
617   struct gsc_unit *scu = unittab + unit;
618
619   lprintf(("gsc%d.close: minor %d\n",
620          unit, minor(dev)));
621
622   if ( unit >= NGSC || !( scu->flags & ATTACHED ) )
623     {
624       lprintf(("gsc%d.read: unit was not attached successfully 0x%04x\n",
625              unit, scu->flags));
626       return ENXIO;
627     }
628
629   outb(scu->ctrl, scu->ctrl_byte & ~GSC_POWER_ON);
630
631   scu->sbuf.size = INVALID;
632   scu->sbuf.poi  = INVALID;
633
634   isa_dma_release(scu->channel);
635
636   scu->flags &= ~(FLAG_DEBUG | OPEN | READING);
637
638   return SUCCESS;
639 }
640
641 /***********************************************************************
642  *
643  * gscread
644  */
645
646 static  int
647 gscread  (struct dev_read_args *ap)
648 {
649   cdev_t dev = ap->a_head.a_dev;
650   struct uio *uio = ap->a_uio;
651   int unit = UNIT(minor(dev));
652   struct gsc_unit *scu = unittab + unit;
653   size_t nbytes;
654   int res;
655
656   lprintf(("gsc%d.read: minor %d\n", unit, minor(dev)));
657
658   if ( unit >= NGSC || !( scu->flags & ATTACHED ) )
659     {
660       lprintf(("gsc%d.read: unit was not attached successfully 0x%04x\n",
661              unit, scu->flags));
662       return ENXIO;
663     }
664
665   if ( !(scu->flags & READING) )
666     {
667       res = buffer_allocate(scu);
668       if ( res == SUCCESS )
669         scu->flags |= READING;
670       else
671         return res;
672
673       scu->ctrl_byte = geomtab[scu->geometry].s_res;
674
675       /* initialize for pbm mode */
676       if ( scu->flags & PBM_MODE )
677         {
678           char *p;
679           int width = geomtab[scu->geometry].dpl;
680
681           ksprintf(scu->sbuf.base,"P4 %d %d\n", width, scu->height);
682           scu->bcount = scu->height * width / 8;
683
684           lprintf(("gsc%d.read: initializing pbm mode: `%s', bcount: 0x%x\n",
685                   unit, scu->sbuf.base, scu->bcount));
686
687           /* move header to end of sbuf */
688           for(p=scu->sbuf.base; *p; p++);
689           while(--p >= scu->sbuf.base)
690             {
691               *(char *)(scu->sbuf.base + --scu->sbuf.poi) = *p;
692               scu->bcount++;
693             }
694         }
695     }
696
697   lprintf(("gsc%d.read(before buffer_read): "
698           "size 0x%x, pointer 0x%x, bcount 0x%x, ok\n",
699           unit, scu->sbuf.size, scu->sbuf.poi, scu->bcount));
700
701   if ( scu->sbuf.poi == scu->sbuf.size )
702     if ( (res = buffer_read(scu)) != SUCCESS )
703       return res;
704
705   lprintf(("gsc%d.read(after buffer_read): "
706           "size 0x%x, pointer 0x%x, bcount 0x%x, ok\n",
707           unit, scu->sbuf.size, scu->sbuf.poi, scu->bcount));
708
709   nbytes = MIN( uio->uio_resid, scu->sbuf.size - scu->sbuf.poi );
710
711   if ( (scu->flags & PBM_MODE) )
712     nbytes = MIN( nbytes, scu->bcount );
713
714   lprintf(("gsc%d.read: transferring 0x%x bytes", unit, nbytes));
715
716   res = uiomove(scu->sbuf.base + scu->sbuf.poi, nbytes, uio);
717   if ( res != SUCCESS )
718     {
719       lprintf(("gsc%d.read: uiomove failed %d", unit, res));
720       return res;
721     }
722
723   scu->sbuf.poi += nbytes;
724   if ( scu->flags & PBM_MODE ) scu->bcount -= nbytes;
725
726   lprintf(("gsc%d.read: size 0x%x, pointer 0x%x, bcount 0x%x, ok\n",
727           unit, scu->sbuf.size, scu->sbuf.poi, scu->bcount));
728
729   return SUCCESS;
730 }
731
732 /***********************************************************************
733  *
734  * gscioctl
735  *
736  */
737
738 static  int
739 gscioctl (struct dev_ioctl_args *ap)
740 {
741   cdev_t dev = ap->a_head.a_dev;
742   caddr_t data = ap->a_data;
743   int unit = UNIT(minor(dev));
744   struct gsc_unit *scu = unittab + unit;
745
746   lprintf(("gsc%d.ioctl: minor %d\n",
747          unit, minor(dev)));
748
749   if ( unit >= NGSC || !( scu->flags & ATTACHED ) )
750     {
751       lprintf(("gsc%d.ioctl: unit was not attached successfully 0x%04x\n",
752              unit, scu->flags));
753       return ENXIO;
754     }
755
756   switch(ap->a_cmd) {
757   case GSC_SRESSW:
758     lprintf(("gsc%d.ioctl:GSC_SRESSW\n", unit));
759     if ( scu->flags & READING )
760       {
761         lprintf(("gsc%d:ioctl on already reading unit\n", unit));
762         return EBUSY;
763       }
764     scu->geometry = get_geometry(scu);
765     return SUCCESS;
766   case GSC_GRES:
767     *(int *)data=geomtab[scu->geometry].dpi;
768     lprintf(("gsc%d.ioctl:GSC_GRES %ddpi\n", unit, *(int *)data));
769     return SUCCESS;
770   case GSC_GWIDTH:
771     *(int *)data=geomtab[scu->geometry].dpl;
772     lprintf(("gsc%d.ioctl:GSC_GWIDTH %d\n", unit, *(int *)data));
773     return SUCCESS;
774   case GSC_SRES:
775   case GSC_SWIDTH:
776     lprintf(("gsc%d.ioctl:GSC_SRES or GSC_SWIDTH %d\n",
777            unit, *(int *)data));
778     { int g;
779       struct gsc_geom geom = NEW_GEOM;
780       if ( ap->a_cmd == GSC_SRES )
781         geom.dpi = *(int *)data;
782       else
783         geom.dpl = *(int *)data;
784       if ( ( g = lookup_geometry(geom, scu) ) == INVALID )
785         return EINVAL;
786       scu->geometry = g;
787       return SUCCESS;
788     }
789   case GSC_GHEIGHT:
790     *(int *)data=scu->height;
791     lprintf(("gsc%d.ioctl:GSC_GHEIGHT %d\n", unit, *(int *)data));
792     return SUCCESS;
793   case GSC_SHEIGHT:
794     lprintf(("gsc%d.ioctl:GSC_SHEIGHT %d\n", unit, *(int *)data));
795     if ( scu->flags & READING )
796       {
797         lprintf(("gsc%d:ioctl on already reading unit\n", unit));
798         return EBUSY;
799       }
800     scu->height=*(int *)data;
801     return SUCCESS;
802   case GSC_GBLEN:
803     *(int *)data=scu->blen;
804     lprintf(("gsc%d.ioctl:GSC_GBLEN %d\n", unit, *(int *)data));
805     return SUCCESS;
806   case GSC_SBLEN:
807     lprintf(("gsc%d.ioctl:GSC_SBLEN %d\n", unit, *(int *)data));
808     if (*(int *)data * geomtab[scu->geometry].dpl / 8 > MAX_BUFSIZE)
809       {
810         lprintf(("gsc%d:ioctl buffer size too high\n", unit));
811         return ENOMEM;
812       }
813     scu->blen=*(int *)data;
814     return SUCCESS;
815   case GSC_GBTIME:
816     *(int *)data = scu->btime / hz;
817     lprintf(("gsc%d.ioctl:GSC_GBTIME %d\n", unit, *(int *)data));
818     return SUCCESS;
819   case GSC_SBTIME:
820     scu->btime = *(int *)data * hz;
821     lprintf(("gsc%d.ioctl:GSC_SBTIME %d\n", unit, *(int *)data));
822     return SUCCESS;
823   default: return ENOTTY;
824   }
825 }