[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 * const 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->edid_corrupt)) {
		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,
					 NULL))
			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:
	release_firmware(fw);
	return edid;
}

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

	if (edid_firmware[0] == '\0')
		return 0;

	/*
	 * If there are multiple edid files specified and separated
	 * by commas, search through the list looking for one that
	 * matches the connector.
	 *
	 * If there's one or more that don't't specify a connector, keep
	 * the last one found one as a fallback.
	 */
	fwstr = kstrdup(edid_firmware, GFP_KERNEL);
	edidstr = fwstr;

	while ((edidname = strsep(&edidstr, ","))) {
		colon = strchr(edidname, ':');
		if (colon != NULL) {
			if (strncmp(connector_name, edidname, colon - edidname))
				continue;
			edidname = colon + 1;
			break;
		}

		if (*edidname != '\0') /* corner case: multiple ',' */
			fallback = edidname;
	}

	if (!edidname) {
		if (!fallback) {
			kfree(fwstr);
			return 0;
		}
		edidname = fallback;
	}

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

	edid = edid_load(connector, edidname, connector_name);
	kfree(fwstr);

	if (IS_ERR_OR_NULL(edid))
		return 0;

	drm_mode_connector_update_edid_property(connector, edid);
	ret = drm_add_edid_modes(connector, edid);
	drm_edid_to_eld(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
a5b62374	35	static const char * const 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
6ba2bd3d TP	219	if (!drm_edid_block_valid(edid, 0, print_bad_edid,
6ba2bd3d TP	220	&connector->edid_corrupt)) {
0b2443ed	221	connector->bad_edid_counter++;
da0df92b CE	222	DRM_ERROR("Base block of EDID firmware \"%s\" is invalid ",
	223	name);
	224	kfree(edid);
9066f83c CW	225	edid = ERR_PTR(-EINVAL);
9066f83c CW	226	goto out;
da0df92b CE	227	}
	228
	229	for (i = 1; i <= edid[0x7e]; i++) {
	230	if (i != valid_extensions + 1)
	231	memcpy(edid + (valid_extensions + 1) * EDID_LENGTH,
	232	edid + i * EDID_LENGTH, EDID_LENGTH);
6ba2bd3d TP	233	if (drm_edid_block_valid(edid + i * EDID_LENGTH, i,
	234	print_bad_edid,
	235	NULL))
da0df92b CE	236	valid_extensions++;
	237	}
	238
	239	if (valid_extensions != edid[0x7e]) {
9066f83c CW	240	u8 *new_edid;
9066f83c CW	241
da0df92b CE	242	edid[EDID_LENGTH-1] += edid[0x7e] - valid_extensions;
	243	DRM_INFO("Found %d valid extensions instead of %d in EDID data "
	244	"\"%s\" for connector \"%s\"\n", valid_extensions,
	245	edid[0x7e], name, connector_name);
	246	edid[0x7e] = valid_extensions;
9066f83c	247
f7b83b90	248	new_edid = krealloc(edid, (valid_extensions + 1) * EDID_LENGTH,
9066f83c CW	249	GFP_KERNEL);
	250	if (new_edid)
	251	edid = new_edid;
da0df92b CE	252	}
da0df92b CE	253
da0df92b CE	254	DRM_INFO("Got %s EDID base block and %d extension%s from "
	255	"\"%s\" for connector \"%s\"\n", builtin ? "built-in" :
	256	"external", valid_extensions, valid_extensions == 1 ? "" : "s",
	257	name, connector_name);
	258
da0df92b	259	out:
9084acf1	260	release_firmware(fw);
451023dc	261	return edid;
da0df92b CE	262	}
	263
	264	int drm_load_edid_firmware(struct drm_connector *connector)
	265	{
25933820	266	const char *connector_name = connector->name;
96206e29	267	char edidname, last, colon, fwstr, edidstr, fallback = NULL;
4a1b0714	268	int ret;
451023dc	269	struct edid *edid;
da0df92b	270
96206e29	271	if (edid_firmware[0] == '\0')
4a1b0714	272	return 0;
da0df92b	273
96206e29 BP	274	/*
	275	* If there are multiple edid files specified and separated
	276	* by commas, search through the list looking for one that
	277	* matches the connector.
	278	*
	279	* If there's one or more that don't't specify a connector, keep
	280	* the last one found one as a fallback.
	281	*/
	282	fwstr = kstrdup(edid_firmware, GFP_KERNEL);
	283	edidstr = fwstr;
	284
	285	while ((edidname = strsep(&edidstr, ","))) {
	286	colon = strchr(edidname, ':');
	287	if (colon != NULL) {
	288	if (strncmp(connector_name, edidname, colon - edidname))
	289	continue;
	290	edidname = colon + 1;
	291	break;
	292	}
	293
	294	if (edidname != '\0') / corner case: multiple ',' */
	295	fallback = edidname;
	296	}
	297
	298	if (!edidname) {
	299	if (!fallback) {
	300	kfree(fwstr);
4a1b0714	301	return 0;
96206e29 BP	302	}
96206e29 BP	303	edidname = fallback;
da0df92b CE	304	}
	305
	306	last = edidname + strlen(edidname) - 1;
	307	if (*last == '\n')
	308	*last = '\0';
	309
ce456e03	310	edid = edid_load(connector, edidname, connector_name);
96206e29 BP	311	kfree(fwstr);
96206e29 BP	312
451023dc	313	if (IS_ERR_OR_NULL(edid))
da0df92b CE	314	return 0;
da0df92b CE	315
451023dc JN	316	drm_mode_connector_update_edid_property(connector, edid);
451023dc JN	317	ret = drm_add_edid_modes(connector, edid);
ad692b46	318	drm_edid_to_eld(connector, edid);
451023dc	319	kfree(edid);
da0df92b	320
451023dc	321	return ret;
da0df92b	322	}