intel_acpi.c

  1// SPDX-License-Identifier: GPL-2.0
  2/*
  3 * Intel ACPI functions
  4 *
  5 * _DSM related code stolen from nouveau_acpi.c.
  6 */
  7
  8#include <linux/pci.h>
  9#include <linux/acpi.h>
 10#include <acpi/video.h>
 11
 12#include <drm/drm_print.h>
 13
 14#include "intel_acpi.h"
 15#include "intel_display_core.h"
 16#include "intel_display_types.h"
 17#include "intel_display_utils.h"
 18
 19#define INTEL_DSM_REVISION_ID 1 /* For Calpella anyway... */
 20#define INTEL_DSM_FN_PLATFORM_MUX_INFO 1 /* No args */
 21
 22static const guid_t intel_dsm_guid =
 23	GUID_INIT(0x7ed873d3, 0xc2d0, 0x4e4f,
 24		  0xa8, 0x54, 0x0f, 0x13, 0x17, 0xb0, 0x1c, 0x2c);
 25
 26#define INTEL_DSM_FN_GET_BIOS_DATA_FUNCS_SUPPORTED 0 /* No args */
 27
 28static const guid_t intel_dsm_guid2 =
 29	GUID_INIT(0x3e5b41c6, 0xeb1d, 0x4260,
 30		  0x9d, 0x15, 0xc7, 0x1f, 0xba, 0xda, 0xe4, 0x14);
 31
 32static char *intel_dsm_port_name(u8 id)
 33{
 34	switch (id) {
 35	case 0:
 36		return "Reserved";
 37	case 1:
 38		return "Analog VGA";
 39	case 2:
 40		return "LVDS";
 41	case 3:
 42		return "Reserved";
 43	case 4:
 44		return "HDMI/DVI_B";
 45	case 5:
 46		return "HDMI/DVI_C";
 47	case 6:
 48		return "HDMI/DVI_D";
 49	case 7:
 50		return "DisplayPort_A";
 51	case 8:
 52		return "DisplayPort_B";
 53	case 9:
 54		return "DisplayPort_C";
 55	case 0xa:
 56		return "DisplayPort_D";
 57	case 0xb:
 58	case 0xc:
 59	case 0xd:
 60		return "Reserved";
 61	case 0xe:
 62		return "WiDi";
 63	default:
 64		return "bad type";
 65	}
 66}
 67
 68static char *intel_dsm_mux_type(u8 type)
 69{
 70	switch (type) {
 71	case 0:
 72		return "unknown";
 73	case 1:
 74		return "No MUX, iGPU only";
 75	case 2:
 76		return "No MUX, dGPU only";
 77	case 3:
 78		return "MUXed between iGPU and dGPU";
 79	default:
 80		return "bad type";
 81	}
 82}
 83
 84static void intel_dsm_platform_mux_info(acpi_handle dhandle)
 85{
 86	int i;
 87	union acpi_object *pkg, *connector_count;
 88
 89	pkg = acpi_evaluate_dsm_typed(dhandle, &intel_dsm_guid,
 90			INTEL_DSM_REVISION_ID, INTEL_DSM_FN_PLATFORM_MUX_INFO,
 91			NULL, ACPI_TYPE_PACKAGE);
 92	if (!pkg) {
 93		DRM_DEBUG_DRIVER("failed to evaluate _DSM\n");
 94		return;
 95	}
 96
 97	if (!pkg->package.count) {
 98		DRM_DEBUG_DRIVER("no connection in _DSM\n");
 99		ACPI_FREE(pkg);
100		return;
101	}
102
103	connector_count = &pkg->package.elements[0];
104	DRM_DEBUG_DRIVER("MUX info connectors: %lld\n",
105		  (unsigned long long)connector_count->integer.value);
106	for (i = 1; i < pkg->package.count; i++) {
107		union acpi_object *obj = &pkg->package.elements[i];
108		union acpi_object *connector_id;
109		union acpi_object *info;
110
111		if (obj->type != ACPI_TYPE_PACKAGE || obj->package.count < 2) {
112			DRM_DEBUG_DRIVER("Invalid object for MUX #%d\n", i);
113			continue;
114		}
115
116		connector_id = &obj->package.elements[0];
117		info = &obj->package.elements[1];
118		if (info->type != ACPI_TYPE_BUFFER || info->buffer.length < 4) {
119			DRM_DEBUG_DRIVER("Invalid info for MUX obj #%d\n", i);
120			continue;
121		}
122
123		DRM_DEBUG_DRIVER("Connector id: 0x%016llx\n",
124			  (unsigned long long)connector_id->integer.value);
125		DRM_DEBUG_DRIVER("  port id: %s\n",
126		       intel_dsm_port_name(info->buffer.pointer[0]));
127		DRM_DEBUG_DRIVER("  display mux info: %s\n",
128		       intel_dsm_mux_type(info->buffer.pointer[1]));
129		DRM_DEBUG_DRIVER("  aux/dc mux info: %s\n",
130		       intel_dsm_mux_type(info->buffer.pointer[2]));
131		DRM_DEBUG_DRIVER("  hpd mux info: %s\n",
132		       intel_dsm_mux_type(info->buffer.pointer[3]));
133	}
134
135	ACPI_FREE(pkg);
136}
137
138static acpi_handle intel_dsm_pci_probe(struct pci_dev *pdev)
139{
140	acpi_handle dhandle;
141
142	dhandle = ACPI_HANDLE(&pdev->dev);
143	if (!dhandle)
144		return NULL;
145
146	if (!acpi_check_dsm(dhandle, &intel_dsm_guid, INTEL_DSM_REVISION_ID,
147			    1 << INTEL_DSM_FN_PLATFORM_MUX_INFO)) {
148		DRM_DEBUG_KMS("no _DSM method for intel device\n");
149		return NULL;
150	}
151
152	intel_dsm_platform_mux_info(dhandle);
153
154	return dhandle;
155}
156
157static bool intel_dsm_detect(void)
158{
159	acpi_handle dhandle = NULL;
160	char acpi_method_name[255] = {};
161	struct acpi_buffer buffer = {sizeof(acpi_method_name), acpi_method_name};
162	struct pci_dev *pdev = NULL;
163	int vga_count = 0;
164
165	while ((pdev = pci_get_class(PCI_CLASS_DISPLAY_VGA << 8, pdev)) != NULL) {
166		vga_count++;
167		dhandle = intel_dsm_pci_probe(pdev) ?: dhandle;
168	}
169
170	if (vga_count == 2 && dhandle) {
171		acpi_get_name(dhandle, ACPI_FULL_PATHNAME, &buffer);
172		DRM_DEBUG_DRIVER("vga_switcheroo: detected DSM switching method %s handle\n",
173				 acpi_method_name);
174		return true;
175	}
176
177	return false;
178}
179
180void intel_register_dsm_handler(void)
181{
182	if (!intel_dsm_detect())
183		return;
184}
185
186void intel_unregister_dsm_handler(void)
187{
188}
189
190void intel_dsm_get_bios_data_funcs_supported(struct intel_display *display)
191{
192	struct pci_dev *pdev = to_pci_dev(display->drm->dev);
193	acpi_handle dhandle;
194	union acpi_object *obj;
195
196	dhandle = ACPI_HANDLE(&pdev->dev);
197	if (!dhandle)
198		return;
199
200	obj = acpi_evaluate_dsm(dhandle, &intel_dsm_guid2, INTEL_DSM_REVISION_ID,
201				INTEL_DSM_FN_GET_BIOS_DATA_FUNCS_SUPPORTED, NULL);
202	if (obj)
203		ACPI_FREE(obj);
204}
205
206/*
207 * ACPI Specification, Revision 5.0, Appendix B.3.2 _DOD (Enumerate All Devices
208 * Attached to the Display Adapter).
209 */
210#define ACPI_DISPLAY_INDEX_SHIFT		0
211#define ACPI_DISPLAY_INDEX_MASK			(0xf << 0)
212#define ACPI_DISPLAY_PORT_ATTACHMENT_SHIFT	4
213#define ACPI_DISPLAY_PORT_ATTACHMENT_MASK	(0xf << 4)
214#define ACPI_DISPLAY_TYPE_SHIFT			8
215#define ACPI_DISPLAY_TYPE_MASK			(0xf << 8)
216#define ACPI_DISPLAY_TYPE_OTHER			(0 << 8)
217#define ACPI_DISPLAY_TYPE_VGA			(1 << 8)
218#define ACPI_DISPLAY_TYPE_TV			(2 << 8)
219#define ACPI_DISPLAY_TYPE_EXTERNAL_DIGITAL	(3 << 8)
220#define ACPI_DISPLAY_TYPE_INTERNAL_DIGITAL	(4 << 8)
221#define ACPI_VENDOR_SPECIFIC_SHIFT		12
222#define ACPI_VENDOR_SPECIFIC_MASK		(0xf << 12)
223#define ACPI_BIOS_CAN_DETECT			(1 << 16)
224#define ACPI_DEPENDS_ON_VGA			(1 << 17)
225#define ACPI_PIPE_ID_SHIFT			18
226#define ACPI_PIPE_ID_MASK			(7 << 18)
227#define ACPI_DEVICE_ID_SCHEME			(1ULL << 31)
228
229static u32 acpi_display_type(struct intel_connector *connector)
230{
231	u32 display_type;
232
233	switch (connector->base.connector_type) {
234	case DRM_MODE_CONNECTOR_VGA:
235	case DRM_MODE_CONNECTOR_DVIA:
236		display_type = ACPI_DISPLAY_TYPE_VGA;
237		break;
238	case DRM_MODE_CONNECTOR_Composite:
239	case DRM_MODE_CONNECTOR_SVIDEO:
240	case DRM_MODE_CONNECTOR_Component:
241	case DRM_MODE_CONNECTOR_9PinDIN:
242	case DRM_MODE_CONNECTOR_TV:
243		display_type = ACPI_DISPLAY_TYPE_TV;
244		break;
245	case DRM_MODE_CONNECTOR_DVII:
246	case DRM_MODE_CONNECTOR_DVID:
247	case DRM_MODE_CONNECTOR_DisplayPort:
248	case DRM_MODE_CONNECTOR_HDMIA:
249	case DRM_MODE_CONNECTOR_HDMIB:
250		display_type = ACPI_DISPLAY_TYPE_EXTERNAL_DIGITAL;
251		break;
252	case DRM_MODE_CONNECTOR_LVDS:
253	case DRM_MODE_CONNECTOR_eDP:
254	case DRM_MODE_CONNECTOR_DSI:
255		display_type = ACPI_DISPLAY_TYPE_INTERNAL_DIGITAL;
256		break;
257	case DRM_MODE_CONNECTOR_Unknown:
258	case DRM_MODE_CONNECTOR_VIRTUAL:
259		display_type = ACPI_DISPLAY_TYPE_OTHER;
260		break;
261	default:
262		MISSING_CASE(connector->base.connector_type);
263		display_type = ACPI_DISPLAY_TYPE_OTHER;
264		break;
265	}
266
267	return display_type;
268}
269
270void intel_acpi_device_id_update(struct intel_display *display)
271{
272	struct intel_connector *connector;
273	struct drm_connector_list_iter conn_iter;
274	u8 display_index[16] = {};
275
276	/* Populate the ACPI IDs for all connectors for a given drm_device */
277	drm_connector_list_iter_begin(display->drm, &conn_iter);
278	for_each_intel_connector_iter(connector, &conn_iter) {
279		u32 device_id, type;
280
281		device_id = acpi_display_type(connector);
282
283		/* Use display type specific display index. */
284		type = (device_id & ACPI_DISPLAY_TYPE_MASK)
285			>> ACPI_DISPLAY_TYPE_SHIFT;
286		device_id |= display_index[type]++ << ACPI_DISPLAY_INDEX_SHIFT;
287
288		connector->acpi_device_id = device_id;
289	}
290	drm_connector_list_iter_end(&conn_iter);
291}
292
293/* NOTE: The connector order must be final before this is called. */
294void intel_acpi_assign_connector_fwnodes(struct intel_display *display)
295{
296	struct drm_device *drm_dev = display->drm;
297	struct drm_connector_list_iter conn_iter;
298	struct fwnode_handle *fwnode = NULL;
299	struct drm_connector *connector;
300	struct acpi_device *adev;
301
302	drm_connector_list_iter_begin(drm_dev, &conn_iter);
303	drm_for_each_connector_iter(connector, &conn_iter) {
304		/* Always getting the next, even when the last was not used. */
305		fwnode = device_get_next_child_node(drm_dev->dev, fwnode);
306		if (!fwnode)
307			break;
308
309		switch (connector->connector_type) {
310		case DRM_MODE_CONNECTOR_LVDS:
311		case DRM_MODE_CONNECTOR_eDP:
312		case DRM_MODE_CONNECTOR_DSI:
313			/*
314			 * Integrated displays have a specific address 0x1f on
315			 * most Intel platforms, but not on all of them.
316			 */
317			adev = acpi_find_child_device(ACPI_COMPANION(drm_dev->dev),
318						      0x1f, 0);
319			if (adev) {
320				connector->fwnode =
321					fwnode_handle_get(acpi_fwnode_handle(adev));
322				break;
323			}
324			fallthrough;
325		default:
326			connector->fwnode = fwnode_handle_get(fwnode);
327			break;
328		}
329	}
330	drm_connector_list_iter_end(&conn_iter);
331	/*
332	 * device_get_next_child_node() takes a reference on the fwnode, if
333	 * we stopped iterating because we are out of connectors we need to
334	 * put this, otherwise fwnode is NULL and the put is a no-op.
335	 */
336	fwnode_handle_put(fwnode);
337}
338
339void intel_acpi_video_register(struct intel_display *display)
340{
341	struct drm_connector_list_iter conn_iter;
342	struct drm_connector *connector;
343
344	acpi_video_register();
345
346	/*
347	 * If i915 is driving an internal panel without registering its native
348	 * backlight handler try to register the acpi_video backlight.
349	 * For panels not driven by i915 another GPU driver may still register
350	 * a native backlight later and acpi_video_register_backlight() should
351	 * only be called after any native backlights have been registered.
352	 */
353	drm_connector_list_iter_begin(display->drm, &conn_iter);
354	drm_for_each_connector_iter(connector, &conn_iter) {
355		struct intel_panel *panel = &to_intel_connector(connector)->panel;
356
357		if (panel->backlight.funcs && !panel->backlight.device) {
358			acpi_video_register_backlight();
359			break;
360		}
361	}
362	drm_connector_list_iter_end(&conn_iter);
363}