/*      $NetBSD: pm.c,v 1.19 2023/02/11 18:30:45 tsutsui Exp $  */

/*-
* Copyright (c) 2002, 2003 The NetBSD Foundation, Inc.
* All rights reserved.
*
* This code is derived from software contributed to The NetBSD Foundation
* by Andrew Doran.
*
* 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.
*
* THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. 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 FOUNDATION 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.
*/

#include <sys/cdefs.h>
__KERNEL_RCSID(0, "$NetBSD: pm.c,v 1.19 2023/02/11 18:30:45 tsutsui Exp $");

#include <sys/param.h>
#include <sys/buf.h>
#include <sys/bus.h>
#include <sys/device.h>
#include <sys/ioctl.h>
#include <sys/intr.h>
#include <sys/kernel.h>
#include <sys/systm.h>

#include <dev/wscons/wsconsio.h>
#include <dev/wscons/wsdisplayvar.h>
#include <dev/rasops/rasops.h>
#include <dev/wsfont/wsfont.h>

#include <dev/ic/dc503reg.h>

#include <pmax/pmax/kn01.h>

#include <pmax/ibus/ibusvar.h>
#include <pmax/ibus/pmreg.h>

#include <uvm/uvm_extern.h>

#define CURSOR_MAX_SIZE 16

struct hwcmap256 {
       uint8_t r[256];
       uint8_t g[256];
       uint8_t b[256];
};

struct hwcursor64 {
       struct wsdisplay_curpos cc_pos;
       struct wsdisplay_curpos cc_hot;
       struct wsdisplay_curpos cc_size;
       uint8_t cc_color[6];

       /*
        * Max cursor size is 16x16.  The X server pads bitmap scanlines to
        * a word boundary.  We take the easy route and waste some space.
        */
       u_short cc_image[32 + 32];
};

struct pm_softc {
       device_t                sc_dev;
       size_t                  sc_cmap_size;
       size_t                  sc_fb_size;
       int                     sc_type;
       int                     sc_blanked;
       int                     sc_curenb;
       int                     sc_changed;
       int                     sc_nscreens;
       struct hwcursor64       sc_cursor;
       struct hwcmap256        sc_cmap;
};
#define WSDISPLAY_CMAP_DOLUT    0x20

int     pm_match(device_t, cfdata_t, void *);
void    pm_attach(device_t, device_t, void *);
int     pm_check_vfb(void);
int     pm_ioctl(void *, void *, u_long, void *, int, struct lwp *);
paddr_t pm_mmap(void *, void *, off_t, int);
int     pm_alloc_screen(void *, const struct wsscreen_descr *,
                               void **, int *, int *, long *);
void    pm_free_screen(void *, void *);
int     pm_show_screen(void *, void *, int,
                              void (*) (void *, int, int), void *);
void    pm_cursor_off(void);
void    pm_cursor_on(struct pm_softc *);
int     pm_cnattach(void);
void    pm_common_init(void);
int     pm_flush(struct pm_softc *);
int     pm_get_cmap(struct pm_softc *, struct wsdisplay_cmap *);
int     pm_set_cmap(struct pm_softc *, struct wsdisplay_cmap *);
int     pm_set_cursor(struct pm_softc *, struct wsdisplay_cursor *);
int     pm_get_cursor(struct pm_softc *, struct wsdisplay_cursor *);
void    pm_set_curpos(struct pm_softc *, struct wsdisplay_curpos *);
void    pm_init_cmap(struct pm_softc *);

CFATTACH_DECL_NEW(pm, sizeof(struct pm_softc),
  pm_match, pm_attach, NULL, NULL);

struct rasops_info pm_ri;

struct wsscreen_descr pm_stdscreen = {
       "std", 0, 0,
       0, /* textops */
       0, 0,
       WSSCREEN_REVERSE
};

const struct wsscreen_descr *_pm_scrlist[] = {
       &pm_stdscreen,
};

const struct wsscreen_list pm_screenlist = {
       sizeof(_pm_scrlist) / sizeof(struct wsscreen_descr *), _pm_scrlist
};

const struct wsdisplay_accessops pm_accessops = {
       pm_ioctl,
       pm_mmap,
       pm_alloc_screen,
       pm_free_screen,
       pm_show_screen,
       0 /* load_font */
};

u_int   pm_creg;

int
pm_match(device_t parent, cfdata_t cf, void *aux)
{
       struct ibus_attach_args *ia;
       void *pmaddr;

       ia = aux;
       pmaddr = (void *)ia->ia_addr;

       if (strcmp(ia->ia_name, "pm") != 0)
               return (0);

       if (badaddr(pmaddr, 4))
               return (0);

       return (1);
}

void
pm_attach(device_t parent, device_t self, void *aux)
{
       struct pm_softc *sc;
       struct rasops_info *ri;
       struct wsemuldisplaydev_attach_args waa;
       int console;

       sc = device_private(self);
       sc->sc_dev = self;
       ri = &pm_ri;
       console = (ri->ri_bits != NULL);

       if (console) {
               sc->sc_nscreens = 1;
               ri->ri_flg &= ~RI_NO_AUTO;
       } else if (!pm_check_vfb()) {
               printf(": VFB01/VFB02 frame buffer option not found\n");
               return;
       } else
               pm_common_init();

       printf(": %dx%d, %dbpp\n", ri->ri_width, ri->ri_height, ri->ri_depth);

       pm_init_cmap(sc);

       sc->sc_blanked = 0;
       sc->sc_curenb = 0;

       waa.console = console;
       waa.scrdata = &pm_screenlist;
       waa.accessops = &pm_accessops;
       waa.accesscookie = sc;

       config_found(self, &waa, wsemuldisplaydevprint, CFARGS_NONE);
}

int
pm_check_vfb(void)
{
       int *mem;
       const int magic = 0xcafebabe;

       mem = (void *)MIPS_PHYS_TO_KSEG1(KN01_PHYS_FBUF_START);

       *mem = magic;
       wbflush();
       if (*mem != magic)
               return 0;

       *mem = ~magic;
       wbflush();
       if (*mem != ~magic)
               return 0;

       return 1;
}

void
pm_init_cmap(struct pm_softc *sc)
{
       struct hwcmap256 *cm;
       struct rasops_info *ri;
       const uint8_t *p;
       int index;

       cm = &sc->sc_cmap;
       ri = &pm_ri;

       if (ri->ri_depth == 8) {
               p = rasops_cmap;
               for (index = 0; index < 256; index++, p += 3) {
                       cm->r[index] = p[0];
                       cm->g[index] = p[1];
                       cm->b[index] = p[2];
               }

               sc->sc_type = WSDISPLAY_TYPE_PM_COLOR;
               sc->sc_cmap_size = 256;
               sc->sc_fb_size = 0x100000;
       } else {
               cm->r[0] = 0x00;
               cm->g[0] = 0x00;
               cm->b[0] = 0x00;

               cm->r[1] = 0x00;
               cm->g[1] = 0xff;
               cm->b[1] = 0x00;

               sc->sc_type = WSDISPLAY_TYPE_PM_MONO;
               sc->sc_cmap_size = 2;
               sc->sc_fb_size = 0x40000;
       }
}

void
pm_common_init(void)
{
       struct rasops_info *ri;
       int cookie, bior, i;
       struct dc503reg *pcc;
       VDACRegs *vdac;
       uint16_t kn01csr;

       kn01csr = *(volatile uint16_t *)MIPS_PHYS_TO_KSEG1(KN01_SYS_CSR);
       pcc = (void *)MIPS_PHYS_TO_KSEG1(KN01_SYS_PCC);
       vdac = (void *)MIPS_PHYS_TO_KSEG1(KN01_SYS_VDAC);
       ri = &pm_ri;

       ri->ri_flg = RI_CENTER;
       if (ri->ri_bits == NULL)
               ri->ri_flg |= RI_NO_AUTO;
       ri->ri_depth = ((kn01csr & KN01_CSR_MONO) != 0 ? 1 : 8);
       ri->ri_width = 1024;
       ri->ri_height = 864;
       ri->ri_stride = (ri->ri_depth == 8 ? 1024 : 2048 / 8);
       ri->ri_bits = (void *)MIPS_PHYS_TO_KSEG1(KN01_PHYS_FBUF_START);

       /*
        * Clear the screen.
        */
       memset(ri->ri_bits, 0, ri->ri_stride * ri->ri_height);

       /*
        * Get a font to use.
        */
       bior = (ri->ri_depth == 8 ? WSDISPLAY_FONTORDER_L2R :
           WSDISPLAY_FONTORDER_R2L);

       wsfont_init();
       if (ri->ri_depth == 8)
               cookie = wsfont_find(NULL, 12, 0, 0, bior,
                   WSDISPLAY_FONTORDER_L2R, WSFONT_FIND_BITMAP);
       else
               cookie = wsfont_find(NULL, 8, 0, 0, bior,
                   WSDISPLAY_FONTORDER_L2R, WSFONT_FIND_BITMAP);
       if (cookie <= 0)
               cookie = wsfont_find(NULL, 0, 0, 0, bior,
                   WSDISPLAY_FONTORDER_L2R, WSFONT_FIND_BITMAP);
       if (cookie <= 0) {
               printf("pm: font table is empty\n");
               return;
       }

       if (wsfont_lock(cookie, &ri->ri_font)) {
               printf("pm: couldn't lock font\n");
               return;
       }
       ri->ri_wsfcookie = cookie;

       /*
        * Set up the raster operations set.
        */
       rasops_init(ri, 1000, 1000);

       pm_stdscreen.nrows = ri->ri_rows;
       pm_stdscreen.ncols = ri->ri_cols;
       pm_stdscreen.textops = &ri->ri_ops;
       pm_stdscreen.capabilities = ri->ri_caps;

       /*
        * Initialize the VDAC.
        */
       *(uint8_t *)MIPS_PHYS_TO_KSEG1(KN01_PHYS_COLMASK_START) = 0xff;
       wbflush();

       vdac->overWA = 0x04; wbflush();
       vdac->over = 0x00; wbflush();
       vdac->over = 0x00; wbflush();
       vdac->over = 0x00; wbflush();
       vdac->overWA = 0x08; wbflush();
       vdac->over = 0x00; wbflush();
       vdac->over = 0x00; wbflush();
       vdac->over = 0x7f; wbflush();
       vdac->overWA = 0x0c; wbflush();
       vdac->over = 0xff; wbflush();
       vdac->over = 0xff; wbflush();
       vdac->over = 0xff; wbflush();

       /*
        * Set in the initial colormap.
        */
       if (ri->ri_depth == 8) {
               vdac->mapWA = 0;
               wbflush();

               for (i = 0; i < 256 * 3; i += 3) {
                       vdac->map = rasops_cmap[i];
                       wbflush();
                       vdac->map = rasops_cmap[i + 1];
                       wbflush();
                       vdac->map = rasops_cmap[i + 2];
                       wbflush();
               }
       } else {
               vdac->mapWA = 0;
               wbflush();

               for (i = 0; i < 256; i++) {
                       vdac->map = 0x00;
                       wbflush();
                       vdac->map = (i < 128 ? 0x00 : 0xff);
                       wbflush();
                       vdac->map = 0x00;
                       wbflush();
               }
       }

       /*
        * Turn off the hardware cursor sprite for text mode.
        */
       pcc->cmdr = PCCCMD_FOPB | PCCCMD_VBHI;
       wbflush();
       pm_creg = 0;
       pm_cursor_off();
}

void
pm_cursor_off(void)
{
       struct dc503reg *pcc;

       pcc = (void *)MIPS_PHYS_TO_KSEG1(KN01_SYS_PCC);
       pcc->cmdr = (pm_creg &= ~(PCCCMD_ENPA | PCCCMD_ENPB));
       wbflush();
}

void
pm_cursor_on(struct pm_softc *sc)
{
       struct dc503reg *pcc;

       if (sc->sc_curenb) {
               pcc = (void *)MIPS_PHYS_TO_KSEG1(KN01_SYS_PCC);
               pcc->cmdr = (pm_creg |= (PCCCMD_ENPA | PCCCMD_ENPB));
               wbflush();
       }
}

int
pm_ioctl(void *v, void *vs, u_long cmd, void *data, int flag, struct lwp *l)
{
       struct pm_softc *sc;
       struct rasops_info *ri;
       int turnoff, rv, i;
       struct dc503reg *pcc;
       VDACRegs *vdac;

       sc = v;
       ri = &pm_ri;
       rv = 0;
       pcc = (void *)MIPS_PHYS_TO_KSEG1(KN01_SYS_PCC);
       vdac = (void *)MIPS_PHYS_TO_KSEG1(KN01_SYS_VDAC);

       switch (cmd) {
       case WSDISPLAYIO_GTYPE:
               *(u_int *)data = sc->sc_type;
               break;

       case WSDISPLAYIO_SMODE:
               if (*(u_int *)data == WSDISPLAYIO_MODE_EMUL) {
                       pm_cursor_off();
                       pm_init_cmap(sc);
                       memset(ri->ri_bits, 0, ri->ri_stride * ri->ri_height);
                       sc->sc_curenb = 0;
                       sc->sc_changed |= WSDISPLAY_CMAP_DOLUT;
               }
               break;

       case WSDISPLAYIO_GINFO:
#define wsd_fbip ((struct wsdisplay_fbinfo *)data)
               wsd_fbip->height = ri->ri_height;
               wsd_fbip->width = ri->ri_width;
               wsd_fbip->depth = ri->ri_depth;
               wsd_fbip->cmsize = sc->sc_cmap_size;
#undef fbt
               break;

       case WSDISPLAYIO_GETCMAP:
               rv = pm_get_cmap(sc, (struct wsdisplay_cmap *)data);
               break;

       case WSDISPLAYIO_PUTCMAP:
               rv = pm_set_cmap(sc, (struct wsdisplay_cmap *)data);
               break;

       case WSDISPLAYIO_SVIDEO:
               turnoff = (*(int *)data == WSDISPLAYIO_VIDEO_OFF);
               if ((sc->sc_blanked == 0) ^ turnoff) {
                       sc->sc_blanked = turnoff;
                       if (turnoff == 0) {
                               pcc->cmdr =
                                   (pm_creg &= ~(PCCCMD_FOPA | PCCCMD_FOPB));
                               wbflush();
                               pm_cursor_on(sc);
                               sc->sc_changed |= WSDISPLAY_CURSOR_DOCMAP;
                       } else {
                               pm_cursor_off();
                               pcc->cmdr =
                                   (pm_creg |= (PCCCMD_FOPA | PCCCMD_FOPB));
                               wbflush();
                               vdac->overWA = 0x0c;
                               wbflush();
                               for (i = 0; i < 3; i++) {
                                       vdac->over = 0;
                                       wbflush();
                               }
                       }
               }
               break;

       case WSDISPLAYIO_GVIDEO:
               *(u_int *)data = (sc->sc_blanked ?
                   WSDISPLAYIO_VIDEO_OFF : WSDISPLAYIO_VIDEO_ON);
               break;

       case WSDISPLAYIO_GCURPOS:
               *(struct wsdisplay_curpos *)data = sc->sc_cursor.cc_pos;
               break;

       case WSDISPLAYIO_SCURPOS:
               pm_set_curpos(sc, (struct wsdisplay_curpos *)data);
               sc->sc_changed |= WSDISPLAY_CURSOR_DOPOS;
               break;

       case WSDISPLAYIO_GCURMAX:
               ((struct wsdisplay_curpos *)data)->x =
               ((struct wsdisplay_curpos *)data)->y = CURSOR_MAX_SIZE;
               break;

       case WSDISPLAYIO_GCURSOR:
               rv = pm_get_cursor(sc, (struct wsdisplay_cursor *)data);
               break;

       case WSDISPLAYIO_SCURSOR:
               rv = pm_set_cursor(sc, (struct wsdisplay_cursor *)data);
               break;

       default:
               rv = ENOTTY;
               break;
       }

       pm_flush(sc);
       return (rv);
}

paddr_t
pm_mmap(void *v, void *vs, off_t offset, int prot)
{
       struct pm_softc *sc;

       sc = v;

       if (offset >= sc->sc_fb_size || offset < 0)
               return (-1);

       return (mips_btop(KN01_PHYS_FBUF_START + offset));
}

int
pm_alloc_screen(void *v, const struct wsscreen_descr *type, void **cookiep,
               int *curxp, int *curyp, long *attrp)
{
       struct pm_softc *sc;
       struct rasops_info *ri;
       long defattr;

       sc = v;
       ri = &pm_ri;

       if (sc->sc_nscreens > 0)
               return (ENOMEM);

       *cookiep = ri;   /* one and only for now */
       *curxp = 0;
       *curyp = 0;
       (*ri->ri_ops.allocattr)(ri, 0, 0, 0, &defattr);
       *attrp = defattr;
       sc->sc_nscreens++;
       return (0);
}

void
pm_free_screen(void *v, void *cookie)
{

       panic("pm_free_screen: console");
}

int
pm_show_screen(void *v, void *cookie, int waitok,
              void (*cb)(void *, int, int), void *cbarg)
{

       return (0);
}

/* EXPORT */ int
pm_cnattach(void)
{
       struct rasops_info *ri;
       long defattr;

       ri = &pm_ri;

       pm_common_init();
       (*ri->ri_ops.allocattr)(ri, 0, 0, 0, &defattr);
       wsdisplay_cnattach(&pm_stdscreen, ri, 0, 0, defattr);
       return (1);
}

int
pm_flush(struct pm_softc *sc)
{
       VDACRegs *vdac;
       struct dc503reg *pcc;
       uint8_t *cp;
       int v, i, x, y;
       u_short *p, *pe;
       struct hwcmap256 *cm;

       if (sc->sc_changed == 0)
               return (1);

       vdac = (void *)MIPS_PHYS_TO_KSEG1(KN01_SYS_VDAC);
       pcc = (void *)MIPS_PHYS_TO_KSEG1(KN01_SYS_PCC);
       v = sc->sc_changed;

       if ((v & WSDISPLAY_CURSOR_DOCUR) != 0) {
               if (sc->sc_curenb)
                       pm_cursor_on(sc);
               else
                       pm_cursor_off();
       }

       if ((v & (WSDISPLAY_CURSOR_DOPOS | WSDISPLAY_CURSOR_DOHOT)) != 0) {
               x = sc->sc_cursor.cc_pos.x - sc->sc_cursor.cc_hot.x;
               y = sc->sc_cursor.cc_pos.y - sc->sc_cursor.cc_hot.y;
               pcc->xpos = x + PCC_X_OFFSET;
               pcc->ypos = y + PCC_Y_OFFSET;
               wbflush();
       }
       if ((v & WSDISPLAY_CURSOR_DOCMAP) != 0) {
               cp = sc->sc_cursor.cc_color;

               vdac->overWA = 0x04;
               wbflush();
               for (i = 1; i < 6; i += 2) {
                       vdac->over = cp[i];
                       wbflush();
               }

               vdac->overWA = 0x08;
               wbflush();
               vdac->over = 0x00;
               wbflush();
               vdac->over = 0x00;
               wbflush();
               vdac->over = 0x7f;
               wbflush();

               vdac->overWA = 0x0c;
               wbflush();
               for (i = 0; i < 6; i += 2) {
                       vdac->over = cp[i];
                       wbflush();
               }
       }
       if ((v & WSDISPLAY_CURSOR_DOSHAPE) != 0) {
               pcc->cmdr = (pm_creg | PCCCMD_LODSA);
               wbflush();

               p = sc->sc_cursor.cc_image;
               x = 0xffff >> (16 - sc->sc_cursor.cc_size.x);
               for (pe = p + 64; p < pe; p += 2) {
                       pcc->load = *p & x;
                       wbflush();
               }

               pcc->cmdr = (pm_creg &= ~PCCCMD_LODSA);
               wbflush();
       }

       if ((v & WSDISPLAY_CMAP_DOLUT) != 0) {
               cm = &sc->sc_cmap;

               vdac->mapWA = 0;
               wbflush();

               if (sc->sc_cmap_size == 2) {
                       for (i = 0; i < 128; i++) {
                               vdac->map = 0;
                               wbflush();
                               vdac->map = cm->g[0];
                               wbflush();
                               vdac->map = 0;
                               wbflush();
                       }
                       for (; i < 256; i++) {
                               vdac->map = 0;
                               wbflush();
                               vdac->map = cm->g[1];
                               wbflush();
                               vdac->map = 0;
                               wbflush();
                       }
               } else {
                       for (i = 0; i < sc->sc_cmap_size; i++) {
                               vdac->map = cm->r[i];
                               wbflush();
                               vdac->map = cm->g[i];
                               wbflush();
                               vdac->map = cm->b[i];
                               wbflush();
                       }
               }
       }

       sc->sc_changed = 0;
       return (1);
}

int
pm_get_cmap(struct pm_softc *sc, struct wsdisplay_cmap *p)
{
       u_int index, count;
       int rv;

       index = p->index;
       count = p->count;

       if (index >= sc->sc_cmap_size || count > sc->sc_cmap_size - index)
               return (EINVAL);

       if ((rv = copyout(&sc->sc_cmap.r[index], p->red, count)) != 0)
               return (rv);
       if ((rv = copyout(&sc->sc_cmap.g[index], p->green, count)) != 0)
               return (rv);
       return (copyout(&sc->sc_cmap.b[index], p->blue, count));
}

int
pm_set_cmap(struct pm_softc *sc, struct wsdisplay_cmap *p)
{
       u_int index, count;
       int rv;

       index = p->index;
       count = p->count;

       if (index >= sc->sc_cmap_size || count > sc->sc_cmap_size - index)
               return (EINVAL);

       if ((rv = copyin(p->red, &sc->sc_cmap.r[index], count)) != 0)
               return (rv);
       if ((rv = copyin(p->green, &sc->sc_cmap.g[index], count)) != 0)
               return (rv);
       if ((rv = copyin(p->blue, &sc->sc_cmap.b[index], count)) != 0)
               return (rv);
       sc->sc_changed |= WSDISPLAY_CMAP_DOLUT;
       return (0);
}

int
pm_set_cursor(struct pm_softc *sc, struct wsdisplay_cursor *p)
{
       u_int v, index, count;
       struct hwcursor64 *cc;
       int rv;

       v = p->which;
       cc = &sc->sc_cursor;

       if ((v & WSDISPLAY_CURSOR_DOCUR) != 0)
               sc->sc_curenb = p->enable;
       if ((v & WSDISPLAY_CURSOR_DOPOS) != 0)
               pm_set_curpos(sc, &p->pos);
       if ((v & WSDISPLAY_CURSOR_DOHOT) != 0)
               cc->cc_hot = p->hot;
       if ((v & WSDISPLAY_CURSOR_DOCMAP) != 0) {
               index = p->cmap.index;
               count = p->cmap.count;
               if (index >= 2 || count > 2 - index)
                       return (EINVAL);

               rv = copyin(p->cmap.red, &cc->cc_color[index], count);
               if (rv != 0)
                       return (rv);
               rv = copyin(p->cmap.green, &cc->cc_color[index + 2], count);
               if (rv != 0)
                       return (rv);
               rv = copyin(p->cmap.blue, &cc->cc_color[index + 4], count);
               if (rv != 0)
                       return (rv);
       }
       if ((v & WSDISPLAY_CURSOR_DOSHAPE) != 0) {
               if (p->size.x > CURSOR_MAX_SIZE ||
                   p->size.y > CURSOR_MAX_SIZE)
                       return (EINVAL);

               cc->cc_size = p->size;
               memset(cc->cc_image, 0, sizeof(cc->cc_image));
               rv = copyin(p->image, cc->cc_image, p->size.y * 4);
               if (rv != 0)
                       return (rv);
               rv = copyin(p->mask, cc->cc_image+32, p->size.y * 4);
               if (rv != 0)
                       return (rv);
       }

       sc->sc_changed |= v;
       return (0);
}

int
pm_get_cursor(struct pm_softc *sc, struct wsdisplay_cursor *p)
{

       return (ENOTTY); /* XXX */
}

void
pm_set_curpos(struct pm_softc *sc, struct wsdisplay_curpos *curpos)
{
       struct rasops_info *ri;
       int x, y;

       ri = &pm_ri;
       x = curpos->x;
       y = curpos->y;

       if (y < 0)
               y = 0;
       else if (y > ri->ri_height)
               y = ri->ri_height;
       if (x < 0)
               x = 0;
       else if (x > ri->ri_width)
               x = ri->ri_width;
       sc->sc_cursor.cc_pos.x = x;
       sc->sc_cursor.cc_pos.y = y;
}

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.