/*
 * Copyright © 2012 Intel Corporation
 *
 * Permission is hereby granted, free of charge, to any person obtaining a
 * copy of this software and associated documentation files (the "Software"),
 * to deal in the Software without restriction, including without limitation
 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
 * and/or sell copies of the Software, and to permit persons to whom the
 * Software is furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice (including the next
 * paragraph) shall be included in all copies or substantial portions of the
 * Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
 * DEALINGS IN THE SOFTWARE.
 *
 * Authors:
 *    Eugeni Dodonov <eugeni.dodonov@intel.com>
 *
 */

extern "C" {

#include <sys/resource.h>
#include <sys/time.h>
#include <stdlib.h>
#include <unistd.h>
#include <err.h>
#include <pciaccess.h>

#include "intel_stats.h"

void *mmio;
static pthread_t m_thread;
static pthread_mutex_t m_lock;

static Stats counter1, counter2;


static inline uint32_t
INREG(uint32_t reg)
{
	return *(volatile uint32_t *)((volatile char *)mmio + reg);
}

void
intel_get_mmio(struct pci_device *pci_dev)
{
    uint32_t devid;
    int mmio_bar;
    int err;

    devid = pci_dev->device_id;
    if (IS_GEN2(devid))
        mmio_bar = 1;
    else
        mmio_bar = 0;

    err = pci_device_map_range (pci_dev,
                    pci_dev->regions[mmio_bar].base_addr,
                    pci_dev->regions[mmio_bar].size,
                    PCI_DEV_MAP_FLAG_WRITABLE,
                    &mmio);

    if (err != 0) {
        fprintf(stderr, "Couldn't map MMIO region: %s\n",
            strerror(err));
        exit(1);
    }
}

struct pci_device *
intel_get_pci_device(void)
{
	struct pci_device *pci_dev;
	int err;

	err = pci_system_init();
	if (err != 0) {
		fprintf(stderr, "Couldn't initialize PCI system: %s\n",
			strerror(err));
		exit(1);
	}

	/* Grab the graphics card */
	pci_dev = pci_device_find_by_slot(0, 0, 2, 0);
	if (pci_dev == NULL)
		errx(1, "Couldn't find graphics card");

	err = pci_device_probe(pci_dev);
	if (err != 0) {
		fprintf(stderr, "Couldn't probe graphics card: %s\n",
			strerror(err));
		exit(1);
	}

	if (pci_dev->vendor_id != 0x8086)
		errx(1, "Graphics card is non-intel");

	return pci_dev;
}

void m_init() {
    intel_get_mmio(intel_get_pci_device());

    pthread_mutex_init(&m_lock, NULL);

    pthread_mutex_lock(&m_lock);
    /* Initialize starting values */
    pthread_mutex_unlock(&m_lock);

    /* Run GPU monitoring thread */
    pthread_create(&m_thread, 0, m_monitor, NULL);
}

void m_reset() {
    struct rusage r;

    /* Reset counter1 to counter2 values */
    pthread_mutex_lock(&m_lock);

    getrusage(RUSAGE_SELF, &r);
    counter2.user = r.ru_utime;
    counter2.system = r.ru_stime;
    gettimeofday(&counter2.time, NULL);

    counter1.user = counter2.user;
    counter1.system = counter2.system;
    counter1.gpu = counter2.gpu;
    counter1.gpuidle = counter2.gpuidle;

    counter1.time = counter2.time;
    pthread_mutex_unlock(&m_lock);
}

Stats m_count() {
    Stats stats;
    struct rusage r;

    pthread_mutex_lock(&m_lock);

    getrusage(RUSAGE_SELF, &r);

    gettimeofday(&counter2.time, NULL);

    counter2.user = r.ru_utime;
    counter2.system = r.ru_stime;

    /* Do the calculations */
    timersub(&counter2.time, &counter1.time, &stats.time);
    timersub(&counter2.user, &counter1.user, &stats.user);
    timersub(&counter2.system, &counter1.system, &stats.system);
    stats.gpu = counter2.gpu - counter1.gpu;
    stats.gpuidle = counter2.gpuidle - counter1.gpuidle;

    pthread_mutex_unlock(&m_lock);

    return stats;
}

void *m_monitor( void *data) {
    while(1) {
        uint32_t ring_head, ring_tail;

        /* GPU usage */
        ring_head = INREG(LP_RING + RING_HEAD) & HEAD_ADDR;
        ring_tail = INREG(LP_RING + RING_TAIL) & TAIL_ADDR;

        pthread_mutex_lock(&m_lock);
        /* GPU stats */
        if (ring_tail == ring_head)
            counter2.gpuidle++;
        counter2.gpu++;
        pthread_mutex_unlock(&m_lock);
        usleep(1000000 / SAMPLES_PER_SEC);
    }
    return NULL;
}

}