/*      $OpenBSD: dev_sioctl.c,v 1.11 2024/12/20 07:35:56 ratchov Exp $ */
/*
 * Copyright (c) 2014-2020 Alexandre Ratchov <alex@caoua.org>
 *
 * Permission to use, copy, modify, and distribute this software for any
 * purpose with or without fee is hereby granted, provided that the above
 * copyright notice and this permission notice appear in all copies.
 *
 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */
#include <sys/time.h>
#include <sys/types.h>

#include <poll.h>
#include <sndio.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "abuf.h"
#include "defs.h"
#include "dev.h"
#include "dsp.h"
#include "file.h"
#include "dev_sioctl.h"
#include "utils.h"

void dev_sioctl_ondesc(void *, struct sioctl_desc *, int);
void dev_sioctl_onval(void *, unsigned int, unsigned int);
int dev_sioctl_pollfd(void *, struct pollfd *);
int dev_sioctl_revents(void *, struct pollfd *);
void dev_sioctl_in(void *);
void dev_sioctl_out(void *);
void dev_sioctl_hup(void *);

struct fileops dev_sioctl_ops = {
        "sioctl",
        dev_sioctl_pollfd,
        dev_sioctl_revents,
        dev_sioctl_in,
        dev_sioctl_out,
        dev_sioctl_hup
};

void
dev_sioctl_ondesc(void *arg, struct sioctl_desc *desc, int val)
{
        struct dev *d = arg;
        char *group, group_buf[CTL_NAMEMAX];

        if (desc == NULL) {
                dev_ctlsync(d);
                return;
        }

        ctl_del(CTL_HW, d, &desc->addr);

        if (desc->group[0] == 0)
                group = d->name;
        else {
                if (snprintf(group_buf, CTL_NAMEMAX, "%s/%s",
                        d->name, desc->group) >= CTL_NAMEMAX)
                        return;
                group = group_buf;
        }

        ctl_new(CTL_HW, d, &desc->addr,
            desc->type, desc->display, group,
            desc->node0.name, desc->node0.unit, desc->func,
            desc->node1.name, desc->node1.unit, desc->maxval, val);
}

void
dev_sioctl_onval(void *arg, unsigned int addr, unsigned int val)
{
        char str[64];
        struct dev *d = arg;
        struct ctl *c;

        logx(2, "%s: onctl: addr = %u, val = %u", d->path, addr, val);

        for (c = ctl_list; c != NULL; c = c->next) {
                if (c->scope != CTL_HW || c->u.hw.dev != d ||
                    c->u.hw.addr != addr)
                        continue;

                logx(2, "ctl%u: %s -> %u", c->addr,
                    (ctl_fmt(str, sizeof(str), c), str), val);

                c->val_mask = ~0U;
                c->curval = val;
        }
}

/*
 * open the control device.
 */
void
dev_sioctl_open(struct dev *d)
{
        if (d->sioctl.hdl == NULL) {
                /*
                 * At this point there are clients, for instance if we're
                 * called by dev_reopen() but the control device couldn't
                 * be opened. In this case controls have changed (thoseof
                 * old device are just removed) so we need to notify clients.
                 */
                dev_ctlsync(d);
                return;
        }
        sioctl_ondesc(d->sioctl.hdl, dev_sioctl_ondesc, d);
        sioctl_onval(d->sioctl.hdl, dev_sioctl_onval, d);
}

/*
 * close the control device.
 */
void
dev_sioctl_close(struct dev *d)
{
        struct ctl *c, **pc;

        /* remove controls */
        pc = &ctl_list;
        while ((c = *pc) != NULL) {
                if (c->scope == CTL_HW && c->u.hw.dev == d) {
                        c->refs_mask &= ~CTL_DEVMASK;
                        if (c->refs_mask == 0) {
                                *pc = c->next;
                                xfree(c);
                                continue;
                        }
                        c->type = CTL_NONE;
                        c->desc_mask = ~0;
                }
                pc = &c->next;
        }
        dev_ctlsync(d);
}

int
dev_sioctl_pollfd(void *arg, struct pollfd *pfd)
{
        struct dev *d = arg;
        struct ctl *c;
        int events = 0;

        for (c = ctl_list; c != NULL; c = c->next) {
                if (c->scope == CTL_HW && c->u.hw.dev == d && c->dirty)
                        events |= POLLOUT;
        }
        return sioctl_pollfd(d->sioctl.hdl, pfd, events);
}

int
dev_sioctl_revents(void *arg, struct pollfd *pfd)
{
        struct dev *d = arg;

        return sioctl_revents(d->sioctl.hdl, pfd);
}

void
dev_sioctl_in(void *arg)
{
}

void
dev_sioctl_out(void *arg)
{
        struct dev *d = arg;
        struct ctl *c;
        int cnt;

        /*
         * for each dirty ctl, call sioctl_setval() and dev_unref(). As
         * dev_unref() may destroy the ctl_list, we must call it after
         * we've finished iterating on it.
         */
        cnt = 0;
        for (c = ctl_list; c != NULL; c = c->next) {
                if (c->scope != CTL_HW || c->u.hw.dev != d || !c->dirty)
                        continue;
                if (!sioctl_setval(d->sioctl.hdl, c->u.hw.addr, c->curval)) {
                        logx(1, "ctl%u: set failed", c->addr);
                        break;
                }
                c->dirty = 0;
                cnt++;
        }
        while (cnt-- > 0)
                dev_unref(d);
}

void
dev_sioctl_hup(void *arg)
{
        struct dev *d = arg;

        dev_sioctl_close(d);
        file_del(d->sioctl.file);
        sioctl_close(d->sioctl.hdl);
        d->sioctl.hdl = NULL;
}