/* $NetBSD: gsckbc.c,v 1.3 2022/06/13 17:26:34 andvar Exp $ */
/*
* Copyright (c) 2004 Jochen Kunz.
* 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. The name of Jochen Kunz may not be used to endorse or promote
*    products derived from this software without specific prior
*    written permission.
*
* THIS SOFTWARE IS PROVIDED BY JOCHEN KUNZ
* ``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 JOCHEN KUNZ
* 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.
*/

/*
* hppa GSC bus MD pckbport(9) frontend for the PS/2 ports found in LASI chips.
*/

#include <sys/cdefs.h>
__KERNEL_RCSID(0, "$NetBSD: gsckbc.c,v 1.3 2022/06/13 17:26:34 andvar Exp $");

/* autoconfig and device stuff */
#include <sys/param.h>
#include <sys/device.h>
#include <sys/conf.h>
#include <machine/iomod.h>
#include <machine/autoconf.h>
#include <hppa/dev/cpudevs.h>
#include <hppa/gsc/gscbusvar.h>
#include <hppa/hppa/machdep.h>
#include "locators.h"
#include "ioconf.h"

/* bus_space / bus_dma etc. */
#include <sys/bus.h>
#include <machine/intr.h>

/* general system data and functions */
#include <sys/systm.h>
#include <sys/ioctl.h>
#include <sys/ioccom.h>
#include <sys/types.h>

/* pckbport interface */
#include <dev/pckbport/pckbportvar.h>

/* register offsets */
#define REG_ID          0x0     /* R: ID register */
#define REG_RESET       0x0     /* W: reset port */
#define REG_RCVDATA     0x4     /* R: received data (4 byte FIFO) */
#define REG_XMITDATA    0x4     /* W: data to transmit */
#define REG_CONTROL     0x8     /* Control Bits */
#define REG_STATUS      0xc     /* Status Bits */
#define REG_SZ          0xc     /* Size of register set */
#define REG_OFFSET      0x100   /* Address Offset of the two ports */

/* ID values for REG_ID */
#define ID_KBD          0       /* keyboard port */
#define ID_AUX          1       /* mouse / aux port */

/* Control Register Bits (R/W) */
#define CTRL_ENBL       0x01    /* Enable */
#define CTRL_LPBXR      0x02    /* Loopback Xmt/Rcv mode */
#define CTRL_DIAG       0x20    /* Diagnostic mode */
#define CTRL_DATDIR     0x40    /* External data line direct control */
#define CTRL_CLKDIR     0x80    /* External clock line direct control */

/* Status Register Bits (RO) */
#define STAT_RBNE       0x01    /* Receive buffer not empty */
#define STAT_TBNE       0x02    /* Transmit buffer not empty */
#define STAT_TERR       0x04    /* Timeout Error */
#define STAT_PERR       0x08    /* Parity Error */
#define STAT_CMPINTR    0x10    /* Composite interrupt */
#define STAT_DATSHD     0x40    /* Data line shadow */
#define STAT_CLKSHD     0x80    /* Clock line shadow */



/* autoconfig stuff */
static int gsckbc_match(device_t, cfdata_t, void *);
static void gsckbc_attach(device_t, device_t, void *);

static int gsckbc_xt_translation(void *, pckbport_slot_t, int);
static int gsckbc_send_devcmd(void *, pckbport_slot_t, u_char);
static int gsckbc_poll_data1(void *, pckbport_slot_t);
static void gsckbc_slot_enable(void *, pckbport_slot_t, int);
static void gsckbc_intr_establish(void *, pckbport_slot_t);
static void gsckbc_set_poll(void *, pckbport_slot_t, int);

static int gsckbc_intr(void *);


struct gsckbc_softc {
       device_t sc_dev;                        /* general dev info */
       bus_space_tag_t sc_iot;                 /* bus_space(9) tag */
       bus_space_handle_t sc_ioh;              /* bus_space(9) handle */
       struct gsckbc_softc *sc_op;             /* other port */
       void *sc_ih;                            /* interrupt handle */
       pckbport_slot_t sc_slot;                /* kbd or mouse / aux slot */
       pckbport_tag_t sc_pckbport;             /* port tag */
       device_t sc_child;                      /* our child devices */
       int sc_poll;                            /* if != 0 then pooling mode */
       int sc_enable;                          /* if != 0 then enable */
};


CFATTACH_DECL_NEW(gsckbc, sizeof(struct gsckbc_softc), gsckbc_match, gsckbc_attach,
       NULL, NULL);


const struct pckbport_accessops gsckbc_accessops = {
       gsckbc_xt_translation,
       gsckbc_send_devcmd,
       gsckbc_poll_data1,
       gsckbc_slot_enable,
       gsckbc_intr_establish,
       gsckbc_set_poll
};


static int
gsckbc_xt_translation(void *cookie, pckbport_slot_t slot, int on)
{
       return 0;
}


static int
gsckbc_send_devcmd(void *cookie, pckbport_slot_t slot, u_char byte)
{
       struct gsckbc_softc *sc = (struct gsckbc_softc *) cookie;

       if ((bus_space_read_1(sc->sc_iot, sc->sc_ioh, REG_STATUS) & STAT_TBNE)
           != 0)
               DELAY(100);
       if ((bus_space_read_1(sc->sc_iot, sc->sc_ioh, REG_STATUS) & STAT_TBNE)
           != 0)
               return 0;
       bus_space_write_1(sc->sc_iot, sc->sc_ioh, REG_XMITDATA, byte);
       return 1;
}


static int
gsckbc_poll_data1(void *cookie, pckbport_slot_t slot)
{
       struct gsckbc_softc *sc = (struct gsckbc_softc *) cookie;
       int i;

       for (i = 0; i < 1000; i++) {
               if ((bus_space_read_1(sc->sc_iot, sc->sc_ioh, REG_STATUS) &
                   STAT_RBNE) != 0 || sc->sc_poll == 0) {
                       return bus_space_read_1(sc->sc_iot, sc->sc_ioh,
                           REG_RCVDATA);
               }
               DELAY(100);
       }
       return -1;
}


static void
gsckbc_slot_enable(void *cookie, pckbport_slot_t slot, int on)
{
       struct gsckbc_softc *sc = (struct gsckbc_softc *) cookie;

       sc->sc_enable = on;
}


static void
gsckbc_intr_establish(void *cookie, pckbport_slot_t slot)
{
       return;
}


static void
gsckbc_set_poll(void *cookie, pckbport_slot_t slot, int on)
{
       struct gsckbc_softc *sc = (struct gsckbc_softc *) cookie;

       sc->sc_poll = on;
}


static int
gsckbc_intr(void *arg)
{
       struct gsckbc_softc *sc = (struct gsckbc_softc *) arg;
       int data;

       while ((bus_space_read_1(sc->sc_iot, sc->sc_ioh, REG_STATUS)
           & STAT_RBNE) != 0 && sc->sc_poll == 0) {
               data = bus_space_read_1(sc->sc_iot, sc->sc_ioh, REG_RCVDATA);
               if (sc->sc_enable != 0)
                       pckbportintr(sc->sc_pckbport, sc->sc_slot, data);
       }
       while ((bus_space_read_1(sc->sc_op->sc_iot, sc->sc_op->sc_ioh,
           REG_STATUS) & STAT_RBNE) != 0 && sc->sc_op->sc_poll == 0) {
               data = bus_space_read_1(sc->sc_op->sc_iot, sc->sc_op->sc_ioh,
                   REG_RCVDATA);
               if (sc->sc_op->sc_enable != 0)
                       pckbportintr(sc->sc_op->sc_pckbport, sc->sc_op->sc_slot,
                           data);
       }
       return 1;
}


static int
gsckbc_match(device_t parent, cfdata_t match, void *aux)
{
       struct gsc_attach_args *ga = aux;

       if (ga->ga_type.iodc_type == HPPA_TYPE_FIO
           && ga->ga_type.iodc_sv_model == HPPA_FIO_GPCIO)
               return(1);
       return(0);
}


static void
gsckbc_attach(device_t parent, device_t self, void *aux)
{
       struct gsckbc_softc *sc = device_private(self);
       struct gsc_attach_args *ga = aux;
       static struct gsckbc_softc *master_sc;
       int pagezero_cookie;
       int i;

       /*
        * On hppa bus_space_map(9) maps whole pages. (surprise, surprise)
        * The registers are within the same page so we can do only a single
        * mapping for both devices. Also both devices use the same IRQ.
        * Actually you can think of the two PS/2 ports to be a single
        * device. The firmware lists them as individual devices in the
        * firmware device tree so we keep this illusion to map the firmware
        * device tree as close as possible to the kernel device tree.
        * So we do one mapping and IRQ for both devices. The first device
        * is called "master", gets the IRQ and the other is the "slave".
        *
        * Assumption: Master attaches first, gets the IRQ and has lower HPA.
        */
       sc->sc_dev = self;
       sc->sc_iot = ga->ga_iot;
       if (ga->ga_irq >= 0) {
               if (bus_space_map(sc->sc_iot, ga->ga_hpa, REG_SZ + REG_OFFSET,
                   0, &sc->sc_ioh)) {
                       aprint_normal(": gsckbc_attach: can't map I/O space\n");
                       return;
               }
               aprint_debug(" (master)");
               sc->sc_ih = hppa_intr_establish(IPL_TTY, gsckbc_intr, sc,
                   ga->ga_ir, ga->ga_irq);
               master_sc = sc;
       } else {
               if (master_sc == NULL) {
                       aprint_normal(": can't find master device\n");
                       return;
               }
               sc->sc_op = master_sc;
               master_sc->sc_op = sc;
               sc->sc_ioh = sc->sc_op->sc_ioh + REG_OFFSET;
               aprint_debug(" (slave)");
       }
       /* We start in polling mode. */
       sc->sc_poll = 1;
       /* Reset port. */
       bus_space_write_1(sc->sc_iot, sc->sc_ioh, REG_RESET, 0);
       /* Enable port hardware. */
       bus_space_write_1(sc->sc_iot, sc->sc_ioh, REG_CONTROL, CTRL_ENBL);
       /* Flush RX FIFO. */
       for (i = 0; i < 5; i++)
               bus_space_read_1(sc->sc_iot, sc->sc_ioh, REG_RCVDATA);
       if (bus_space_read_1(sc->sc_iot, sc->sc_ioh, REG_ID) == ID_KBD) {
               aprint_normal(": keyboard\n");
               sc->sc_slot = PCKBPORT_KBD_SLOT;
               pagezero_cookie = hppa_pagezero_map();
               if ((hppa_hpa_t)PAGE0->mem_kbd.pz_hpa == ga->ga_hpa) {
                       if (pckbport_cnattach(sc, &gsckbc_accessops,
                           sc->sc_slot) != 0)
                               aprint_normal("Failed to attach console "
                                   "keyboard!\n");
                       else
                               sc->sc_enable = 1;
               }
               hppa_pagezero_unmap(pagezero_cookie);
       } else {
               aprint_normal(": mouse\n");
               sc->sc_slot = PCKBPORT_AUX_SLOT;
       }
       sc->sc_pckbport = pckbport_attach(sc, &gsckbc_accessops);
       if (sc->sc_pckbport != NULL)
               sc->sc_child = pckbport_attach_slot(self, sc->sc_pckbport,
                   sc->sc_slot);
       sc->sc_poll = 0;
}

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.