[deliverable/linux.git] / drivers / gpu / drm / drm_edid_load.c

/*
   drm_edid_load.c: use a built-in EDID data set or load it via the firmware
		    interface

   Copyright (C) 2012 Carsten Emde <C.Emde@osadl.org>

   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License
   as published by the Free Software Foundation; either version 2
   of the License, or (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA.
*/

#include <linux/module.h>
#include <linux/firmware.h>
#include <drm/drmP.h>
#include <drm/drm_crtc.h>
#include <drm/drm_crtc_helper.h>
#include <drm/drm_edid.h>

static char edid_firmware[PATH_MAX];
module_param_string(edid_firmware, edid_firmware, sizeof(edid_firmware), 0644);
MODULE_PARM_DESC(edid_firmware, "Do not probe monitor, use specified EDID blob "
	"from built-in data or /lib/firmware instead. ");

#define GENERIC_EDIDS 6
static const char *generic_edid_name[GENERIC_EDIDS] = {
	"edid/800x600.bin",
	"edid/1024x768.bin",
	"edid/1280x1024.bin",
	"edid/1600x1200.bin",
	"edid/1680x1050.bin",
	"edid/1920x1080.bin",
};

static const u8 generic_edid[GENERIC_EDIDS][128] = {
	{
	0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00,
	0x31, 0xd8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
	0x05, 0x16, 0x01, 0x03, 0x6d, 0x1b, 0x14, 0x78,
	0xea, 0x5e, 0xc0, 0xa4, 0x59, 0x4a, 0x98, 0x25,
	0x20, 0x50, 0x54, 0x01, 0x00, 0x00, 0x45, 0x40,
	0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
	0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0xa0, 0x0f,
	0x20, 0x00, 0x31, 0x58, 0x1c, 0x20, 0x28, 0x80,
	0x14, 0x00, 0x15, 0xd0, 0x10, 0x00, 0x00, 0x1e,
	0x00, 0x00, 0x00, 0xff, 0x00, 0x4c, 0x69, 0x6e,
	0x75, 0x78, 0x20, 0x23, 0x30, 0x0a, 0x20, 0x20,
	0x20, 0x20, 0x00, 0x00, 0x00, 0xfd, 0x00, 0x3b,
	0x3d, 0x24, 0x26, 0x05, 0x00, 0x0a, 0x20, 0x20,
	0x20, 0x20, 0x20, 0x20, 0x00, 0x00, 0x00, 0xfc,
	0x00, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x20, 0x53,
	0x56, 0x47, 0x41, 0x0a, 0x20, 0x20, 0x00, 0xc2,
	},
	{
	0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00,
	0x31, 0xd8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
	0x05, 0x16, 0x01, 0x03, 0x6d, 0x23, 0x1a, 0x78,
	0xea, 0x5e, 0xc0, 0xa4, 0x59, 0x4a, 0x98, 0x25,
	0x20, 0x50, 0x54, 0x00, 0x08, 0x00, 0x61, 0x40,
	0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
	0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x64, 0x19,
	0x00, 0x40, 0x41, 0x00, 0x26, 0x30, 0x08, 0x90,
	0x36, 0x00, 0x63, 0x0a, 0x11, 0x00, 0x00, 0x18,
	0x00, 0x00, 0x00, 0xff, 0x00, 0x4c, 0x69, 0x6e,
	0x75, 0x78, 0x20, 0x23, 0x30, 0x0a, 0x20, 0x20,
	0x20, 0x20, 0x00, 0x00, 0x00, 0xfd, 0x00, 0x3b,
	0x3d, 0x2f, 0x31, 0x07, 0x00, 0x0a, 0x20, 0x20,
	0x20, 0x20, 0x20, 0x20, 0x00, 0x00, 0x00, 0xfc,
	0x00, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x20, 0x58,
	0x47, 0x41, 0x0a, 0x20, 0x20, 0x20, 0x00, 0x55,
	},
	{
	0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00,
	0x31, 0xd8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
	0x05, 0x16, 0x01, 0x03, 0x6d, 0x2c, 0x23, 0x78,
	0xea, 0x5e, 0xc0, 0xa4, 0x59, 0x4a, 0x98, 0x25,
	0x20, 0x50, 0x54, 0x00, 0x00, 0x00, 0x81, 0x80,
	0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
	0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x30, 0x2a,
	0x00, 0x98, 0x51, 0x00, 0x2a, 0x40, 0x30, 0x70,
	0x13, 0x00, 0xbc, 0x63, 0x11, 0x00, 0x00, 0x1e,
	0x00, 0x00, 0x00, 0xff, 0x00, 0x4c, 0x69, 0x6e,
	0x75, 0x78, 0x20, 0x23, 0x30, 0x0a, 0x20, 0x20,
	0x20, 0x20, 0x00, 0x00, 0x00, 0xfd, 0x00, 0x3b,
	0x3d, 0x3e, 0x40, 0x0b, 0x00, 0x0a, 0x20, 0x20,
	0x20, 0x20, 0x20, 0x20, 0x00, 0x00, 0x00, 0xfc,
	0x00, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x20, 0x53,
	0x58, 0x47, 0x41, 0x0a, 0x20, 0x20, 0x00, 0xa0,
	},
	{
	0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00,
	0x31, 0xd8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
	0x05, 0x16, 0x01, 0x03, 0x6d, 0x37, 0x29, 0x78,
	0xea, 0x5e, 0xc0, 0xa4, 0x59, 0x4a, 0x98, 0x25,
	0x20, 0x50, 0x54, 0x00, 0x00, 0x00, 0xa9, 0x40,
	0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
	0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x48, 0x3f,
	0x40, 0x30, 0x62, 0xb0, 0x32, 0x40, 0x40, 0xc0,
	0x13, 0x00, 0x2b, 0xa0, 0x21, 0x00, 0x00, 0x1e,
	0x00, 0x00, 0x00, 0xff, 0x00, 0x4c, 0x69, 0x6e,
	0x75, 0x78, 0x20, 0x23, 0x30, 0x0a, 0x20, 0x20,
	0x20, 0x20, 0x00, 0x00, 0x00, 0xfd, 0x00, 0x3b,
	0x3d, 0x4a, 0x4c, 0x11, 0x00, 0x0a, 0x20, 0x20,
	0x20, 0x20, 0x20, 0x20, 0x00, 0x00, 0x00, 0xfc,
	0x00, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x20, 0x55,
	0x58, 0x47, 0x41, 0x0a, 0x20, 0x20, 0x00, 0x9d,
	},
	{
	0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00,
	0x31, 0xd8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
	0x05, 0x16, 0x01, 0x03, 0x6d, 0x2b, 0x1b, 0x78,
	0xea, 0x5e, 0xc0, 0xa4, 0x59, 0x4a, 0x98, 0x25,
	0x20, 0x50, 0x54, 0x00, 0x00, 0x00, 0xb3, 0x00,
	0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
	0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x21, 0x39,
	0x90, 0x30, 0x62, 0x1a, 0x27, 0x40, 0x68, 0xb0,
	0x36, 0x00, 0xb5, 0x11, 0x11, 0x00, 0x00, 0x1e,
	0x00, 0x00, 0x00, 0xff, 0x00, 0x4c, 0x69, 0x6e,
	0x75, 0x78, 0x20, 0x23, 0x30, 0x0a, 0x20, 0x20,
	0x20, 0x20, 0x00, 0x00, 0x00, 0xfd, 0x00, 0x3b,
	0x3d, 0x40, 0x42, 0x0f, 0x00, 0x0a, 0x20, 0x20,
	0x20, 0x20, 0x20, 0x20, 0x00, 0x00, 0x00, 0xfc,
	0x00, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x20, 0x57,
	0x53, 0x58, 0x47, 0x41, 0x0a, 0x20, 0x00, 0x26,
	},
	{
	0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00,
	0x31, 0xd8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
	0x05, 0x16, 0x01, 0x03, 0x6d, 0x32, 0x1c, 0x78,
	0xea, 0x5e, 0xc0, 0xa4, 0x59, 0x4a, 0x98, 0x25,
	0x20, 0x50, 0x54, 0x00, 0x00, 0x00, 0xd1, 0xc0,
	0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
	0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x02, 0x3a,
	0x80, 0x18, 0x71, 0x38, 0x2d, 0x40, 0x58, 0x2c,
	0x45, 0x00, 0xf4, 0x19, 0x11, 0x00, 0x00, 0x1e,
	0x00, 0x00, 0x00, 0xff, 0x00, 0x4c, 0x69, 0x6e,
	0x75, 0x78, 0x20, 0x23, 0x30, 0x0a, 0x20, 0x20,
	0x20, 0x20, 0x00, 0x00, 0x00, 0xfd, 0x00, 0x3b,
	0x3d, 0x42, 0x44, 0x0f, 0x00, 0x0a, 0x20, 0x20,
	0x20, 0x20, 0x20, 0x20, 0x00, 0x00, 0x00, 0xfc,
	0x00, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x20, 0x46,
	0x48, 0x44, 0x0a, 0x20, 0x20, 0x20, 0x00, 0x05,
	},
};

static int edid_size(const u8 *edid, int data_size)
{
	if (data_size < EDID_LENGTH)
		return 0;

	return (edid[0x7e] + 1) * EDID_LENGTH;
}

static void *edid_load(struct drm_connector *connector, const char *name,
			const char *connector_name)
{
	const struct firmware *fw = NULL;
	const u8 *fwdata;
	u8 *edid;
	int fwsize, builtin;
	int i, valid_extensions = 0;
	bool print_bad_edid = !connector->bad_edid_counter || (drm_debug & DRM_UT_KMS);

	builtin = 0;
	for (i = 0; i < GENERIC_EDIDS; i++) {
		if (strcmp(name, generic_edid_name[i]) == 0) {
			fwdata = generic_edid[i];
			fwsize = sizeof(generic_edid[i]);
			builtin = 1;
			break;
		}
	}
	if (!builtin) {
		struct platform_device *pdev;
		int err;

		pdev = platform_device_register_simple(connector_name, -1, NULL, 0);
		if (IS_ERR(pdev)) {
			DRM_ERROR("Failed to register EDID firmware platform device "
				  "for connector \"%s\"\n", connector_name);
			return ERR_CAST(pdev);
		}

		err = request_firmware(&fw, name, &pdev->dev);
		platform_device_unregister(pdev);
		if (err) {
			DRM_ERROR("Requesting EDID firmware \"%s\" failed (err=%d)\n",
				  name, err);
			return ERR_PTR(err);
		}

		fwdata = fw->data;
		fwsize = fw->size;
	}

	if (edid_size(fwdata, fwsize) != fwsize) {
		DRM_ERROR("Size of EDID firmware \"%s\" is invalid "
			  "(expected %d, got %d\n", name,
			  edid_size(fwdata, fwsize), (int)fwsize);
		edid = ERR_PTR(-EINVAL);
		goto out;
	}

	edid = kmemdup(fwdata, fwsize, GFP_KERNEL);
	if (edid == NULL) {
		edid = ERR_PTR(-ENOMEM);
		goto out;
	}

	if (!drm_edid_block_valid(edid, 0, print_bad_edid)) {
		connector->bad_edid_counter++;
		DRM_ERROR("Base block of EDID firmware \"%s\" is invalid ",
		    name);
		kfree(edid);
		edid = ERR_PTR(-EINVAL);
		goto out;
	}

	for (i = 1; i <= edid[0x7e]; i++) {
		if (i != valid_extensions + 1)
			memcpy(edid + (valid_extensions + 1) * EDID_LENGTH,
			    edid + i * EDID_LENGTH, EDID_LENGTH);
		if (drm_edid_block_valid(edid + i * EDID_LENGTH, i, print_bad_edid))
			valid_extensions++;
	}

	if (valid_extensions != edid[0x7e]) {
		u8 *new_edid;

		edid[EDID_LENGTH-1] += edid[0x7e] - valid_extensions;
		DRM_INFO("Found %d valid extensions instead of %d in EDID data "
		    "\"%s\" for connector \"%s\"\n", valid_extensions,
		    edid[0x7e], name, connector_name);
		edid[0x7e] = valid_extensions;

		new_edid = krealloc(edid, (valid_extensions + 1) * EDID_LENGTH,
				    GFP_KERNEL);
		if (new_edid)
			edid = new_edid;
	}

	DRM_INFO("Got %s EDID base block and %d extension%s from "
	    "\"%s\" for connector \"%s\"\n", builtin ? "built-in" :
	    "external", valid_extensions, valid_extensions == 1 ? "" : "s",
	    name, connector_name);

out:
	if (fw)
		release_firmware(fw);
	return edid;
}

int drm_load_edid_firmware(struct drm_connector *connector)
{
	const char *connector_name = connector->name;
	char *edidname = edid_firmware, *last, *colon;
	int ret;
	struct edid *edid;

	if (*edidname == '\0')
		return 0;

	colon = strchr(edidname, ':');
	if (colon != NULL) {
		if (strncmp(connector_name, edidname, colon - edidname))
			return 0;
		edidname = colon + 1;
		if (*edidname == '\0')
			return 0;
	}

	last = edidname + strlen(edidname) - 1;
	if (*last == '\n')
		*last = '\0';

	edid = edid_load(connector, edidname, connector_name);
	if (IS_ERR_OR_NULL(edid))
		return 0;

	drm_mode_connector_update_edid_property(connector, edid);
	ret = drm_add_edid_modes(connector, edid);
	kfree(edid);

	return ret;
}
Commit	Line	Data
da0df92b CE	1	/*
	2	drm_edid_load.c: use a built-in EDID data set or load it via the firmware
	3	interface
	4
	5	Copyright (C) 2012 Carsten Emde <C.Emde@osadl.org>
	6
	7	This program is free software; you can redistribute it and/or
	8	modify it under the terms of the GNU General Public License
	9	as published by the Free Software Foundation; either version 2
	10	of the License, or (at your option) any later version.
	11
	12	This program is distributed in the hope that it will be useful,
	13	but WITHOUT ANY WARRANTY; without even the implied warranty of
	14	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	15	GNU General Public License for more details.
	16
	17	You should have received a copy of the GNU General Public License
	18	along with this program; if not, write to the Free Software
	19	Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	20	*/
	21
	22	#include <linux/module.h>
	23	#include <linux/firmware.h>
760285e7 DH	24	#include <drm/drmP.h>
	25	#include <drm/drm_crtc.h>
	26	#include <drm/drm_crtc_helper.h>
	27	#include <drm/drm_edid.h>
da0df92b CE	28
	29	static char edid_firmware[PATH_MAX];
	30	module_param_string(edid_firmware, edid_firmware, sizeof(edid_firmware), 0644);
	31	MODULE_PARM_DESC(edid_firmware, "Do not probe monitor, use specified EDID blob "
	32	"from built-in data or /lib/firmware instead. ");
	33
4cbe1bfa	34	#define GENERIC_EDIDS 6
9066f83c	35	static const char *generic_edid_name[GENERIC_EDIDS] = {
4cbe1bfa	36	"edid/800x600.bin",
da0df92b CE	37	"edid/1024x768.bin",
da0df92b CE	38	"edid/1280x1024.bin",
8091ee5c	39	"edid/1600x1200.bin",
da0df92b CE	40	"edid/1680x1050.bin",
	41	"edid/1920x1080.bin",
	42	};
	43
9066f83c	44	static const u8 generic_edid[GENERIC_EDIDS][128] = {
4cbe1bfa DT	45	{
	46	0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00,
	47	0x31, 0xd8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
	48	0x05, 0x16, 0x01, 0x03, 0x6d, 0x1b, 0x14, 0x78,
	49	0xea, 0x5e, 0xc0, 0xa4, 0x59, 0x4a, 0x98, 0x25,
	50	0x20, 0x50, 0x54, 0x01, 0x00, 0x00, 0x45, 0x40,
	51	0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
	52	0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0xa0, 0x0f,
	53	0x20, 0x00, 0x31, 0x58, 0x1c, 0x20, 0x28, 0x80,
	54	0x14, 0x00, 0x15, 0xd0, 0x10, 0x00, 0x00, 0x1e,
	55	0x00, 0x00, 0x00, 0xff, 0x00, 0x4c, 0x69, 0x6e,
	56	0x75, 0x78, 0x20, 0x23, 0x30, 0x0a, 0x20, 0x20,
	57	0x20, 0x20, 0x00, 0x00, 0x00, 0xfd, 0x00, 0x3b,
	58	0x3d, 0x24, 0x26, 0x05, 0x00, 0x0a, 0x20, 0x20,
	59	0x20, 0x20, 0x20, 0x20, 0x00, 0x00, 0x00, 0xfc,
	60	0x00, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x20, 0x53,
	61	0x56, 0x47, 0x41, 0x0a, 0x20, 0x20, 0x00, 0xc2,
	62	},
da0df92b CE	63	{
	64	0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00,
	65	0x31, 0xd8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
	66	0x05, 0x16, 0x01, 0x03, 0x6d, 0x23, 0x1a, 0x78,
	67	0xea, 0x5e, 0xc0, 0xa4, 0x59, 0x4a, 0x98, 0x25,
	68	0x20, 0x50, 0x54, 0x00, 0x08, 0x00, 0x61, 0x40,
	69	0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
	70	0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x64, 0x19,
	71	0x00, 0x40, 0x41, 0x00, 0x26, 0x30, 0x08, 0x90,
	72	0x36, 0x00, 0x63, 0x0a, 0x11, 0x00, 0x00, 0x18,
	73	0x00, 0x00, 0x00, 0xff, 0x00, 0x4c, 0x69, 0x6e,
	74	0x75, 0x78, 0x20, 0x23, 0x30, 0x0a, 0x20, 0x20,
	75	0x20, 0x20, 0x00, 0x00, 0x00, 0xfd, 0x00, 0x3b,
	76	0x3d, 0x2f, 0x31, 0x07, 0x00, 0x0a, 0x20, 0x20,
	77	0x20, 0x20, 0x20, 0x20, 0x00, 0x00, 0x00, 0xfc,
	78	0x00, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x20, 0x58,
	79	0x47, 0x41, 0x0a, 0x20, 0x20, 0x20, 0x00, 0x55,
	80	},
	81	{
	82	0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00,
	83	0x31, 0xd8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
	84	0x05, 0x16, 0x01, 0x03, 0x6d, 0x2c, 0x23, 0x78,
	85	0xea, 0x5e, 0xc0, 0xa4, 0x59, 0x4a, 0x98, 0x25,
	86	0x20, 0x50, 0x54, 0x00, 0x00, 0x00, 0x81, 0x80,
	87	0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
	88	0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x30, 0x2a,
	89	0x00, 0x98, 0x51, 0x00, 0x2a, 0x40, 0x30, 0x70,
	90	0x13, 0x00, 0xbc, 0x63, 0x11, 0x00, 0x00, 0x1e,
	91	0x00, 0x00, 0x00, 0xff, 0x00, 0x4c, 0x69, 0x6e,
	92	0x75, 0x78, 0x20, 0x23, 0x30, 0x0a, 0x20, 0x20,
	93	0x20, 0x20, 0x00, 0x00, 0x00, 0xfd, 0x00, 0x3b,
	94	0x3d, 0x3e, 0x40, 0x0b, 0x00, 0x0a, 0x20, 0x20,
	95	0x20, 0x20, 0x20, 0x20, 0x00, 0x00, 0x00, 0xfc,
	96	0x00, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x20, 0x53,
	97	0x58, 0x47, 0x41, 0x0a, 0x20, 0x20, 0x00, 0xa0,
	98	},
	99	{
	100	0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00,
	101	0x31, 0xd8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
8091ee5c CE	102	0x05, 0x16, 0x01, 0x03, 0x6d, 0x37, 0x29, 0x78,
	103	0xea, 0x5e, 0xc0, 0xa4, 0x59, 0x4a, 0x98, 0x25,
	104	0x20, 0x50, 0x54, 0x00, 0x00, 0x00, 0xa9, 0x40,
	105	0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
	106	0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x48, 0x3f,
	107	0x40, 0x30, 0x62, 0xb0, 0x32, 0x40, 0x40, 0xc0,
	108	0x13, 0x00, 0x2b, 0xa0, 0x21, 0x00, 0x00, 0x1e,
	109	0x00, 0x00, 0x00, 0xff, 0x00, 0x4c, 0x69, 0x6e,
	110	0x75, 0x78, 0x20, 0x23, 0x30, 0x0a, 0x20, 0x20,
	111	0x20, 0x20, 0x00, 0x00, 0x00, 0xfd, 0x00, 0x3b,
	112	0x3d, 0x4a, 0x4c, 0x11, 0x00, 0x0a, 0x20, 0x20,
	113	0x20, 0x20, 0x20, 0x20, 0x00, 0x00, 0x00, 0xfc,
	114	0x00, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x20, 0x55,
	115	0x58, 0x47, 0x41, 0x0a, 0x20, 0x20, 0x00, 0x9d,
	116	},
	117	{
	118	0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00,
	119	0x31, 0xd8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
da0df92b CE	120	0x05, 0x16, 0x01, 0x03, 0x6d, 0x2b, 0x1b, 0x78,
	121	0xea, 0x5e, 0xc0, 0xa4, 0x59, 0x4a, 0x98, 0x25,
	122	0x20, 0x50, 0x54, 0x00, 0x00, 0x00, 0xb3, 0x00,
	123	0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
	124	0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x21, 0x39,
	125	0x90, 0x30, 0x62, 0x1a, 0x27, 0x40, 0x68, 0xb0,
	126	0x36, 0x00, 0xb5, 0x11, 0x11, 0x00, 0x00, 0x1e,
	127	0x00, 0x00, 0x00, 0xff, 0x00, 0x4c, 0x69, 0x6e,
	128	0x75, 0x78, 0x20, 0x23, 0x30, 0x0a, 0x20, 0x20,
	129	0x20, 0x20, 0x00, 0x00, 0x00, 0xfd, 0x00, 0x3b,
	130	0x3d, 0x40, 0x42, 0x0f, 0x00, 0x0a, 0x20, 0x20,
	131	0x20, 0x20, 0x20, 0x20, 0x00, 0x00, 0x00, 0xfc,
	132	0x00, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x20, 0x57,
	133	0x53, 0x58, 0x47, 0x41, 0x0a, 0x20, 0x00, 0x26,
	134	},
	135	{
	136	0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00,
	137	0x31, 0xd8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
	138	0x05, 0x16, 0x01, 0x03, 0x6d, 0x32, 0x1c, 0x78,
	139	0xea, 0x5e, 0xc0, 0xa4, 0x59, 0x4a, 0x98, 0x25,
	140	0x20, 0x50, 0x54, 0x00, 0x00, 0x00, 0xd1, 0xc0,
	141	0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
	142	0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x02, 0x3a,
	143	0x80, 0x18, 0x71, 0x38, 0x2d, 0x40, 0x58, 0x2c,
	144	0x45, 0x00, 0xf4, 0x19, 0x11, 0x00, 0x00, 0x1e,
	145	0x00, 0x00, 0x00, 0xff, 0x00, 0x4c, 0x69, 0x6e,
	146	0x75, 0x78, 0x20, 0x23, 0x30, 0x0a, 0x20, 0x20,
	147	0x20, 0x20, 0x00, 0x00, 0x00, 0xfd, 0x00, 0x3b,
	148	0x3d, 0x42, 0x44, 0x0f, 0x00, 0x0a, 0x20, 0x20,
	149	0x20, 0x20, 0x20, 0x20, 0x00, 0x00, 0x00, 0xfc,
	150	0x00, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x20, 0x46,
	151	0x48, 0x44, 0x0a, 0x20, 0x20, 0x20, 0x00, 0x05,
	152	},
	153	};
	154
9066f83c CW	155	static int edid_size(const u8 *edid, int data_size)
	156	{
	157	if (data_size < EDID_LENGTH)
	158	return 0;
	159
	160	return (edid[0x7e] + 1) * EDID_LENGTH;
	161	}
	162
ce456e03	163	static void edid_load(struct drm_connector connector, const char *name,
496fd15b	164	const char *connector_name)
da0df92b	165	{
9066f83c CW	166	const struct firmware *fw = NULL;
	167	const u8 *fwdata;
	168	u8 *edid;
	169	int fwsize, builtin;
da0df92b	170	int i, valid_extensions = 0;
0b2443ed	171	bool print_bad_edid = !connector->bad_edid_counter \|\| (drm_debug & DRM_UT_KMS);
da0df92b	172
9066f83c CW	173	builtin = 0;
	174	for (i = 0; i < GENERIC_EDIDS; i++) {
	175	if (strcmp(name, generic_edid_name[i]) == 0) {
da0df92b CE	176	fwdata = generic_edid[i];
da0df92b CE	177	fwsize = sizeof(generic_edid[i]);
9066f83c CW	178	builtin = 1;
9066f83c CW	179	break;
da0df92b CE	180	}
da0df92b CE	181	}
9066f83c CW	182	if (!builtin) {
	183	struct platform_device *pdev;
	184	int err;
da0df92b	185
9066f83c CW	186	pdev = platform_device_register_simple(connector_name, -1, NULL, 0);
	187	if (IS_ERR(pdev)) {
	188	DRM_ERROR("Failed to register EDID firmware platform device "
	189	"for connector \"%s\"\n", connector_name);
	190	return ERR_CAST(pdev);
	191	}
	192
	193	err = request_firmware(&fw, name, &pdev->dev);
	194	platform_device_unregister(pdev);
	195	if (err) {
	196	DRM_ERROR("Requesting EDID firmware \"%s\" failed (err=%d)\n",
	197	name, err);
	198	return ERR_PTR(err);
	199	}
da0df92b	200
9066f83c	201	fwdata = fw->data;
da0df92b CE	202	fwsize = fw->size;
	203	}
	204
9066f83c	205	if (edid_size(fwdata, fwsize) != fwsize) {
da0df92b	206	DRM_ERROR("Size of EDID firmware \"%s\" is invalid "
9066f83c CW	207	"(expected %d, got %d\n", name,
	208	edid_size(fwdata, fwsize), (int)fwsize);
	209	edid = ERR_PTR(-EINVAL);
	210	goto out;
da0df92b CE	211	}
da0df92b CE	212
8d06cd0a	213	edid = kmemdup(fwdata, fwsize, GFP_KERNEL);
da0df92b	214	if (edid == NULL) {
9066f83c CW	215	edid = ERR_PTR(-ENOMEM);
9066f83c CW	216	goto out;
da0df92b	217	}
da0df92b	218
0b2443ed JG	219	if (!drm_edid_block_valid(edid, 0, print_bad_edid)) {
0b2443ed JG	220	connector->bad_edid_counter++;
da0df92b CE	221	DRM_ERROR("Base block of EDID firmware \"%s\" is invalid ",
	222	name);
	223	kfree(edid);
9066f83c CW	224	edid = ERR_PTR(-EINVAL);
9066f83c CW	225	goto out;
da0df92b CE	226	}
	227
	228	for (i = 1; i <= edid[0x7e]; i++) {
	229	if (i != valid_extensions + 1)
	230	memcpy(edid + (valid_extensions + 1) * EDID_LENGTH,
	231	edid + i * EDID_LENGTH, EDID_LENGTH);
0b2443ed	232	if (drm_edid_block_valid(edid + i * EDID_LENGTH, i, print_bad_edid))
da0df92b CE	233	valid_extensions++;
	234	}
	235
	236	if (valid_extensions != edid[0x7e]) {
9066f83c CW	237	u8 *new_edid;
9066f83c CW	238
da0df92b CE	239	edid[EDID_LENGTH-1] += edid[0x7e] - valid_extensions;
	240	DRM_INFO("Found %d valid extensions instead of %d in EDID data "
	241	"\"%s\" for connector \"%s\"\n", valid_extensions,
	242	edid[0x7e], name, connector_name);
	243	edid[0x7e] = valid_extensions;
9066f83c	244
f7b83b90	245	new_edid = krealloc(edid, (valid_extensions + 1) * EDID_LENGTH,
9066f83c CW	246	GFP_KERNEL);
	247	if (new_edid)
	248	edid = new_edid;
da0df92b CE	249	}
da0df92b CE	250
da0df92b CE	251	DRM_INFO("Got %s EDID base block and %d extension%s from "
	252	"\"%s\" for connector \"%s\"\n", builtin ? "built-in" :
	253	"external", valid_extensions, valid_extensions == 1 ? "" : "s",
	254	name, connector_name);
	255
da0df92b	256	out:
9066f83c CW	257	if (fw)
9066f83c CW	258	release_firmware(fw);
451023dc	259	return edid;
da0df92b CE	260	}
	261
	262	int drm_load_edid_firmware(struct drm_connector *connector)
	263	{
25933820	264	const char *connector_name = connector->name;
da0df92b	265	char edidname = edid_firmware, last, *colon;
4a1b0714	266	int ret;
451023dc	267	struct edid *edid;
da0df92b CE	268
da0df92b CE	269	if (*edidname == '\0')
4a1b0714	270	return 0;
da0df92b CE	271
	272	colon = strchr(edidname, ':');
	273	if (colon != NULL) {
	274	if (strncmp(connector_name, edidname, colon - edidname))
4a1b0714	275	return 0;
da0df92b CE	276	edidname = colon + 1;
da0df92b CE	277	if (*edidname == '\0')
4a1b0714	278	return 0;
da0df92b CE	279	}
	280
	281	last = edidname + strlen(edidname) - 1;
	282	if (*last == '\n')
	283	*last = '\0';
	284
ce456e03	285	edid = edid_load(connector, edidname, connector_name);
451023dc	286	if (IS_ERR_OR_NULL(edid))
da0df92b CE	287	return 0;
da0df92b CE	288
451023dc JN	289	drm_mode_connector_update_edid_property(connector, edid);
	290	ret = drm_add_edid_modes(connector, edid);
	291	kfree(edid);
da0df92b	292
451023dc	293	return ret;
da0df92b	294	}