[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 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 = match_string(generic_edid_name, GENERIC_EDIDS, name);
	if (builtin >= 0) {
		fwdata = generic_edid[builtin];
		fwsize = sizeof(generic_edid[builtin]);
	} else {
		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 >= 0) ? "built-in" :
	    "external", valid_extensions, valid_extensions == 1 ? "" : "s",
	    name, connector_name);

out:
	release_firmware(fw);
	return edid;
}

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

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

	/*
	 * 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 doesn'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 ERR_PTR(-ENOENT);
		}
		edidname = fallback;
	}

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

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

	return edid;
}
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
7a5cf52d AS	173	builtin = match_string(generic_edid_name, GENERIC_EDIDS, name);
	174	if (builtin >= 0) {
	175	fwdata = generic_edid[builtin];
	176	fwsize = sizeof(generic_edid[builtin]);
	177	} else {
9066f83c CW	178	struct platform_device *pdev;
9066f83c CW	179	int err;
da0df92b	180
9066f83c CW	181	pdev = platform_device_register_simple(connector_name, -1, NULL, 0);
	182	if (IS_ERR(pdev)) {
	183	DRM_ERROR("Failed to register EDID firmware platform device "
	184	"for connector \"%s\"\n", connector_name);
	185	return ERR_CAST(pdev);
	186	}
	187
	188	err = request_firmware(&fw, name, &pdev->dev);
	189	platform_device_unregister(pdev);
	190	if (err) {
	191	DRM_ERROR("Requesting EDID firmware \"%s\" failed (err=%d)\n",
	192	name, err);
	193	return ERR_PTR(err);
	194	}
da0df92b	195
9066f83c	196	fwdata = fw->data;
da0df92b CE	197	fwsize = fw->size;
	198	}
	199
9066f83c	200	if (edid_size(fwdata, fwsize) != fwsize) {
da0df92b	201	DRM_ERROR("Size of EDID firmware \"%s\" is invalid "
9066f83c CW	202	"(expected %d, got %d\n", name,
	203	edid_size(fwdata, fwsize), (int)fwsize);
	204	edid = ERR_PTR(-EINVAL);
	205	goto out;
da0df92b CE	206	}
da0df92b CE	207
8d06cd0a	208	edid = kmemdup(fwdata, fwsize, GFP_KERNEL);
da0df92b	209	if (edid == NULL) {
9066f83c CW	210	edid = ERR_PTR(-ENOMEM);
9066f83c CW	211	goto out;
da0df92b	212	}
da0df92b	213
6ba2bd3d TP	214	if (!drm_edid_block_valid(edid, 0, print_bad_edid,
6ba2bd3d TP	215	&connector->edid_corrupt)) {
0b2443ed	216	connector->bad_edid_counter++;
da0df92b CE	217	DRM_ERROR("Base block of EDID firmware \"%s\" is invalid ",
	218	name);
	219	kfree(edid);
9066f83c CW	220	edid = ERR_PTR(-EINVAL);
9066f83c CW	221	goto out;
da0df92b CE	222	}
	223
	224	for (i = 1; i <= edid[0x7e]; i++) {
	225	if (i != valid_extensions + 1)
	226	memcpy(edid + (valid_extensions + 1) * EDID_LENGTH,
	227	edid + i * EDID_LENGTH, EDID_LENGTH);
6ba2bd3d TP	228	if (drm_edid_block_valid(edid + i * EDID_LENGTH, i,
	229	print_bad_edid,
	230	NULL))
da0df92b CE	231	valid_extensions++;
	232	}
	233
	234	if (valid_extensions != edid[0x7e]) {
9066f83c CW	235	u8 *new_edid;
9066f83c CW	236
da0df92b CE	237	edid[EDID_LENGTH-1] += edid[0x7e] - valid_extensions;
	238	DRM_INFO("Found %d valid extensions instead of %d in EDID data "
	239	"\"%s\" for connector \"%s\"\n", valid_extensions,
	240	edid[0x7e], name, connector_name);
	241	edid[0x7e] = valid_extensions;
9066f83c	242
f7b83b90	243	new_edid = krealloc(edid, (valid_extensions + 1) * EDID_LENGTH,
9066f83c CW	244	GFP_KERNEL);
	245	if (new_edid)
	246	edid = new_edid;
da0df92b CE	247	}
da0df92b CE	248
da0df92b	249	DRM_INFO("Got %s EDID base block and %d extension%s from "
7a5cf52d	250	"\"%s\" for connector \"%s\"\n", (builtin >= 0) ? "built-in" :
da0df92b CE	251	"external", valid_extensions, valid_extensions == 1 ? "" : "s",
	252	name, connector_name);
	253
da0df92b	254	out:
9084acf1	255	release_firmware(fw);
451023dc	256	return edid;
da0df92b CE	257	}
da0df92b CE	258
07c2b84b	259	struct edid drm_load_edid_firmware(struct drm_connector connector)
da0df92b	260	{
25933820	261	const char *connector_name = connector->name;
96206e29	262	char edidname, last, colon, fwstr, edidstr, fallback = NULL;
451023dc	263	struct edid *edid;
da0df92b	264
96206e29	265	if (edid_firmware[0] == '\0')
07c2b84b	266	return ERR_PTR(-ENOENT);
da0df92b	267
96206e29 BP	268	/*
	269	* If there are multiple edid files specified and separated
	270	* by commas, search through the list looking for one that
	271	* matches the connector.
	272	*
c67f6957	273	* If there's one or more that doesn't specify a connector, keep
96206e29 BP	274	* the last one found one as a fallback.
	275	*/
	276	fwstr = kstrdup(edid_firmware, GFP_KERNEL);
	277	edidstr = fwstr;
	278
	279	while ((edidname = strsep(&edidstr, ","))) {
	280	colon = strchr(edidname, ':');
	281	if (colon != NULL) {
	282	if (strncmp(connector_name, edidname, colon - edidname))
	283	continue;
	284	edidname = colon + 1;
	285	break;
	286	}
	287
	288	if (edidname != '\0') / corner case: multiple ',' */
	289	fallback = edidname;
	290	}
	291
	292	if (!edidname) {
	293	if (!fallback) {
	294	kfree(fwstr);
07c2b84b	295	return ERR_PTR(-ENOENT);
96206e29 BP	296	}
96206e29 BP	297	edidname = fallback;
da0df92b CE	298	}
	299
	300	last = edidname + strlen(edidname) - 1;
	301	if (*last == '\n')
	302	*last = '\0';
	303
ce456e03	304	edid = edid_load(connector, edidname, connector_name);
96206e29 BP	305	kfree(fwstr);
96206e29 BP	306
07c2b84b	307	return edid;
da0df92b	308	}