/*
 * Copyright © 2014 NVIDIA 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.
 */

#include <stdio.h>
#include <string.h>
#include <unistd.h>

#include "util/common.h"
#include "libkms-test.h"

static const char *const connector_names[] = {
	"Unknown",
	"VGA",
	"DVI-I",
	"DVI-D",
	"DVI-A",
	"Composite",
	"SVIDEO",
	"LVDS",
	"Component",
	"9PinDIN",
	"DisplayPort",
	"HDMI-A",
	"HDMI-B",
	"TV",
	"eDP",
	"Virtual",
	"DSI",
};

static void kms_device_probe_screens(struct kms_device *device)
{
	unsigned int counts[ARRAY_SIZE(connector_names)];
	struct kms_screen *screen;
	drmModeRes *res;
	int i;

	memset(counts, 0, sizeof(counts));

	res = drmModeGetResources(device->fd);
	if (!res)
		return;

	device->screens = calloc(res->count_connectors, sizeof(screen));
	if (!device->screens)
		goto err_free_resources;

	for (i = 0; i < res->count_connectors; i++) {
		unsigned int *count;
		const char *type;
		int len;

		screen = kms_screen_create(device, res->connectors[i]);
		if (!screen)
			continue;

		/* assign a unique name to this screen */
		type = connector_names[screen->type];
		count = &counts[screen->type];

		len = snprintf(NULL, 0, "%s-%u", type, *count);

		screen->name = malloc(len + 1);
		if (!screen->name) {
			free(screen);
			continue;
		}

		snprintf(screen->name, len + 1, "%s-%u", type, *count);
		(*count)++;

		device->screens[i] = screen;
		device->num_screens++;
	}

err_free_resources:
	drmModeFreeResources(res);
}

static void kms_device_probe_crtcs(struct kms_device *device)
{
	struct kms_crtc *crtc;
	drmModeRes *res;
	int i;

	res = drmModeGetResources(device->fd);
	if (!res)
		return;

	device->crtcs = calloc(res->count_crtcs, sizeof(crtc));
	if (!device->crtcs)
		goto err_free_resources;

	for (i = 0; i < res->count_crtcs; i++) {
		crtc = kms_crtc_create(device, res->crtcs[i]);
		if (!crtc)
			continue;

		device->crtcs[i] = crtc;
		device->num_crtcs++;
	}

err_free_resources:
	drmModeFreeResources(res);
}

static void kms_device_probe_planes(struct kms_device *device)
{
	struct kms_plane *plane;
	drmModePlaneRes *res;
	unsigned int i;

	res = drmModeGetPlaneResources(device->fd);
	if (!res)
		return;

	device->planes = calloc(res->count_planes, sizeof(plane));
	if (!device->planes)
		goto err_free_resources;

	for (i = 0; i < res->count_planes; i++) {
		plane = kms_plane_create(device, res->planes[i]);
		if (!plane)
			continue;

		device->planes[i] = plane;
		device->num_planes++;
	}

err_free_resources:
	drmModeFreePlaneResources(res);
}

static void kms_device_probe(struct kms_device *device)
{
	kms_device_probe_screens(device);
	kms_device_probe_crtcs(device);
	kms_device_probe_planes(device);
}

struct kms_device *kms_device_open(int fd)
{
	struct kms_device *device;

	device = calloc(1, sizeof(*device));
	if (!device)
		return NULL;

	device->fd = fd;

	kms_device_probe(device);

	return device;
}

void kms_device_close(struct kms_device *device)
{
	unsigned int i;

	for (i = 0; i < device->num_planes; i++)
		kms_plane_free(device->planes[i]);

	free(device->planes);

	for (i = 0; i < device->num_crtcs; i++)
		kms_crtc_free(device->crtcs[i]);

	free(device->crtcs);

	for (i = 0; i < device->num_screens; i++)
		kms_screen_free(device->screens[i]);

	free(device->screens);

	if (device->fd >= 0)
		close(device->fd);

	free(device);
}

struct kms_plane *kms_device_find_plane_by_type(struct kms_device *device,
						uint32_t type,
						unsigned int index)
{
	unsigned int i;

	for (i = 0; i < device->num_planes; i++) {
		if (device->planes[i]->type == type) {
			if (index == 0)
				return device->planes[i];

			index--;
		}
	}

	return NULL;
}