/*      $NetBSD: intro.c,v 1.4 2007/11/28 16:59:02 pooka Exp $  */

/*
 * El extra-simplo example of the userspace driver framework.
 *
 * Eventually there will be a library a la libpuffs (perhaps,
 * gasp, even the same lib), but for now it's all manual until
 * I get it figured out.
 *
 * So how to run this?
 * 0) sh MAKEDEV putter (if you don't have a freshly created /dev)
 * 1) run this program with the argument "/dev/pud"
 * 2) mknod a char device with the major 377 (see sources below)
 * 3) echo ascii art and jokes into device created in previous step
 *    or read the device
 */

#include <sys/types.h>

#include <dev/pud/pud_msgif.h>

#include <err.h>
#include <errno.h>
#include <fcntl.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>

#include "common.h"

#define DEFALLOC 1024*1024
#define ECHOSTR1 "Would you like some sauce diable with that?\n"
#define ECHOSTR2 "Nej tack, you fool, I'm happy with my tournedos Rossini\n"
#define NSTR 2

const char *curstr = ECHOSTR1;

#ifndef MIN
#define MIN(a,b) ((a)<(b)?(a):(b))
#endif

int
main(int argc, char *argv[])
{
        struct pud_req *pdr = malloc(DEFALLOC);
        struct pud_conf_reg pcr;
        int fd;
        ssize_t n;
        
        if (argc != 2)
                errx(1, "args");

        /*
         * open pud device
         */
        fd = open(argv[1], O_RDWR);
        if (fd == -1)
                err(1, "open");

        /*
         * register our major number
         */
        memset(&pcr, 0, sizeof(pcr));
        pcr.pm_pdr.pdr_pth.pth_framelen = sizeof(struct pud_conf_reg);
        pcr.pm_version = PUD_DEVELVERSION | PUD_VERSION;
        pcr.pm_pdr.pdr_reqclass = PUD_REQ_CONF;
        pcr.pm_pdr.pdr_reqtype = PUD_CONF_REG;

        pcr.pm_regdev = makedev(377, 0);
        pcr.pm_flags = PUD_CONFFLAG_BDEV;
        strlcpy(pcr.pm_devname, "testdev", sizeof(pcr.pm_devname));

        n = write(fd, &pcr, pcr.pm_pdr.pdr_pth.pth_framelen);
        if (n == -1)
                err(1, "configure write");

        /*
         * process requests
         */
        for (;;) {
                n = read(fd, pdr, DEFALLOC);
                printf("read %d %d\n", n, errno);

                switch (pdr->pdr_reqtype) {
                case PUD_CDEV_OPEN:
                case PUD_CDEV_CLOSE:
                        printf("got openclose %d\n", pdr->pdr_reqtype);
                        pdr->pdr_rv = 0;
                        break;

                case PUD_CDEV_READ:
                /* uh oh case PUD_BDEV_STRATREAD: */
                {
                        struct pud_creq_read *pc_read;
                        size_t clen;

                        pc_read = (void *)pdr;
                        printf("read from offset %llu, resid %zu\n",
                            (unsigned long long)pc_read->pm_offset,
                            pc_read->pm_resid);

                        clen = MIN(strlen(curstr), pc_read->pm_resid);
                        strncpy(pc_read->pm_data, curstr, clen);
                        if (pdr->pdr_reqclass == PUD_REQ_BDEV) {
                                clen = pc_read->pm_resid;
                                pc_read->pm_resid = 0;
                        } else {
                                pc_read->pm_resid -= clen;
                        }
                        pdr->pdr_pth.pth_framelen =
                            sizeof(struct pud_creq_read) + clen;
                }
                        break;

                case PUD_CDEV_WRITE:
                /* uh uh oh case PUD_BDEV_STRATWRITE: */
                {
                        struct pud_creq_write *pc_write;

                        pc_write = (void *)pdr;
                        printf("write to offset %llu, resid %zu\n",
                            (unsigned long long)pc_write->pm_offset,
                            pc_write->pm_resid);

                        pc_write->pm_data[pc_write->pm_resid] = '\0';
                        printf("got via write: %s", pc_write->pm_data);
                        pdr->pdr_pth.pth_framelen =
                            sizeof(struct pud_creq_write);
                        pc_write->pm_resid = 0;
                }
                        break;

                case PUD_CDEV_IOCTL:
                {
                        struct pud_req_ioctl *pc_ioctl;
                        int *iocval;

                        pc_ioctl = (void *)pdr;
                        switch (pc_ioctl->pm_iocmd) {
                        case INTROTOGGLE:
                        case INTROTOGGLE_R:
                                iocval = (int *)pc_ioctl->pm_data;
                                if (*iocval < 0 || *iocval > 2) {
                                        pdr->pdr_rv = ERANGE;
                                        break;
                                }

                                if (*iocval == 1)
                                        curstr = ECHOSTR1;
                                else
                                        curstr = ECHOSTR2;

                                *iocval = 0;
                                break;
                        default:
                                abort();
                        }
                }
                        break;

                default:
                        abort();
                }

                n = write(fd, pdr, pdr->pdr_pth.pth_framelen);
                printf("wrote %d %d\n", n, errno);
        }
}