The Design and Implementation of the FreeBSD Operating System, Second Edition
Now available: The Design and Implementation of the FreeBSD Operating System (Second Edition)


[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]

FreeBSD/Linux Kernel Cross Reference
sys/i386/isa/gsc.c

Version: -  FREEBSD  -  FREEBSD-13-STABLE  -  FREEBSD-13-0  -  FREEBSD-12-STABLE  -  FREEBSD-12-0  -  FREEBSD-11-STABLE  -  FREEBSD-11-0  -  FREEBSD-10-STABLE  -  FREEBSD-10-0  -  FREEBSD-9-STABLE  -  FREEBSD-9-0  -  FREEBSD-8-STABLE  -  FREEBSD-8-0  -  FREEBSD-7-STABLE  -  FREEBSD-7-0  -  FREEBSD-6-STABLE  -  FREEBSD-6-0  -  FREEBSD-5-STABLE  -  FREEBSD-5-0  -  FREEBSD-4-STABLE  -  FREEBSD-3-STABLE  -  FREEBSD22  -  l41  -  OPENBSD  -  linux-2.6  -  MK84  -  PLAN9  -  xnu-8792 
SearchContext: -  none  -  3  -  10 

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

Cache object: bbecfdabd99ab55145f8457b9d8e4c3d


[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]


This page is part of the FreeBSD/Linux Linux Kernel Cross-Reference, and was automatically generated using a modified version of the LXR engine.