/*      $NetBSD: par.c,v 1.45 2024/01/07 07:58:33 isaki Exp $   */

/*
* Copyright (c) 1982, 1990 The Regents of the University of California.
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
*    notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
*    notice, this list of conditions and the following disclaimer in the
*    documentation and/or other materials provided with the distribution.
* 3. Neither the name of the University nor the names of its contributors
*    may be used to endorse or promote products derived from this software
*    without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*
*      @(#)ppi.c       7.3 (Berkeley) 12/16/90
*/

/*
* parallel port interface
*/

#include <sys/cdefs.h>
__KERNEL_RCSID(0, "$NetBSD: par.c,v 1.45 2024/01/07 07:58:33 isaki Exp $");

#include <sys/param.h>
#include <sys/errno.h>
#include <sys/uio.h>
#include <sys/device.h>
#include <sys/malloc.h>
#include <sys/file.h>
#include <sys/systm.h>
#include <sys/callout.h>
#include <sys/proc.h>
#include <sys/conf.h>
#include <sys/kernel.h>

#include <machine/bus.h>
#include <machine/cpu.h>
#include <machine/parioctl.h>

#include <arch/x68k/dev/intiovar.h>

#include "ioconf.h"

struct  par_softc {
       device_t                sc_dev;

       bus_space_tag_t         sc_bst;
       bus_space_handle_t      sc_bsh;
       int                     sc_flags;
       struct parparam         sc_param;
#define sc_burst        sc_param.burst
#define sc_timo         sc_param.timo
#define sc_delay        sc_param.delay
       struct callout          sc_timo_ch;
       struct callout          sc_start_ch;
} ;

/* par registers */
#define PAR_DATA        1
#define PAR_STROBE      3

/* sc_flags values */
#define PARF_ALIVE      0x01
#define PARF_OPEN       0x02
#define PARF_UIO        0x04
#define PARF_TIMO       0x08
#define PARF_DELAY      0x10
#define PARF_OREAD      0x40    /* no support */
#define PARF_OWRITE     0x80


void partimo(void *);
void parstart(void *);
void parintr(void *);
int parrw(dev_t, struct uio *);
int parhztoms(int);
int parmstohz(int);
int parsendch(struct par_softc *, u_char);
int parsend(struct par_softc *, u_char *, int);

static struct callout intr_callout;

#define UNIT(x)         minor(x)

#ifdef DEBUG
#define PDB_FOLLOW      0x01
#define PDB_IO          0x02
#define PDB_INTERRUPT   0x04
#define PDB_NOCHECK     0x80
#ifdef PARDEBUG
int     pardebug = PDB_FOLLOW | PDB_IO | PDB_INTERRUPT;
#else
int     pardebug = 0;
#endif
#endif

int parmatch(device_t, cfdata_t, void *);
void parattach(device_t, device_t, void *);

CFATTACH_DECL_NEW(par, sizeof(struct par_softc),
   parmatch, parattach, NULL, NULL);

static int par_attached;

dev_type_open(paropen);
dev_type_close(parclose);
dev_type_write(parwrite);
dev_type_ioctl(parioctl);

const struct cdevsw par_cdevsw = {
       .d_open = paropen,
       .d_close = parclose,
       .d_read = noread,
       .d_write = parwrite,
       .d_ioctl = parioctl,
       .d_stop = nostop,
       .d_tty = notty,
       .d_poll = nopoll,
       .d_mmap = nommap,
       .d_kqfilter = nokqfilter,
       .d_discard = nodiscard,
       .d_flag = 0
};

int
parmatch(device_t parent, cfdata_t cf, void *aux)
{
       struct intio_attach_args *ia = aux;

       /* X680x0 has only one parallel port */
       if (strcmp(ia->ia_name, "par") || par_attached)
               return 0;

       if (ia->ia_addr == INTIOCF_ADDR_DEFAULT)
               ia->ia_addr = 0xe8c000;
       ia->ia_size = 0x2000;
       if (intio_map_allocate_region(parent, ia, INTIO_MAP_TESTONLY))
               return 0;
       if (ia->ia_intr == INTIOCF_INTR_DEFAULT)
               ia->ia_intr = 99;
#if DIAGNOSTIC
       if (ia->ia_intr != 99)
               return 0;
#endif

       return 1;
}

void
parattach(device_t parent, device_t self, void *aux)
{
       struct par_softc *sc = device_private(self);
       struct intio_attach_args *ia = aux;
       int r __diagused;

       par_attached = 1;

       sc->sc_dev = self;
       sc->sc_flags = PARF_ALIVE;
       aprint_normal(": parallel port (write only, interrupt)\n");
       ia->ia_size = 0x2000;
       r = intio_map_allocate_region(parent, ia, INTIO_MAP_ALLOCATE);
#ifdef DIAGNOSTIC
       if (r)
               panic("IO map for PAR corruption??");
#endif
       sc->sc_bst = ia->ia_bst;
       r = bus_space_map(sc->sc_bst,
                          ia->ia_addr, ia->ia_size,
                          BUS_SPACE_MAP_SHIFTED,
                          &sc->sc_bsh);
#ifdef DIAGNOSTIC
       if (r)
               panic("Cannot map IO space for PAR.");
#endif

       intio_set_sicilian_intr(intio_get_sicilian_intr() &
                               ~SICILIAN_INTR_PAR);

       intio_intr_establish(ia->ia_intr, "par",
                            (intio_intr_handler_t)parintr, (void *)1);

       callout_init(&sc->sc_timo_ch, 0);
       callout_init(&sc->sc_start_ch, 0);
       callout_init(&intr_callout, 0);
}

int
paropen(dev_t dev, int flags, int mode, struct lwp *l)
{
       int unit = UNIT(dev);
       struct par_softc *sc;

       sc = device_lookup_private(&par_cd, unit);
       if (sc == NULL || !(sc->sc_flags & PARF_ALIVE))
               return(ENXIO);
       if (sc->sc_flags & PARF_OPEN)
               return(EBUSY);
       /* X680x0 can't read */
       if ((flags & FREAD) == FREAD)
               return (EINVAL);

       sc->sc_flags |= PARF_OPEN;

       sc->sc_flags |= PARF_OWRITE;

       sc->sc_burst = PAR_BURST;
       sc->sc_timo = parmstohz(PAR_TIMO);
       sc->sc_delay = parmstohz(PAR_DELAY);

       return(0);
}

int
parclose(dev_t dev, int flags, int mode, struct lwp *l)
{
       int unit = UNIT(dev);
       int s;
       struct par_softc *sc = device_lookup_private(&par_cd, unit);

       sc->sc_flags &= ~(PARF_OPEN|PARF_OWRITE);

       /* don't allow interrupts any longer */
       s = spl1();
       intio_set_sicilian_intr(intio_get_sicilian_intr() &
                               ~SICILIAN_INTR_PAR);
       splx(s);

       return (0);
}

void
parstart(void *arg)
{
       struct par_softc *sc = arg;
#ifdef DEBUG
       if (pardebug & PDB_FOLLOW)
               printf("parstart(%x)\n", device_unit(sc->sc_dev));
#endif
       sc->sc_flags &= ~PARF_DELAY;
       wakeup(sc);
}

void
partimo(void *arg)
{
       struct par_softc *sc = arg;
#ifdef DEBUG
       if (pardebug & PDB_FOLLOW)
               printf("partimo(%x)\n", device_unit(sc->sc_dev));
#endif
       sc->sc_flags &= ~(PARF_UIO|PARF_TIMO);
       wakeup(sc);
}

int
parwrite(dev_t dev, struct uio *uio, int flag)
{

#ifdef DEBUG
       if (pardebug & PDB_FOLLOW)
               printf("parwrite(%x, %p)\n", UNIT(dev), uio);
#endif
       return (parrw(dev, uio));
}

int
parrw(dev_t dev, struct uio *uio)
{
       int unit = UNIT(dev);
       struct par_softc *sc = device_lookup_private(&par_cd, unit);
       int len=0xdeadbeef;     /* XXX: shutup gcc */
       int s, cnt=0;
       char *cp;
       int error = 0;
       int buflen;
       char *buf;

       if (!!(sc->sc_flags & PARF_OREAD) ^ (uio->uio_rw == UIO_READ))
               return EINVAL;

       if (uio->uio_resid == 0)
               return(0);

       buflen = uimin(sc->sc_burst, uio->uio_resid);
       buf = (char *)malloc(buflen, M_DEVBUF, M_WAITOK);
       sc->sc_flags |= PARF_UIO;
       if (sc->sc_timo > 0) {
               sc->sc_flags |= PARF_TIMO;
               callout_reset(&sc->sc_timo_ch, sc->sc_timo, partimo, sc);
       }
       while (uio->uio_resid > 0) {
               len = uimin(buflen, uio->uio_resid);
               cp = buf;
               if (uio->uio_rw == UIO_WRITE) {
                       error = uiomove(cp, len, uio);
                       if (error)
                               break;
               }
             again:
               s = splsoftclock();
               /*
                * Check if we timed out during sleep or uiomove
                */
               if ((sc->sc_flags & PARF_UIO) == 0) {
#ifdef DEBUG
                       if (pardebug & PDB_IO)
                               printf("parrw: uiomove/sleep timo, flags %x\n",
                                      sc->sc_flags);
#endif
                       if (sc->sc_flags & PARF_TIMO) {
                               callout_stop(&sc->sc_timo_ch);
                               sc->sc_flags &= ~PARF_TIMO;
                       }
                       splx(s);
                       break;
               }
               splx(s);
               /*
                * Perform the operation
                */
               cnt = parsend(sc, cp, len);
               if (cnt < 0) {
                       error = -cnt;
                       break;
               }

               s = splsoftclock();
               /*
                * Operation timeout (or non-blocking), quit now.
                */
               if ((sc->sc_flags & PARF_UIO) == 0) {
#ifdef DEBUG
                       if (pardebug & PDB_IO)
                               printf("parrw: timeout/done\n");
#endif
                       splx(s);
                       break;
               }
               /*
                * Implement inter-read delay
                */
               if (sc->sc_delay > 0) {
                       sc->sc_flags |= PARF_DELAY;
                       callout_reset(&sc->sc_start_ch, sc->sc_delay,
                           parstart, sc);
                       error = tsleep(sc, PCATCH|(PZERO-1), "par-cdelay", 0);
                       if (error) {
                               splx(s);
                               break;
                       }
               }
               splx(s);
               /*
                * Must not call uiomove again til we've used all data
                * that we already grabbed.
                */
               if (uio->uio_rw == UIO_WRITE && cnt != len) {
                       cp += cnt;
                       len -= cnt;
                       cnt = 0;
                       goto again;
               }
       }
       s = splsoftclock();
       if (sc->sc_flags & PARF_TIMO) {
               callout_stop(&sc->sc_timo_ch);
               sc->sc_flags &= ~PARF_TIMO;
       }
       if (sc->sc_flags & PARF_DELAY)  {
               callout_stop(&sc->sc_start_ch);
               sc->sc_flags &= ~PARF_DELAY;
       }
       splx(s);
       /*
        * Adjust for those chars that we uiomove'ed but never wrote
        */
       /*
        * XXXjdolecek: this len usage is wrong, this will be incorrect
        * if the transfer size is longer than sc_burst
        */
       if (uio->uio_rw == UIO_WRITE && cnt != len) {
               uio->uio_resid += (len - cnt);
#ifdef DEBUG
                       if (pardebug & PDB_IO)
                               printf("parrw: short write, adjust by %d\n",
                                      len-cnt);
#endif
       }
       free(buf, M_DEVBUF);
#ifdef DEBUG
       if (pardebug & (PDB_FOLLOW|PDB_IO))
               printf("parrw: return %d, resid %d\n", error, uio->uio_resid);
#endif
       return (error);
}

int
parioctl(dev_t dev, u_long cmd, void *data, int flag, struct lwp *l)
{
       struct par_softc *sc = device_lookup_private(&par_cd, UNIT(dev));
       struct parparam *pp, *upp;
       int error = 0;

       switch (cmd) {
       case PARIOCGPARAM:
               pp = &sc->sc_param;
               upp = (struct parparam *)data;
               upp->burst = pp->burst;
               upp->timo = parhztoms(pp->timo);
               upp->delay = parhztoms(pp->delay);
               break;

       case PARIOCSPARAM:
               pp = &sc->sc_param;
               upp = (struct parparam *)data;
               if (upp->burst < PAR_BURST_MIN || upp->burst > PAR_BURST_MAX ||
                   upp->delay < PAR_DELAY_MIN || upp->delay > PAR_DELAY_MAX)
                       return(EINVAL);
               pp->burst = upp->burst;
               pp->timo = parmstohz(upp->timo);
               pp->delay = parmstohz(upp->delay);
               break;

       default:
               return(EINVAL);
       }
       return (error);
}

int
parhztoms(int h)
{
       int m = h;

       if (m > 0)
               m = m * 1000 / hz;
       return(m);
}

int
parmstohz(int m)
{
       int h = m;

       if (h > 0) {
               h = h * hz / 1000;
               if (h == 0)
                       h = 1000 / hz;
       }
       return(h);
}

/* stuff below here if for interrupt driven output of data thru
  the parallel port. */

int partimeout_pending;
int parsend_pending;

void
parintr(void *arg)
{
       int s, mask;

       mask = (int)arg;
       s = splclock();

       intio_set_sicilian_intr(intio_get_sicilian_intr() &
                               ~SICILIAN_INTR_PAR);

#ifdef DEBUG
       if (pardebug & PDB_INTERRUPT)
               printf("parintr %d(%s)\n", mask, mask ? "FLG" : "tout");
#endif
       /* if invoked from timeout handler, mask will be 0,
        * if from interrupt, it will contain the cia-icr mask,
        * which is != 0
        */
       if (mask) {
               if (partimeout_pending)
                       callout_stop(&intr_callout);
               if (parsend_pending)
                       parsend_pending = 0;
       }

       /* either way, there won't be a timeout pending any longer */
       partimeout_pending = 0;

       wakeup(parintr);
       splx(s);
}

int
parsendch(struct par_softc *sc, u_char ch)
{
       int error = 0;
       int s;

       /* if either offline, busy or out of paper, wait for that
          condition to clear */
       s = spl1();
       while (!error
              && (parsend_pending
                  || !(intio_get_sicilian_intr() & SICILIAN_STAT_PAR)))
       {
               /* wait a second, and try again */
               callout_reset(&intr_callout, hz, parintr, 0);
               partimeout_pending = 1;
               /* this is essentially a flipflop to have us wait for the
                  first character being transmitted when trying to transmit
                  the second, etc. */
               parsend_pending = 0;
               /* it's quite important that a parallel putc can be
                  interrupted, given the possibility to lock a printer
                  in an offline condition.. */
               if ((error = tsleep(parintr, PCATCH|(PZERO-1), "parsendch", 0))) {
#ifdef DEBUG
                       if (pardebug & PDB_INTERRUPT)
                               printf("parsendch interrupted, error = %d\n", error);
#endif
                       if (partimeout_pending)
                               callout_stop(&intr_callout);

                       partimeout_pending = 0;
               }
       }

       if (!error) {
#ifdef DEBUG
               if (pardebug & PDB_INTERRUPT)
                       printf("#%d", ch);
#endif
               bus_space_write_1(sc->sc_bst, sc->sc_bsh, PAR_DATA, ch);
               DELAY(1);       /* (DELAY(1) == 1us) > 0.5us */
               bus_space_write_1(sc->sc_bst, sc->sc_bsh, PAR_STROBE, 0);
               intio_set_sicilian_intr(intio_get_sicilian_intr() |
                                        SICILIAN_INTR_PAR);
               DELAY(1);
               bus_space_write_1(sc->sc_bst, sc->sc_bsh, PAR_STROBE, 1);
               parsend_pending = 1;
       }

       splx(s);

       return error;
}


int
parsend(struct par_softc *sc, u_char *buf, int len)
{
       int err, orig_len = len;

       for (; len; len--, buf++)
               if ((err = parsendch(sc, *buf)))
                       return err < 0 ? -EINTR : -err;

       /* either all or nothing.. */
       return orig_len;
}

You are viewing proxied material from ftp.icm.edu.pl. The copyright of proxied material belongs to its original authors. Any comments or complaints in relation to proxied material should be directed to the original authors of the content concerned. Please see the disclaimer for more details.