/*-
 *   Copyright (C) 2011 by Maxim Ignatenko
 *   gelraen.ua@gmail.com
 *   Copyright (C) 2015  Sascha Wildner
 *   swildner@dragonflybsd.org
 *
 *   All rights reserved.                                                  *
 *                                                                         *
 *   Redistribution and use in source and binary forms, with or without    *
 *    modification, are permitted provided that the following conditions   *
 *    are met:                                                             *
 *     * Redistributions of source code must retain the above copyright    *
 *       notice, this list of conditions and the following disclaimer.     *
 *     * 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 COPYRIGHT HOLDERS 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 COPYRIGHT  *
 *   OWNER 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/param.h>
#include <sys/ioctl.h>
#include <fcntl.h>
#include <unistd.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <uuid.h>

#include <contrib/dev/acpica/source/include/acpi.h>
#include <dev/acpica/acpiio_mcall.h>

#define MAX_ACPI_PATH   4096

static char     dev_path[MAXPATHLEN] = "/dev/acpi";
static char     method_path[MAX_ACPI_PATH] = "";
static size_t   result_buf_size = 1024;
static char     output_format = 'o';
static int      verbose;
static ACPI_OBJECT args[ACPI_METHOD_NUM_ARGS];
static struct acpi_mcall_ioctl_arg params;

static void     usage(void);
static int      parse_buffer(ACPI_OBJECT *, char *);
static void     print_params(struct acpi_mcall_ioctl_arg *);
static void     print_acpi_object(ACPI_OBJECT *);
static void     print_acpi_buffer(ACPI_BUFFER *, char);

int
main(int argc, char *argv[])
{
        char c;
        int i, fd, status;
        uuid_t uuid;

        bzero(&params, sizeof(params));
        params.path = method_path;
        params.args.Count = 0;
        params.args.Pointer = args;

        while ((c = getopt(argc, argv, "b:d:i:o:s:U:v")) != -1) {
                switch (c) {
                case 'b':
                case 'i':
                case 's':
                case 'U':
                        i = params.args.Count;
                        if (i >= ACPI_METHOD_NUM_ARGS) {
                                fprintf(stderr,
                                    "maximum number of %d args exceeded\n",
                                    ACPI_METHOD_NUM_ARGS);
                                exit(1);
                        }
                        switch (optopt) {
                        case 'b':
                                if (parse_buffer(&args[i], optarg) != 0) {
                                        fprintf(stderr,
                                            "unable to parse hexstring: %s\n",
                                            optarg);
                                        exit(1);
                                }
                                break;
                        case 'i':
                                args[i].Type = ACPI_TYPE_INTEGER;
                                args[i].Integer.Value =
                                    strtol(optarg, NULL, 10);
                                break;
                        case 's':
                                args[i].Type = ACPI_TYPE_STRING;
                                args[i].String.Length = strlen(optarg);
                                args[i].String.Pointer = optarg;
                                break;
                        case 'U':
                                uuid_from_string(optarg, &uuid, &status);
                                if (status != uuid_s_ok) {
                                        fprintf(stderr, "invalid uuid %s\n",
                                            optarg);
                                        exit(1);
                                }
                                args[i].Type = ACPI_TYPE_BUFFER;
                                args[i].Buffer.Length = 16;
                                if ((args[i].Buffer.Pointer = malloc(16)) == NULL) {
                                        fprintf(stderr, "malloc failure\n");
                                        exit(1);
                                }
                                uuid_enc_le(args[i].Buffer.Pointer, &uuid);
                                break;
                        }
                        params.args.Count++;
                        break;
                case 'd':
                        strlcpy(dev_path, optarg, MAXPATHLEN);
                        break;
                case 'o':
                        switch (optarg[0]) {
                        case 'b':
                        case 'i':
                        case 'o':
                        case 's':
                                output_format = optarg[0];
                                break;
                        default:
                                fprintf(stderr,
                                    "incorrect output format: %c\n",
                                    optarg[0]);
                                usage();
                                break;
                        }
                        break;
                case 'v':
                        verbose = 1;
                        break;
                default:
                        usage();
                        break;
                }
        }
        argc -= optind;
        argv += optind;

        if (argc != 1)
                usage();
        strlcpy(method_path, argv[0], MAX_ACPI_PATH);

        params.result.Length = result_buf_size;
        params.result.Pointer = malloc(result_buf_size);

        if (params.result.Pointer == NULL) {
                perror("malloc");
                return 1;
        }

        if (method_path[0] == 0) {
                fprintf(stderr,
                    "please specify path to method with -p flag\n");
                return 1;
        }

        if (verbose)
                print_params(&params);

        fd = open(dev_path, O_RDWR);
        if (fd < 0) {
                perror("open");
                return 1;
        }
        if (ioctl(fd, ACPIIO_DO_MCALL, &params) == -1) {
                perror("ioctl");
                return 1;
        }

        if (verbose)
                printf("status: %d\nresult: ", params.retval);
        print_acpi_buffer(&params.result, output_format);
        printf("\n");

        return params.retval;
}

static void
usage(void)
{
        fprintf(stderr,
            "usage: acpicall [-v] [-b hexstring] [-d file] [-i number] "
            "[-o i | s | b | o]\n");
        fprintf(stderr, "                [-s string] [-U uuid] path\n");
        exit(1);
}

static int
parse_buffer(ACPI_OBJECT *dst, char *src)
{
        char tmp[3] = { 0 };
        size_t len = strlen(src) / 2, i;

        dst->Type = ACPI_TYPE_BUFFER;
        dst->Buffer.Length = len;
        if ((dst->Buffer.Pointer = malloc(len)) == NULL) {
                fprintf(stderr,
                    "%s: failed to allocate %zu bytes\n", __func__, len);
                exit(1);
        }

        for (i = 0; i < len; i++) {
                tmp[0] = src[i * 2];
                tmp[1] = src[i * 2 + 1];
                dst->Buffer.Pointer[i] = strtol(tmp, NULL, 16);
        }

        return 0;
}

static void
print_params(struct acpi_mcall_ioctl_arg *p)
{
        int i;

        printf("path: %s\n", p->path);
        printf("number of arguments: %d\n", p->args.Count);
        for (i = 0; i < (int)p->args.Count; i++) {
                printf("argument %d type: ", i + 1);
                switch (p->args.Pointer[i].Type) {
                case ACPI_TYPE_INTEGER:
                        printf("integer\n");
                        break;
                case ACPI_TYPE_STRING:
                        printf("string\n");
                        break;
                case ACPI_TYPE_BUFFER:
                        printf("buffer\n");
                        break;
                }
                printf("argument %d value: ", i + 1);
                print_acpi_object(&(p->args.Pointer[i]));
                printf("\n");
        }
}

static void
print_acpi_object(ACPI_OBJECT *obj)
{
        int i;

        switch (obj->Type) {
        case ACPI_TYPE_INTEGER:
                printf("%ju", (uintmax_t)obj->Integer.Value);
                break;
        case ACPI_TYPE_STRING:
                printf("%s", obj->String.Pointer);
                break;
        case ACPI_TYPE_BUFFER:
                for (i = 0; i < (int)obj->Buffer.Length; i++)
                        printf("%02x", obj->Buffer.Pointer[i]);
                break;
        default:
                printf("unknown object type '%d'", obj->Type);
                break;
        }       
}

static void
print_acpi_buffer(ACPI_BUFFER *buf, char format)
{
        int i;

        switch (format) {
        case 'i':
                printf("%ju", (uintmax_t)*((UINT64 *)buf->Pointer));
                break;
        case 's':
                printf("%s", (char *)buf->Pointer);
                break;
        case 'b':
                for (i = 0; i < (int)buf->Length; i++)
                        printf("%02x", ((UINT8 *)(buf->Pointer))[i]);
                break;
        case 'o':
                print_acpi_object((ACPI_OBJECT *)buf->Pointer);
                break;
        }
}