/*      $NetBSD: rf_compat50.c,v 1.13 2019/12/15 16:48:27 tsutsui Exp $ */

/*-
 * Copyright (c) 2009 The NetBSD Foundation, Inc.
 * All rights reserved.
 *
 * This code is derived from software contributed to The NetBSD Foundation
 * by Christos Zoulas.
 *
 * 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/types.h>
#include <sys/param.h>
#include <sys/systm.h>
#include <sys/module.h>

#include <sys/compat_stub.h>

#include <dev/raidframe/raidframeio.h>
#include <dev/raidframe/raidframevar.h>

#include "rf_raid.h"
#include "rf_compat50.h"
#include "rf_debugMem.h"

typedef struct RF_Config50_s {
        RF_RowCol_t             numRow, numCol, numSpare;
        int32_t                 devs[RF_MAXROW][RF_MAXCOL];
        char                    devnames[RF_MAXROW][RF_MAXCOL][50];
        int32_t                 spare_devs[RF_MAXSPARE];
        char                    spare_names[RF_MAXSPARE][50];
        RF_SectorNum_t          sectPerSU;
        RF_StripeNum_t          SUsPerPU;
        RF_StripeNum_t          SUsPerRU;
        RF_ParityConfig_t       parityConfig;
        RF_DiskQueueType_t      diskQueueType;
        char                    maxOutstandingDiskReqs;
        char                    debugVars[RF_MAXDBGV][50];
        unsigned int            layoutSpecificSize;
        void                   *layoutSpecific;
        int                     force;
} RF_Config50_t;

typedef struct RF_RaidDisk50_s {
        char             devname[56];
        RF_DiskStatus_t  status;
        RF_RowCol_t      spareRow;
        RF_RowCol_t      spareCol;
        RF_SectorCount_t numBlocks;
        int              blockSize;
        RF_SectorCount_t partitionSize;
        int              auto_configured;
        int32_t          dev;
} RF_RaidDisk50_t;

typedef struct RF_DeviceConfig50_s {
        u_int                   rows;
        u_int                   cols;
        u_int                   maxqdepth;
        int                     ndevs;
        RF_RaidDisk50_t         devs[RF_MAX_DISKS];
        u_int                   nspares;
        RF_RaidDisk50_t         spares[RF_MAX_DISKS];
} RF_DeviceConfig50_t;

static void
rf_disk_to_disk50(RF_RaidDisk50_t *d50, const RF_RaidDisk_t *d)
{
        memcpy(d50->devname, d->devname, sizeof(d50->devname));
        d50->status = d->status;
        d50->spareRow = 0;
        d50->spareCol = d->spareCol;
        d50->numBlocks = d->numBlocks;
        d50->blockSize = d->blockSize;
        d50->partitionSize = d->partitionSize;
        d50->auto_configured = d->auto_configured;
        d50->dev = d->dev;
}

static int
rf_config50(struct raid_softc *rs, void *data)
{
        RF_Config50_t *u50_cfg, *k50_cfg;
        RF_Config_t *k_cfg;
        RF_Raid_t *raidPtr = rf_get_raid(rs);
        size_t i, j;
        int error;

        if (raidPtr->valid) {
                /* There is a valid RAID set running on this unit! */
                printf("raid%d: Device already configured!\n", rf_get_unit(rs));
                return EINVAL;
        }

        /* copy-in the configuration information */
        /* data points to a pointer to the configuration structure */

        u50_cfg = *((RF_Config50_t **) data);
        k50_cfg = RF_Malloc(sizeof(*k50_cfg));
        if (k50_cfg == NULL)
                return ENOMEM;

        error = copyin(u50_cfg, k50_cfg, sizeof(*k50_cfg));
        if (error) {
                RF_Free(k50_cfg, sizeof(*k50_cfg));
                return error;
        }
        k_cfg = RF_Malloc(sizeof(*k_cfg));
        if (k_cfg == NULL) {
                RF_Free(k50_cfg, sizeof(*k50_cfg));
                return ENOMEM;
        }

        k_cfg->numCol = k50_cfg->numCol;
        k_cfg->numSpare = k50_cfg->numSpare;

        for (i = 0; i < RF_MAXROW; i++)
                for (j = 0; j < RF_MAXCOL; j++)
                        k_cfg->devs[i][j] = k50_cfg->devs[i][j];

        memcpy(k_cfg->devnames, k50_cfg->devnames,
            sizeof(k_cfg->devnames));

        for (i = 0; i < RF_MAXSPARE; i++)
                k_cfg->spare_devs[i] = k50_cfg->spare_devs[i];

        memcpy(k_cfg->spare_names, k50_cfg->spare_names,
            sizeof(k_cfg->spare_names));

        k_cfg->sectPerSU = k50_cfg->sectPerSU;
        k_cfg->SUsPerPU = k50_cfg->SUsPerPU;
        k_cfg->SUsPerRU = k50_cfg->SUsPerRU;
        k_cfg->parityConfig = k50_cfg->parityConfig;

        memcpy(k_cfg->diskQueueType, k50_cfg->diskQueueType,
            sizeof(k_cfg->diskQueueType));

        k_cfg->maxOutstandingDiskReqs = k50_cfg->maxOutstandingDiskReqs;

        memcpy(k_cfg->debugVars, k50_cfg->debugVars,
            sizeof(k_cfg->debugVars));

        k_cfg->layoutSpecificSize = k50_cfg->layoutSpecificSize;
        k_cfg->layoutSpecific = k50_cfg->layoutSpecific;
        k_cfg->force = k50_cfg->force;

        RF_Free(k50_cfg, sizeof(*k50_cfg));
        return rf_construct(rs, k_cfg);
}

static int
rf_get_info50(RF_Raid_t *raidPtr, void *data)
{
        RF_DeviceConfig50_t **ucfgp = data, *d_cfg;
        size_t i, j;
        int error;

        if (!raidPtr->valid)
                return ENODEV;

        d_cfg = RF_Malloc(sizeof(*d_cfg));

        if (d_cfg == NULL)
                return ENOMEM;

        d_cfg->rows = 1; /* there is only 1 row now */
        d_cfg->cols = raidPtr->numCol;
        d_cfg->ndevs = raidPtr->numCol;
        if (d_cfg->ndevs >= RF_MAX_DISKS) {
                error = ENOMEM;
                goto out;
        }

        d_cfg->nspares = raidPtr->numSpare;
        if (d_cfg->nspares >= RF_MAX_DISKS) {
                error = ENOMEM;
                goto out;
        }

        d_cfg->maxqdepth = raidPtr->maxQueueDepth;
        for (j = 0; j < d_cfg->cols; j++)
                rf_disk_to_disk50(&d_cfg->devs[j], &raidPtr->Disks[j]);

        for (j = d_cfg->cols, i = 0; i < d_cfg->nspares; i++, j++)
                rf_disk_to_disk50(&d_cfg->spares[i], &raidPtr->Disks[j]);

        error = copyout(d_cfg, *ucfgp, sizeof(**ucfgp));

out:
        RF_Free(d_cfg, sizeof(*d_cfg));
        return error;
}

static int
raidframe_ioctl_50(struct raid_softc *rs, u_long cmd, void *data)
{
        RF_Raid_t *raidPtr = rf_get_raid(rs);

        switch (cmd) {
        case RAIDFRAME_GET_INFO50:
                if (!rf_inited(rs))
                        return ENXIO;
                return rf_get_info50(raidPtr, data);

        case RAIDFRAME_CONFIGURE50:
                return rf_config50(rs, data);
        default:
                return EPASSTHROUGH;
        }
}

static void
raidframe_50_init(void)
{

        MODULE_HOOK_SET(raidframe_ioctl_50_hook, raidframe_ioctl_50);
}

static void
raidframe_50_fini(void)
{

        MODULE_HOOK_UNSET(raidframe_ioctl_50_hook);
}

MODULE(MODULE_CLASS_EXEC, compat_raid_50, "raid,compat_50,compat_raid_80");

static int
compat_raid_50_modcmd(modcmd_t cmd, void *arg)
{

        switch (cmd) {
        case MODULE_CMD_INIT:
                raidframe_50_init();
                return 0;
        case MODULE_CMD_FINI:
                raidframe_50_fini();
                return 0;
        default:
                return ENOTTY;
        }
}