WebSVN – Kolibri OS – Diff – /drivers/video/drm/i915/intel_opregion.c

 #define OPREGION_SIGNATURE "IntelGraphicsMem"
 #define MBOX_ACPI      (1<<0)
 #define MBOX_SWSCI     (1<<1)
+#define MBOX_ASLE      (1<<2)
-#define MBOX_ASLE      (1<<2)
+#define MBOX_ASLE_EXT  (1<<4)
 struct opregion_header {
-       u8 signature[16];
+	u8 signature[16];
-       u32 size;
+	u32 size;
-       u32 opregion_ver;
+	u32 opregion_ver;
-       u8 bios_ver[32];
+	u8 bios_ver[32];
-       u8 vbios_ver[16];
+	u8 vbios_ver[16];
+	u8 driver_ver[16];
+	u32 mboxes;
+	u32 driver_model;
-       u8 driver_ver[16];
+	u32 pcon;
-       u32 mboxes;
+	u8 dver[32];
-       u8 reserved[164];
+	u8 rsvd[124];
 } __packed;
-       u32 cdck;       /* current docking state */
+	u32 cdck;       /* current docking state */
-       u32 sxsw;       /* Sx state resume */
+	u32 sxsw;       /* Sx state resume */
-       u32 evts;       /* ASL supported events */
+	u32 evts;       /* ASL supported events */
-       u32 cnot;       /* current OS notification */
+	u32 cnot;       /* current OS notification */
-       u32 nrdy;       /* driver status */
+	u32 nrdy;       /* driver status */
+	u32 did2[7];	/* extended supported display devices ID list */
+	u32 cpd2[7];	/* extended attached display devices list */
-       u8 rsvd2[60];
+	u8 rsvd2[4];
 } __packed;
 /* OpRegion mailbox #2: SWSCI */
 struct opregion_swsci {
-       u32 pfmb;       /* PWM freq and min brightness */
+	u32 pfmb;       /* PWM freq and min brightness */
 	u32 cddv;       /* color correction default values */
 	u32 pcft;       /* power conservation features */
 	u32 srot;       /* supported rotation angles */
 	u32 iuer;       /* IUER events */
+	u64 fdss;
+	u32 fdsp;
+	u32 stat;
-	u8 rsvd[86];
+	u8 rsvd[70];
 } __packed;
 /* Driver readiness indicator */
 #define ASLE_ARDY_READY		(1 << 0)
 #ifdef CONFIG_ACPI
 static int swsci(struct drm_device *dev, u32 function, u32 parm, u32 *parm_out)
+{
 	struct drm_i915_private *dev_priv = dev->dev_private;
-	struct opregion_swsci __iomem *swsci = dev_priv->opregion.swsci;
+	struct opregion_swsci *swsci = dev_priv->opregion.swsci;
 	u32 main_function, sub_function, scic;
 	u16 pci_swsci;
 	u32 dslp;
 		     (1 << sub_function)) == 0)
 			return -EINVAL;
+	}
 	/* Driver sleep timeout in ms. */
-	dslp = ioread32(&swsci->dslp);
+	dslp = swsci->dslp;
 	if (!dslp) {
 		/* The spec says 2ms should be the default, but it's too small
 		 * for some machines. */
 		dslp = 50;
 			      "using %u ms instead\n", dslp, MAX_DSLP);
 		dslp = MAX_DSLP;
+	}
 	/* The spec tells us to do this, but we are the only user... */
-	scic = ioread32(&swsci->scic);
+	scic = swsci->scic;
 	if (scic & SWSCI_SCIC_INDICATOR) {
 		DRM_DEBUG_DRIVER("SWSCI request already in progress\n");
 		return -EBUSY;
+	}
 	scic = function | SWSCI_SCIC_INDICATOR;
-	iowrite32(parm, &swsci->parm);
+	swsci->parm = parm;
-	iowrite32(scic, &swsci->scic);
+	swsci->scic = scic;
 	/* Use event trigger to tell bios to check the mail. */
 	pci_swsci |= PCI_SWSCI_GSSCIE;
 	pci_write_config_word(dev->pdev, PCI_SWSCI, pci_swsci);
 	/* Poll for the result. */
-#define C (((scic = ioread32(&swsci->scic)) & SWSCI_SCIC_INDICATOR) == 0)
+#define C (((scic = swsci->scic) & SWSCI_SCIC_INDICATOR) == 0)
 	if (wait_for(C, dslp)) {
 		DRM_DEBUG_DRIVER("SWSCI request timed out\n");
 		return -ETIMEDOUT;
 		DRM_DEBUG_DRIVER("SWSCI request error %u\n", scic);
 		return -EIO;
+	}
 	if (parm_out)
-		*parm_out = ioread32(&swsci->parm);
+		*parm_out = swsci->parm;
 	return 0;
 	/* don't care about old stuff for now */
 	if (!HAS_DDI(dev))
+		return 0;
+	if (intel_encoder->type == INTEL_OUTPUT_DSI)
-		return 0;
+		port = 0;
+	else
 		port = intel_ddi_get_encoder_port(intel_encoder);
 	port = intel_ddi_get_encoder_port(intel_encoder);
-	if (port == PORT_E) {
+	if (port == PORT_E)  {
 		port = 0;
 	} else {
 	case INTEL_OUTPUT_HDMI:
 	case INTEL_OUTPUT_DP_MST:
 		type = DISPLAY_TYPE_EXTERNAL_FLAT_PANEL;
 		break;
 	case INTEL_OUTPUT_EDP:
+	case INTEL_OUTPUT_DSI:
 		type = DISPLAY_TYPE_INTERNAL_FLAT_PANEL;
 		break;
 	default:
 		WARN_ONCE(1, "unsupported intel_encoder type %d\n",
 			  intel_encoder->type);
+	}
 	return -EINVAL;
-}
-/*
- * If the vendor backlight interface is not in use and ACPI backlight interface
- * is broken, do not bother processing backlight change requests from firmware.
- */
-static bool should_ignore_backlight_request(void)
-{
-	return acpi_video_backlight_support() &&
-	       !acpi_video_verify_backlight_support();
+}
 static u32 asle_set_backlight(struct drm_device *dev, u32 bclp)
+{
 	struct drm_i915_private *dev_priv = dev->dev_private;
 	struct intel_connector *intel_connector;
-	struct opregion_asle __iomem *asle = dev_priv->opregion.asle;
+	struct opregion_asle *asle = dev_priv->opregion.asle;
 	DRM_DEBUG_DRIVER("bclp = 0x%08x\n", bclp);
-	if (should_ignore_backlight_request()) {
+	if (acpi_video_get_backlight_type() == acpi_backlight_native) {
 	 * only one).
 	 */
 	DRM_DEBUG_KMS("updating opregion backlight %d/255\n", bclp);
 	list_for_each_entry(intel_connector, &dev->mode_config.connector_list, base.head)
 		intel_panel_set_backlight_acpi(intel_connector, bclp, 255);
-	iowrite32(DIV_ROUND_UP(bclp * 100, 255) | ASLE_CBLV_VALID, &asle->cblv);
+	asle->cblv = DIV_ROUND_UP(bclp * 100, 255) | ASLE_CBLV_VALID;
 	drm_modeset_unlock(&dev->mode_config.connection_mutex);
 	struct intel_opregion *opregion =
 		container_of(work, struct intel_opregion, asle_work);
 	struct drm_i915_private *dev_priv =
 		container_of(opregion, struct drm_i915_private, opregion);
 	struct drm_device *dev = dev_priv->dev;
-	struct opregion_asle __iomem *asle = dev_priv->opregion.asle;
+	struct opregion_asle *asle = dev_priv->opregion.asle;
 	u32 aslc_stat = 0;
 	u32 aslc_req;
 	if (!asle)
 		return;
-	aslc_req = ioread32(&asle->aslc);
+	aslc_req = asle->aslc;
 	if (!(aslc_req & ASLC_REQ_MSK)) {
 		DRM_DEBUG_DRIVER("No request on ASLC interrupt 0x%08x\n",
 				 aslc_req);
 		return;
+	}
 	if (aslc_req & ASLC_SET_ALS_ILLUM)
-		aslc_stat |= asle_set_als_illum(dev, ioread32(&asle->alsi));
+		aslc_stat |= asle_set_als_illum(dev, asle->alsi);
 	if (aslc_req & ASLC_SET_BACKLIGHT)
-		aslc_stat |= asle_set_backlight(dev, ioread32(&asle->bclp));
+		aslc_stat |= asle_set_backlight(dev, asle->bclp);
 	if (aslc_req & ASLC_SET_PFIT)
-		aslc_stat |= asle_set_pfit(dev, ioread32(&asle->pfit));
+		aslc_stat |= asle_set_pfit(dev, asle->pfit);
 	if (aslc_req & ASLC_SET_PWM_FREQ)
-		aslc_stat |= asle_set_pwm_freq(dev, ioread32(&asle->pfmb));
+		aslc_stat |= asle_set_pwm_freq(dev, asle->pfmb);
 	if (aslc_req & ASLC_SUPPORTED_ROTATION_ANGLES)
 		aslc_stat |= asle_set_supported_rotation_angles(dev,
-							ioread32(&asle->srot));
+							asle->srot);
 	if (aslc_req & ASLC_BUTTON_ARRAY)
-		aslc_stat |= asle_set_button_array(dev, ioread32(&asle->iuer));
+		aslc_stat |= asle_set_button_array(dev, asle->iuer);
 	if (aslc_req & ASLC_CONVERTIBLE_INDICATOR)
 	/* The only video events relevant to opregion are 0x80. These indicate
 	   either a docking event, lid switch or display switch request. In
 	   Linux, these are handled by the dock, button and video drivers.
 	*/
 	struct opregion_acpi __iomem *acpi;
+	struct acpi_bus_event *event = data;
-	struct acpi_bus_event *event = data;
+	struct opregion_acpi *acpi;
 	int ret = NOTIFY_OK;
 	if (strcmp(event->device_class, ACPI_VIDEO_CLASS) != 0)
 		return NOTIFY_DONE;
-	if (!system_opregion)
-		return NOTIFY_DONE;
+	if (!system_opregion)
 		return NOTIFY_DONE;
-	acpi = system_opregion->acpi;
 	acpi = system_opregion->acpi;
 	if (event->type == 0x80 &&
-	    (ioread32(&acpi->cevt) & 1) == 0)
+	if (event->type == 0x80 && ((acpi->cevt & 1) == 0))
  * Initialise the DIDL field in opregion. This passes a list of devices to
  * the firmware. Values are defined by section B.4.2 of the ACPI specification
  * (version 3)
  */
+static u32 get_did(struct intel_opregion *opregion, int i)
+{
+	u32 did;
+	if (i < ARRAY_SIZE(opregion->acpi->didl)) {
+		did = opregion->acpi->didl[i];
+	} else {
+		i -= ARRAY_SIZE(opregion->acpi->didl);
+		if (WARN_ON(i >= ARRAY_SIZE(opregion->acpi->did2)))
+			return 0;
+		did = opregion->acpi->did2[i];
+	}
+	return did;
+}
+static void set_did(struct intel_opregion *opregion, int i, u32 val)
+{
+	if (i < ARRAY_SIZE(opregion->acpi->didl)) {
+		opregion->acpi->didl[i] = val;
+	} else {
+		i -= ARRAY_SIZE(opregion->acpi->didl);
+		if (WARN_ON(i >= ARRAY_SIZE(opregion->acpi->did2)))
+			return;
+		opregion->acpi->did2[i] = val;
+	}
+}
 static void intel_didl_outputs(struct drm_device *dev)
+{
 	struct drm_i915_private *dev_priv = dev->dev_private;
 	struct intel_opregion *opregion = &dev_priv->opregion;
 	struct drm_connector *connector;
 	acpi_handle handle;
 	struct acpi_device *acpi_dev, *acpi_cdev, *acpi_video_bus = NULL;
 	unsigned long long device_id;
 	acpi_status status;
-	u32 temp;
+	u32 temp, max_outputs;
 	int i = 0;
 	handle = ACPI_HANDLE(&dev->pdev->dev);
+			}
+		}
+	}
 	if (!acpi_video_bus) {
-		pr_warn("No ACPI video bus found\n");
+		DRM_ERROR("No ACPI video bus found\n");
 		return;
+	}
+	/*
+	 * In theory, did2, the extended didl, gets added at opregion version
+	 * 3.0. In practice, however, we're supposed to set it for earlier
+	 * versions as well, since a BIOS that doesn't understand did2 should
+	 * not look at it anyway. Use a variable so we can tweak this if a need
+	 * arises later.
+	 */
+	max_outputs = ARRAY_SIZE(opregion->acpi->didl) +
 		ARRAY_SIZE(opregion->acpi->did2);
 	list_for_each_entry(acpi_cdev, &acpi_video_bus->children, node) {
-		if (i >= 8) {
+		if (i >= max_outputs) {
-			dev_dbg(&dev->pdev->dev,
+			DRM_DEBUG_KMS("More than %u outputs detected via ACPI\n",
-				"More than 8 outputs detected via ACPI\n");
+				      max_outputs);
-			return;
-		}
+			return;
 		status =
-			acpi_evaluate_integer(acpi_cdev->handle, "_ADR",
+		status = acpi_evaluate_integer(acpi_cdev->handle, "_ADR",
-						NULL, &device_id);
+					       NULL, &device_id);
 		if (ACPI_SUCCESS(status)) {
 			if (!device_id)
-				goto blind_set;
-			iowrite32((u32)(device_id & 0x0f0f),
-				  &opregion->acpi->didl[i]);
+				goto blind_set;
-			i++;
+			set_did(opregion, i++, (u32)(device_id & 0x0f0f));
+		}
+	}
-	}
+end:
+	DRM_DEBUG_KMS("%d outputs detected\n", i);
-end:
-	/* If fewer than 8 outputs, the list must be null terminated */
+	/* If fewer than max outputs, the list must be null terminated */
-	if (i < 8)
+	if (i < max_outputs)
-		iowrite32(0, &opregion->acpi->didl[i]);
+		set_did(opregion, i, 0);
 	return;
 blind_set:
-	i = 0;
-	list_for_each_entry(connector, &dev->mode_config.connector_list, head) {
+	i = 0;
+	list_for_each_entry(connector, &dev->mode_config.connector_list, head) {
 		int output_type = ACPI_OTHER_OUTPUT;
-		if (i >= 8) {
+		if (i >= max_outputs) {
-			dev_dbg(&dev->pdev->dev,
+			DRM_DEBUG_KMS("More than %u outputs in connector list\n",
-				"More than 8 outputs in connector list\n");
+				      max_outputs);
 			return;
 			break;
 		case DRM_MODE_CONNECTOR_LVDS:
 			output_type = ACPI_LVDS_OUTPUT;
 			break;
+		}
-		temp = ioread32(&opregion->acpi->didl[i]);
+		temp = get_did(opregion, i);
-		iowrite32(temp | (1<<31) | output_type | i,
+		set_did(opregion, i, temp | (1 << 31) | output_type | i);
-			  &opregion->acpi->didl[i]);
 		i++;
+	}
 	goto end;
+}
 	 * but not active. This initialization is necessary for some Clevo
 	 * laptops that check this field before processing the brightness and
 	 * display switching hotkeys. Just like DIDL, CADL is NULL-terminated if
 	 * there are less than eight devices. */
 	do {
-		disp_id = ioread32(&opregion->acpi->didl[i]);
+		disp_id = get_did(opregion, i);
-		iowrite32(disp_id, &opregion->acpi->cadl[i]);
+		opregion->acpi->cadl[i] = disp_id;
 	} while (++i < 8 && disp_id != 0);
+}
 void intel_opregion_init(struct drm_device *dev)
 	if (!opregion->header)
 		return;
 	if (opregion->acpi) {
-		if (drm_core_check_feature(dev, DRIVER_MODESET)) {
+	if (opregion->acpi) {
-			intel_didl_outputs(dev);
-			intel_setup_cadls(dev);
+		intel_didl_outputs(dev);
 		intel_setup_cadls(dev);
 		/* Notify BIOS we are ready to handle ACPI video ext notifs.
 		 * Right now, all the events are handled by the ACPI video module.
 		 * We don't actually need to do anything with them. */
-		iowrite32(0, &opregion->acpi->csts);
+		opregion->acpi->csts = 0;
-		iowrite32(1, &opregion->acpi->drdy);
+		opregion->acpi->drdy = 1;
 		system_opregion = opregion;
 		register_acpi_notifier(&intel_opregion_notifier);
+	}
 	if (opregion->asle) {
-		iowrite32(ASLE_TCHE_BLC_EN, &opregion->asle->tche);
+		opregion->asle->tche = ASLE_TCHE_BLC_EN;
 	if (!opregion->header)
 		return;
 	if (opregion->asle)
-		iowrite32(ASLE_ARDY_NOT_READY, &opregion->asle->ardy);
+		opregion->asle->ardy = ASLE_ARDY_NOT_READY;
 	cancel_work_sync(&dev_priv->opregion.asle_work);
 	if (opregion->acpi) {
-		iowrite32(0, &opregion->acpi->drdy);
+		opregion->acpi->drdy = 0;
 		system_opregion = NULL;
 		unregister_acpi_notifier(&intel_opregion_notifier);
+	}
 	/* just clear all opregion memory pointers now */
 int intel_opregion_setup(struct drm_device *dev)
+{
 	struct drm_i915_private *dev_priv = dev->dev_private;
-	struct intel_opregion *opregion = &dev_priv->opregion;
-	void __iomem *base;
+	struct intel_opregion *opregion = &dev_priv->opregion;
 	u32 asls, mboxes;
 	char buf[sizeof(OPREGION_SIGNATURE)];
+	int err = 0;
+	void *base;
+	BUILD_BUG_ON(sizeof(struct opregion_header) != 0x100);
+	BUILD_BUG_ON(sizeof(struct opregion_acpi) != 0x100);
+	BUILD_BUG_ON(sizeof(struct opregion_swsci) != 0x100);
-	int err = 0;
+	BUILD_BUG_ON(sizeof(struct opregion_asle) != 0x100);
 	pci_read_config_dword(dev->pdev, PCI_ASLS, &asls);
 	DRM_DEBUG_DRIVER("graphic opregion physical addr: 0x%x\n", asls);
 #ifdef CONFIG_ACPI
 	INIT_WORK(&opregion->asle_work, asle_work);
 #endif
-	base = acpi_os_ioremap(asls, OPREGION_SIZE);
+	base = memremap(asls, OPREGION_SIZE, MEMREMAP_WB);
 	if (!base)
 		return -ENOMEM;
-	memcpy_fromio(buf, base, sizeof(buf));
+	memcpy(buf, base, sizeof(buf));
 	opregion->header = base;
 	opregion->vbt = base + OPREGION_VBT_OFFSET;
 	opregion->lid_state = base + ACPI_CLID;
-	mboxes = ioread32(&opregion->header->mboxes);
+	mboxes = opregion->header->mboxes;
 	if (mboxes & MBOX_ACPI) {
 		DRM_DEBUG_DRIVER("Public ACPI methods supported\n");
+	}
 	if (mboxes & MBOX_ASLE) {
 		DRM_DEBUG_DRIVER("ASLE supported\n");
 		opregion->asle = base + OPREGION_ASLE_OFFSET;
-		iowrite32(ASLE_ARDY_NOT_READY, &opregion->asle->ardy);
+		opregion->asle->ardy = ASLE_ARDY_NOT_READY;
+	}
 	return 0;
 err_out:

Subversion Repositories Kolibri OS

(root)/drivers/video/drm/i915/intel_opregion.c @ 6103 – Rev 5354 → 6084