[mirror_ubuntu-artful-kernel.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 5
static const char *generic_edid_name[GENERIC_EDIDS] = {
	"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, 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 = drm_get_connector_name(connector);
	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
8091ee5c	34	#define GENERIC_EDIDS 5
9066f83c	35	static const char *generic_edid_name[GENERIC_EDIDS] = {
da0df92b CE	36	"edid/1024x768.bin",
da0df92b CE	37	"edid/1280x1024.bin",
8091ee5c	38	"edid/1600x1200.bin",
da0df92b CE	39	"edid/1680x1050.bin",
	40	"edid/1920x1080.bin",
	41	};
	42
9066f83c	43	static const u8 generic_edid[GENERIC_EDIDS][128] = {
da0df92b CE	44	{
	45	0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00,
	46	0x31, 0xd8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
	47	0x05, 0x16, 0x01, 0x03, 0x6d, 0x23, 0x1a, 0x78,
	48	0xea, 0x5e, 0xc0, 0xa4, 0x59, 0x4a, 0x98, 0x25,
	49	0x20, 0x50, 0x54, 0x00, 0x08, 0x00, 0x61, 0x40,
	50	0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
	51	0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x64, 0x19,
	52	0x00, 0x40, 0x41, 0x00, 0x26, 0x30, 0x08, 0x90,
	53	0x36, 0x00, 0x63, 0x0a, 0x11, 0x00, 0x00, 0x18,
	54	0x00, 0x00, 0x00, 0xff, 0x00, 0x4c, 0x69, 0x6e,
	55	0x75, 0x78, 0x20, 0x23, 0x30, 0x0a, 0x20, 0x20,
	56	0x20, 0x20, 0x00, 0x00, 0x00, 0xfd, 0x00, 0x3b,
	57	0x3d, 0x2f, 0x31, 0x07, 0x00, 0x0a, 0x20, 0x20,
	58	0x20, 0x20, 0x20, 0x20, 0x00, 0x00, 0x00, 0xfc,
	59	0x00, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x20, 0x58,
	60	0x47, 0x41, 0x0a, 0x20, 0x20, 0x20, 0x00, 0x55,
	61	},
	62	{
	63	0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00,
	64	0x31, 0xd8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
	65	0x05, 0x16, 0x01, 0x03, 0x6d, 0x2c, 0x23, 0x78,
	66	0xea, 0x5e, 0xc0, 0xa4, 0x59, 0x4a, 0x98, 0x25,
	67	0x20, 0x50, 0x54, 0x00, 0x00, 0x00, 0x81, 0x80,
	68	0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
	69	0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x30, 0x2a,
	70	0x00, 0x98, 0x51, 0x00, 0x2a, 0x40, 0x30, 0x70,
	71	0x13, 0x00, 0xbc, 0x63, 0x11, 0x00, 0x00, 0x1e,
	72	0x00, 0x00, 0x00, 0xff, 0x00, 0x4c, 0x69, 0x6e,
	73	0x75, 0x78, 0x20, 0x23, 0x30, 0x0a, 0x20, 0x20,
	74	0x20, 0x20, 0x00, 0x00, 0x00, 0xfd, 0x00, 0x3b,
	75	0x3d, 0x3e, 0x40, 0x0b, 0x00, 0x0a, 0x20, 0x20,
	76	0x20, 0x20, 0x20, 0x20, 0x00, 0x00, 0x00, 0xfc,
	77	0x00, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x20, 0x53,
	78	0x58, 0x47, 0x41, 0x0a, 0x20, 0x20, 0x00, 0xa0,
	79	},
	80	{
	81	0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00,
	82	0x31, 0xd8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
8091ee5c CE	83	0x05, 0x16, 0x01, 0x03, 0x6d, 0x37, 0x29, 0x78,
	84	0xea, 0x5e, 0xc0, 0xa4, 0x59, 0x4a, 0x98, 0x25,
	85	0x20, 0x50, 0x54, 0x00, 0x00, 0x00, 0xa9, 0x40,
	86	0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
	87	0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x48, 0x3f,
	88	0x40, 0x30, 0x62, 0xb0, 0x32, 0x40, 0x40, 0xc0,
	89	0x13, 0x00, 0x2b, 0xa0, 0x21, 0x00, 0x00, 0x1e,
	90	0x00, 0x00, 0x00, 0xff, 0x00, 0x4c, 0x69, 0x6e,
	91	0x75, 0x78, 0x20, 0x23, 0x30, 0x0a, 0x20, 0x20,
	92	0x20, 0x20, 0x00, 0x00, 0x00, 0xfd, 0x00, 0x3b,
	93	0x3d, 0x4a, 0x4c, 0x11, 0x00, 0x0a, 0x20, 0x20,
	94	0x20, 0x20, 0x20, 0x20, 0x00, 0x00, 0x00, 0xfc,
	95	0x00, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x20, 0x55,
	96	0x58, 0x47, 0x41, 0x0a, 0x20, 0x20, 0x00, 0x9d,
	97	},
	98	{
	99	0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00,
	100	0x31, 0xd8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
da0df92b CE	101	0x05, 0x16, 0x01, 0x03, 0x6d, 0x2b, 0x1b, 0x78,
	102	0xea, 0x5e, 0xc0, 0xa4, 0x59, 0x4a, 0x98, 0x25,
	103	0x20, 0x50, 0x54, 0x00, 0x00, 0x00, 0xb3, 0x00,
	104	0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
	105	0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x21, 0x39,
	106	0x90, 0x30, 0x62, 0x1a, 0x27, 0x40, 0x68, 0xb0,
	107	0x36, 0x00, 0xb5, 0x11, 0x11, 0x00, 0x00, 0x1e,
	108	0x00, 0x00, 0x00, 0xff, 0x00, 0x4c, 0x69, 0x6e,
	109	0x75, 0x78, 0x20, 0x23, 0x30, 0x0a, 0x20, 0x20,
	110	0x20, 0x20, 0x00, 0x00, 0x00, 0xfd, 0x00, 0x3b,
	111	0x3d, 0x40, 0x42, 0x0f, 0x00, 0x0a, 0x20, 0x20,
	112	0x20, 0x20, 0x20, 0x20, 0x00, 0x00, 0x00, 0xfc,
	113	0x00, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x20, 0x57,
	114	0x53, 0x58, 0x47, 0x41, 0x0a, 0x20, 0x00, 0x26,
	115	},
	116	{
	117	0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00,
	118	0x31, 0xd8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
	119	0x05, 0x16, 0x01, 0x03, 0x6d, 0x32, 0x1c, 0x78,
	120	0xea, 0x5e, 0xc0, 0xa4, 0x59, 0x4a, 0x98, 0x25,
	121	0x20, 0x50, 0x54, 0x00, 0x00, 0x00, 0xd1, 0xc0,
	122	0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
	123	0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x02, 0x3a,
	124	0x80, 0x18, 0x71, 0x38, 0x2d, 0x40, 0x58, 0x2c,
	125	0x45, 0x00, 0xf4, 0x19, 0x11, 0x00, 0x00, 0x1e,
	126	0x00, 0x00, 0x00, 0xff, 0x00, 0x4c, 0x69, 0x6e,
	127	0x75, 0x78, 0x20, 0x23, 0x30, 0x0a, 0x20, 0x20,
	128	0x20, 0x20, 0x00, 0x00, 0x00, 0xfd, 0x00, 0x3b,
	129	0x3d, 0x42, 0x44, 0x0f, 0x00, 0x0a, 0x20, 0x20,
	130	0x20, 0x20, 0x20, 0x20, 0x00, 0x00, 0x00, 0xfc,
	131	0x00, 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x20, 0x46,
	132	0x48, 0x44, 0x0a, 0x20, 0x20, 0x20, 0x00, 0x05,
	133	},
	134	};
	135
9066f83c CW	136	static int edid_size(const u8 *edid, int data_size)
	137	{
	138	if (data_size < EDID_LENGTH)
	139	return 0;
	140
	141	return (edid[0x7e] + 1) * EDID_LENGTH;
	142	}
	143
ce456e03	144	static void edid_load(struct drm_connector connector, const char *name,
496fd15b	145	const char *connector_name)
da0df92b	146	{
9066f83c CW	147	const struct firmware *fw = NULL;
	148	const u8 *fwdata;
	149	u8 *edid;
	150	int fwsize, builtin;
da0df92b	151	int i, valid_extensions = 0;
0b2443ed	152	bool print_bad_edid = !connector->bad_edid_counter \|\| (drm_debug & DRM_UT_KMS);
da0df92b	153
9066f83c CW	154	builtin = 0;
	155	for (i = 0; i < GENERIC_EDIDS; i++) {
	156	if (strcmp(name, generic_edid_name[i]) == 0) {
da0df92b CE	157	fwdata = generic_edid[i];
da0df92b CE	158	fwsize = sizeof(generic_edid[i]);
9066f83c CW	159	builtin = 1;
9066f83c CW	160	break;
da0df92b CE	161	}
da0df92b CE	162	}
9066f83c CW	163	if (!builtin) {
	164	struct platform_device *pdev;
	165	int err;
da0df92b	166
9066f83c CW	167	pdev = platform_device_register_simple(connector_name, -1, NULL, 0);
	168	if (IS_ERR(pdev)) {
	169	DRM_ERROR("Failed to register EDID firmware platform device "
	170	"for connector \"%s\"\n", connector_name);
	171	return ERR_CAST(pdev);
	172	}
	173
	174	err = request_firmware(&fw, name, &pdev->dev);
	175	platform_device_unregister(pdev);
	176	if (err) {
	177	DRM_ERROR("Requesting EDID firmware \"%s\" failed (err=%d)\n",
	178	name, err);
	179	return ERR_PTR(err);
	180	}
da0df92b	181
9066f83c	182	fwdata = fw->data;
da0df92b CE	183	fwsize = fw->size;
	184	}
	185
9066f83c	186	if (edid_size(fwdata, fwsize) != fwsize) {
da0df92b	187	DRM_ERROR("Size of EDID firmware \"%s\" is invalid "
9066f83c CW	188	"(expected %d, got %d\n", name,
	189	edid_size(fwdata, fwsize), (int)fwsize);
	190	edid = ERR_PTR(-EINVAL);
	191	goto out;
da0df92b CE	192	}
da0df92b CE	193
8d06cd0a	194	edid = kmemdup(fwdata, fwsize, GFP_KERNEL);
da0df92b	195	if (edid == NULL) {
9066f83c CW	196	edid = ERR_PTR(-ENOMEM);
9066f83c CW	197	goto out;
da0df92b	198	}
da0df92b	199
0b2443ed JG	200	if (!drm_edid_block_valid(edid, 0, print_bad_edid)) {
0b2443ed JG	201	connector->bad_edid_counter++;
da0df92b CE	202	DRM_ERROR("Base block of EDID firmware \"%s\" is invalid ",
	203	name);
	204	kfree(edid);
9066f83c CW	205	edid = ERR_PTR(-EINVAL);
9066f83c CW	206	goto out;
da0df92b CE	207	}
	208
	209	for (i = 1; i <= edid[0x7e]; i++) {
	210	if (i != valid_extensions + 1)
	211	memcpy(edid + (valid_extensions + 1) * EDID_LENGTH,
	212	edid + i * EDID_LENGTH, EDID_LENGTH);
0b2443ed	213	if (drm_edid_block_valid(edid + i * EDID_LENGTH, i, print_bad_edid))
da0df92b CE	214	valid_extensions++;
	215	}
	216
	217	if (valid_extensions != edid[0x7e]) {
9066f83c CW	218	u8 *new_edid;
9066f83c CW	219
da0df92b CE	220	edid[EDID_LENGTH-1] += edid[0x7e] - valid_extensions;
	221	DRM_INFO("Found %d valid extensions instead of %d in EDID data "
	222	"\"%s\" for connector \"%s\"\n", valid_extensions,
	223	edid[0x7e], name, connector_name);
	224	edid[0x7e] = valid_extensions;
9066f83c	225
f7b83b90	226	new_edid = krealloc(edid, (valid_extensions + 1) * EDID_LENGTH,
9066f83c CW	227	GFP_KERNEL);
	228	if (new_edid)
	229	edid = new_edid;
da0df92b CE	230	}
da0df92b CE	231
da0df92b CE	232	DRM_INFO("Got %s EDID base block and %d extension%s from "
	233	"\"%s\" for connector \"%s\"\n", builtin ? "built-in" :
	234	"external", valid_extensions, valid_extensions == 1 ? "" : "s",
	235	name, connector_name);
	236
da0df92b	237	out:
9066f83c CW	238	if (fw)
9066f83c CW	239	release_firmware(fw);
451023dc	240	return edid;
da0df92b CE	241	}
	242
	243	int drm_load_edid_firmware(struct drm_connector *connector)
	244	{
496fd15b	245	const char *connector_name = drm_get_connector_name(connector);
da0df92b	246	char edidname = edid_firmware, last, *colon;
4a1b0714	247	int ret;
451023dc	248	struct edid *edid;
da0df92b CE	249
da0df92b CE	250	if (*edidname == '\0')
4a1b0714	251	return 0;
da0df92b CE	252
	253	colon = strchr(edidname, ':');
	254	if (colon != NULL) {
	255	if (strncmp(connector_name, edidname, colon - edidname))
4a1b0714	256	return 0;
da0df92b CE	257	edidname = colon + 1;
da0df92b CE	258	if (*edidname == '\0')
4a1b0714	259	return 0;
da0df92b CE	260	}
	261
	262	last = edidname + strlen(edidname) - 1;
	263	if (*last == '\n')
	264	*last = '\0';
	265
ce456e03	266	edid = edid_load(connector, edidname, connector_name);
451023dc	267	if (IS_ERR_OR_NULL(edid))
da0df92b CE	268	return 0;
da0df92b CE	269
451023dc JN	270	drm_mode_connector_update_edid_property(connector, edid);
	271	ret = drm_add_edid_modes(connector, edid);
	272	kfree(edid);
da0df92b	273
451023dc	274	return ret;
da0df92b	275	}