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

+ *
  * In that case, we don't need to do it when GEM is initialized as nobody else
  * has access to the ring.
  */
 #define RING_LOCK_TEST_WITH_RETURN(dev, file) do {			\
-	if (LP_RING(dev->dev_private)->obj == NULL)			\
+	if (LP_RING(dev->dev_private)->buffer->obj == NULL)			\
 		LOCK_TEST_WITH_RETURN(dev, file);			\
 } while (0)
 static inline u32
 #define READ_BREADCRUMB(dev_priv) READ_HWSP(dev_priv, I915_BREADCRUMB_INDEX)
 #define I915_BREADCRUMB_INDEX		0x21
 void i915_update_dri1_breadcrumb(struct drm_device *dev)
 {
-	drm_i915_private_t *dev_priv = dev->dev_private;
+	struct drm_i915_private *dev_priv = dev->dev_private;
 	struct drm_i915_master_private *master_priv;
 	/*
+	}
+}
 static void i915_write_hws_pga(struct drm_device *dev)
 {
-	drm_i915_private_t *dev_priv = dev->dev_private;
+	struct drm_i915_private *dev_priv = dev->dev_private;
 	u32 addr;
 	addr = dev_priv->status_page_dmah->busaddr;
  * Frees the hardware status page, whether it's a physical address or a virtual
  * address set up by the X Server.
  */
 static void i915_free_hws(struct drm_device *dev)
+{
-	drm_i915_private_t *dev_priv = dev->dev_private;
+	struct drm_i915_private *dev_priv = dev->dev_private;
-	struct intel_ring_buffer *ring = LP_RING(dev_priv);
+	struct intel_engine_cs *ring = LP_RING(dev_priv);
 	if (dev_priv->status_page_dmah) {
 		drm_pci_free(dev, dev_priv->status_page_dmah);
 		dev_priv->status_page_dmah = NULL;
 #if 0
 void i915_kernel_lost_context(struct drm_device * dev)
+{
-	drm_i915_private_t *dev_priv = dev->dev_private;
+	struct drm_i915_private *dev_priv = dev->dev_private;
+	struct drm_i915_master_private *master_priv;
-	struct drm_i915_master_private *master_priv;
+	struct intel_engine_cs *ring = LP_RING(dev_priv);
-	struct intel_ring_buffer *ring = LP_RING(dev_priv);
+	struct intel_ringbuffer *ringbuf = ring->buffer;
 	/*
 	 * We should never lose context on the ring with modesetting
 	 * as we don't expose it to userspace
 	 */
 	if (drm_core_check_feature(dev, DRIVER_MODESET))
 		return;
-	ring->head = I915_READ_HEAD(ring) & HEAD_ADDR;
+	ringbuf->head = I915_READ_HEAD(ring) & HEAD_ADDR;
-	ring->tail = I915_READ_TAIL(ring) & TAIL_ADDR;
+	ringbuf->tail = I915_READ_TAIL(ring) & TAIL_ADDR;
-	ring->space = ring->head - (ring->tail + I915_RING_FREE_SPACE);
+	ringbuf->space = ringbuf->head - (ringbuf->tail + I915_RING_FREE_SPACE);
-	if (ring->space < 0)
+	if (ringbuf->space < 0)
-		ring->space += ring->size;
+		ringbuf->space += ringbuf->size;
 	if (!dev->primary->master)
 		return;
 	master_priv = dev->primary->master->driver_priv;
-	if (ring->head == ring->tail && master_priv->sarea_priv)
+	if (ringbuf->head == ringbuf->tail && master_priv->sarea_priv)
 		master_priv->sarea_priv->perf_boxes |= I915_BOX_RING_EMPTY;
+}
 	return 0;
+}
-static int i915_initialize(struct drm_device * dev, drm_i915_init_t * init)
+static int i915_initialize(struct drm_device *dev, drm_i915_init_t *init)
 {
-	drm_i915_private_t *dev_priv = dev->dev_private;
+	struct drm_i915_private *dev_priv = dev->dev_private;
 	struct drm_i915_master_private *master_priv = dev->primary->master->driver_priv;
 	int ret;
 	} else {
 		DRM_DEBUG_DRIVER("sarea not found assuming DRI2 userspace\n");
+	}
 	if (init->ring_size != 0) {
-		if (LP_RING(dev_priv)->obj != NULL) {
+		if (LP_RING(dev_priv)->buffer->obj != NULL) {
 			i915_dma_cleanup(dev);
 			DRM_ERROR("Client tried to initialize ringbuffer in "
 				  "GEM mode\n");
 			return -EINVAL;
 	return 0;
+}
-static int i915_dma_resume(struct drm_device * dev)
+static int i915_dma_resume(struct drm_device *dev)
 {
-	drm_i915_private_t *dev_priv = (drm_i915_private_t *) dev->dev_private;
+	struct drm_i915_private *dev_priv = dev->dev_private;
-	struct intel_ring_buffer *ring = LP_RING(dev_priv);
+	struct intel_engine_cs *ring = LP_RING(dev_priv);
 	DRM_DEBUG_DRIVER("%s\n", __func__);
-	if (ring->virtual_start == NULL) {
+	if (ring->buffer->virtual_start == NULL) {
 		DRM_ERROR("can not ioremap virtual address for"
 	return 0;
+}
-static int i915_emit_cmds(struct drm_device * dev, int *buffer, int dwords)
+static int i915_emit_cmds(struct drm_device *dev, int *buffer, int dwords)
 {
-	drm_i915_private_t *dev_priv = dev->dev_private;
+	struct drm_i915_private *dev_priv = dev->dev_private;
 	int i, ret;
-	if ((dwords+1) * sizeof(int) >= LP_RING(dev_priv)->size - 8)
+	if ((dwords+1) * sizeof(int) >= LP_RING(dev_priv)->buffer->size - 8)
 		return -EINVAL;
 	for (i = 0; i < dwords;) {
-	for (i = 0; i < dwords;) {
+		int sz = validate_cmd(buffer[i]);
 		int sz = validate_cmd(buffer[i]);
 		if (sz == 0 || i + sz > dwords)
  * emit. For now, do it in both places:
  */
 static void i915_emit_breadcrumb(struct drm_device *dev)
 {
-	drm_i915_private_t *dev_priv = dev->dev_private;
+	struct drm_i915_private *dev_priv = dev->dev_private;
 	struct drm_i915_master_private *master_priv = dev->primary->master->driver_priv;
 	dev_priv->dri1.counter++;
 	return 0;
+}
-static int i915_dispatch_flip(struct drm_device * dev)
+static int i915_dispatch_flip(struct drm_device *dev)
 {
-	drm_i915_private_t *dev_priv = dev->dev_private;
+	struct drm_i915_private *dev_priv = dev->dev_private;
 	struct drm_i915_master_private *master_priv =
 		dev->primary->master->driver_priv;
 	int ret;
+}
 static int i915_batchbuffer(struct drm_device *dev, void *data,
 			    struct drm_file *file_priv)
 {
-	drm_i915_private_t *dev_priv = (drm_i915_private_t *) dev->dev_private;
+	struct drm_i915_private *dev_priv = dev->dev_private;
-	struct drm_i915_master_private *master_priv = dev->primary->master->driver_priv;
+	struct drm_i915_master_private *master_priv;
-	drm_i915_sarea_t *sarea_priv = (drm_i915_sarea_t *)
-	    master_priv->sarea_priv;
+	drm_i915_sarea_t *sarea_priv;
 	drm_i915_batchbuffer_t *batch = data;
 	int ret;
 	struct drm_clip_rect *cliprects = NULL;
+	if (drm_core_check_feature(dev, DRIVER_MODESET))
+		return -ENODEV;
-	if (drm_core_check_feature(dev, DRIVER_MODESET))
+	master_priv = dev->primary->master->driver_priv;
-		return -ENODEV;
+	sarea_priv = (drm_i915_sarea_t *) master_priv->sarea_priv;
 	if (!dev_priv->dri1.allow_batchbuffer) {
+}
 static int i915_cmdbuffer(struct drm_device *dev, void *data,
 			  struct drm_file *file_priv)
 {
-	drm_i915_private_t *dev_priv = (drm_i915_private_t *) dev->dev_private;
+	struct drm_i915_private *dev_priv = dev->dev_private;
-	struct drm_i915_master_private *master_priv = dev->primary->master->driver_priv;
+	struct drm_i915_master_private *master_priv;
-	drm_i915_sarea_t *sarea_priv = (drm_i915_sarea_t *)
-	    master_priv->sarea_priv;
+	drm_i915_sarea_t *sarea_priv;
 	drm_i915_cmdbuffer_t *cmdbuf = data;
 	struct drm_clip_rect *cliprects = NULL;
 	void *batch_data;
 			cmdbuf->buf, cmdbuf->sz, cmdbuf->num_cliprects);
 	if (drm_core_check_feature(dev, DRIVER_MODESET))
+		return -ENODEV;
+	master_priv = dev->primary->master->driver_priv;
-		return -ENODEV;
+	sarea_priv = (drm_i915_sarea_t *) master_priv->sarea_priv;
 	RING_LOCK_TEST_WITH_RETURN(dev, file_priv);
 	return ret;
+}
-static int i915_emit_irq(struct drm_device * dev)
+static int i915_emit_irq(struct drm_device *dev)
 {
-	drm_i915_private_t *dev_priv = dev->dev_private;
+	struct drm_i915_private *dev_priv = dev->dev_private;
 	struct drm_i915_master_private *master_priv = dev->primary->master->driver_priv;
 	return dev_priv->dri1.counter;
+}
-static int i915_wait_irq(struct drm_device * dev, int irq_nr)
+static int i915_wait_irq(struct drm_device *dev, int irq_nr)
 {
-	drm_i915_private_t *dev_priv = (drm_i915_private_t *) dev->dev_private;
+	struct drm_i915_private *dev_priv = dev->dev_private;
 	struct drm_i915_master_private *master_priv = dev->primary->master->driver_priv;
 	int ret = 0;
-	struct intel_ring_buffer *ring = LP_RING(dev_priv);
+	struct intel_engine_cs *ring = LP_RING(dev_priv);
 	DRM_DEBUG_DRIVER("irq_nr=%d breadcrumb=%d\n", irq_nr,
 /* Needs the lock as it touches the ring.
  */
 static int i915_irq_emit(struct drm_device *dev, void *data,
 			 struct drm_file *file_priv)
+{
-	drm_i915_private_t *dev_priv = dev->dev_private;
+	struct drm_i915_private *dev_priv = dev->dev_private;
 	drm_i915_irq_emit_t *emit = data;
 	int result;
 	if (drm_core_check_feature(dev, DRIVER_MODESET))
 		return -ENODEV;
-	if (!dev_priv || !LP_RING(dev_priv)->virtual_start) {
+	if (!dev_priv || !LP_RING(dev_priv)->buffer->virtual_start) {
 		DRM_ERROR("called with no initialization\n");
 		return -EINVAL;
 /* Doesn't need the hardware lock.
  */
 static int i915_irq_wait(struct drm_device *dev, void *data,
 			 struct drm_file *file_priv)
+{
-	drm_i915_private_t *dev_priv = dev->dev_private;
+	struct drm_i915_private *dev_priv = dev->dev_private;
 	drm_i915_irq_wait_t *irqwait = data;
 	if (drm_core_check_feature(dev, DRIVER_MODESET))
+}
 static int i915_vblank_pipe_get(struct drm_device *dev, void *data,
 			 struct drm_file *file_priv)
 {
-	drm_i915_private_t *dev_priv = dev->dev_private;
+	struct drm_i915_private *dev_priv = dev->dev_private;
 	drm_i915_vblank_pipe_t *pipe = data;
 #endif
 int i915_getparam(struct drm_device *dev, void *data,
 			 struct drm_file *file_priv)
 {
-	drm_i915_private_t *dev_priv = dev->dev_private;
+	struct drm_i915_private *dev_priv = dev->dev_private;
 	drm_i915_getparam_t *param = data;
 	int value;
 		break;
 	case I915_PARAM_LAST_DISPATCH:
 		value = READ_BREADCRUMB(dev_priv);
 		break;
 	case I915_PARAM_CHIPSET_ID:
-		value = dev->pci_device;
+		value = dev->pdev->device;
 		break;
 	case I915_PARAM_HAS_GEM:
 		value = 1;
 		break;
 	case I915_PARAM_NUM_FENCES_AVAIL:
 		break;
 	case I915_PARAM_HAS_WT:
 		value = HAS_WT(dev);
 		break;
 	case I915_PARAM_HAS_ALIASING_PPGTT:
-		value = dev_priv->mm.aliasing_ppgtt ? 1 : 0;
+		value = dev_priv->mm.aliasing_ppgtt || USES_FULL_PPGTT(dev);
 		break;
 	case I915_PARAM_HAS_WAIT_TIMEOUT:
 		value = 1;
 		break;
 	case I915_PARAM_HAS_SEMAPHORES:
 		value = 1;
         break;
 	case I915_PARAM_HAS_EXEC_HANDLE_LUT:
 		value = 1;
         break;
+	case I915_PARAM_CMD_PARSER_VERSION:
+		value = i915_cmd_parser_get_version();
+		break;
 	default:
 		DRM_DEBUG("Unknown parameter %d\n", param->param);
 		return -EINVAL;
+	}
 #if 0
 static int i915_setparam(struct drm_device *dev, void *data,
 			 struct drm_file *file_priv)
 {
-	drm_i915_private_t *dev_priv = dev->dev_private;
+	struct drm_i915_private *dev_priv = dev->dev_private;
 	drm_i915_setparam_t *param = data;
 	if (!dev_priv) {
 /* Setup MCHBAR if possible, return true if we should disable it again */
 static void
 intel_setup_mchbar(struct drm_device *dev)
 {
-	drm_i915_private_t *dev_priv = dev->dev_private;
+	struct drm_i915_private *dev_priv = dev->dev_private;
 	int mchbar_reg = INTEL_INFO(dev)->gen >= 4 ? MCHBAR_I965 : MCHBAR_I915;
 	u32 temp;
+	bool enabled;
+	if (IS_VALLEYVIEW(dev))
-	bool enabled;
+		return;
 	dev_priv->mchbar_need_disable = false;
     ret = intel_parse_bios(dev);
     if (ret)
-        DRM_INFO("failed to find VBIOS tables\n");
+        DRM_INFO("failed to find VBIOS tables\n");
     main_fb_obj = kos_gem_fb_object_create(dev,0,16*1024*1024);
 	/* Initialise stolen first so that we may reserve preallocated
 	 * objects for the BIOS to KMS transition.
 	 */
+	ret = i915_gem_init_stolen(dev);
+	if (ret)
-	ret = i915_gem_init_stolen(dev);
+		goto cleanup_vga_switcheroo;
 	if (ret)
-		goto cleanup_vga_switcheroo;
+	intel_power_domains_init_hw(dev_priv);
-	ret = drm_irq_install(dev);
+	ret = drm_irq_install(dev, dev->pdev->irq);
 	if (ret)
 		goto cleanup_gem_stolen;
-	intel_power_domains_init_hw(dev);
+	dev_priv->pm._irqs_disabled = false;
 	/* Important: The output setup functions called by modeset_init need
 	 * working irqs for e.g. gmbus and dp aux transfers. */
     intel_modeset_init(dev);
 	ret = i915_gem_init(dev);
-    if (ret)
-		goto cleanup_power;
+    if (ret)
 		goto cleanup_irq;
     intel_modeset_gem_init(dev);
 	 * scanning against hotplug events. Hence do this first and ignore the
 	 * tiny window where we will loose hotplug notifactions.
 	 */
 	intel_fbdev_initial_config(dev);
-	/* Only enable hotplug handling once the fbdev is fully set up. */
-	dev_priv->enable_hotplug_processing = true;
 	drm_kms_helper_poll_init(dev);
     return 0;
 cleanup_gem:
 	mutex_lock(&dev->struct_mutex);
 	i915_gem_cleanup_ringbuffer(dev);
-	i915_gem_context_fini(dev);
-	mutex_unlock(&dev->struct_mutex);
+	i915_gem_context_fini(dev);
-	i915_gem_cleanup_aliasing_ppgtt(dev);
-	drm_mm_takedown(&dev_priv->gtt.base.mm);
+	mutex_unlock(&dev->struct_mutex);
-cleanup_power:
+	WARN_ON(dev_priv->mm.aliasing_ppgtt);
-	intel_display_power_put(dev, POWER_DOMAIN_VGA);
+cleanup_irq:
 //	drm_irq_uninstall(dev);
 cleanup_gem_stolen:
+}
 #if IS_ENABLED(CONFIG_FB)
-static void i915_kick_out_firmware_fb(struct drm_i915_private *dev_priv)
+static int i915_kick_out_firmware_fb(struct drm_i915_private *dev_priv)
+{
+	struct apertures_struct *ap;
-	struct apertures_struct *ap;
+	struct pci_dev *pdev = dev_priv->dev->pdev;
-	struct pci_dev *pdev = dev_priv->dev->pdev;
+	bool primary;
-	bool primary;
+	int ret;
 	ap = alloc_apertures(1);
 	if (!ap)
-		return;
+		return -ENOMEM;
 	ap->ranges[0].base = dev_priv->gtt.mappable_base;
+	ap->ranges[0].size = dev_priv->gtt.mappable_end;
-	ap->ranges[0].size = dev_priv->gtt.mappable_end;
+	primary =
 		pdev->resource[PCI_ROM_RESOURCE].flags & IORESOURCE_ROM_SHADOW;
-	primary =
-		pdev->resource[PCI_ROM_RESOURCE].flags & IORESOURCE_ROM_SHADOW;
+	ret = remove_conflicting_framebuffers(ap, "inteldrmfb", primary);
 	kfree(ap);
 	remove_conflicting_framebuffers(ap, "inteldrmfb", primary);
 	return ret;
 	kfree(ap);
-}
+#else
-#else
+static int i915_kick_out_firmware_fb(struct drm_i915_private *dev_priv)
 static void i915_kick_out_firmware_fb(struct drm_i915_private *dev_priv)
 	return 0;
+}
 #endif
 static void i915_dump_device_info(struct drm_i915_private *dev_priv)
+{
+	const struct intel_device_info *info = &dev_priv->info;
 	const struct intel_device_info *info = dev_priv->info;
 #define PRINT_S(name) "%s"
-#define PRINT_S(name) "%s"
+#define SEP_EMPTY
-#define SEP_EMPTY
+#define PRINT_FLAG(name) info->name ? #name "," : ""
-#define PRINT_FLAG(name) info->name ? #name "," : ""
+#define SEP_COMMA ,
-#define SEP_COMMA ,
+	DRM_DEBUG_DRIVER("i915 device info: gen=%i, pciid=0x%04x rev=0x%02x flags="
+			 DEV_INFO_FOR_EACH_FLAG(PRINT_S, SEP_EMPTY),
+			 info->gen,
+			 dev_priv->dev->pdev->device,
+			 dev_priv->dev->pdev->revision,
+			 DEV_INFO_FOR_EACH_FLAG(PRINT_FLAG, SEP_COMMA));
+#undef PRINT_S
+#undef SEP_EMPTY
+#undef PRINT_FLAG
+#undef SEP_COMMA
+}
+/*
+ * Determine various intel_device_info fields at runtime.
+ *
+ * Use it when either:
+ *   - it's judged too laborious to fill n static structures with the limit
+ *     when a simple if statement does the job,
+ *   - run-time checks (eg read fuse/strap registers) are needed.
+ *
+ * This function needs to be called:
+ *   - after the MMIO has been setup as we are reading registers,
+ *   - after the PCH has been detected,
+ *   - before the first usage of the fields it can tweak.
+ */
+static void intel_device_info_runtime_init(struct drm_device *dev)
+{
+	struct drm_i915_private *dev_priv = dev->dev_private;
+	struct intel_device_info *info;
+	enum pipe pipe;
+	info = (struct intel_device_info *)&dev_priv->info;
+	if (IS_VALLEYVIEW(dev))
+		for_each_pipe(pipe)
+			info->num_sprites[pipe] = 2;
+	else
+		for_each_pipe(pipe)
+			info->num_sprites[pipe] = 1;
+	if (i915.disable_display) {
+		DRM_INFO("Display disabled (module parameter)\n");
+		info->num_pipes = 0;
+	} else if (info->num_pipes > 0 &&
+		   (INTEL_INFO(dev)->gen == 7 || INTEL_INFO(dev)->gen == 8) &&
+		   !IS_VALLEYVIEW(dev)) {
+		u32 fuse_strap = I915_READ(FUSE_STRAP);
+		u32 sfuse_strap = I915_READ(SFUSE_STRAP);
+		/*
+		 * SFUSE_STRAP is supposed to have a bit signalling the display
+		 * is fused off. Unfortunately it seems that, at least in
+		 * certain cases, fused off display means that PCH display
+		 * reads don't land anywhere. In that case, we read 0s.
+		 *
+		 * On CPT/PPT, we can detect this case as SFUSE_STRAP_FUSE_LOCK
+		 * should be set when taking over after the firmware.
-	DRM_DEBUG_DRIVER("i915 device info: gen=%i, pciid=0x%04x flags="
+		 */
-			 DEV_INFO_FOR_EACH_FLAG(PRINT_S, SEP_EMPTY),
+		if (fuse_strap & ILK_INTERNAL_DISPLAY_DISABLE ||
-			 info->gen,
+		    sfuse_strap & SFUSE_STRAP_DISPLAY_DISABLED ||
-			 dev_priv->dev->pdev->device,
+		    (dev_priv->pch_type == PCH_CPT &&
-			 DEV_INFO_FOR_EACH_FLAG(PRINT_FLAG, SEP_COMMA));
+		     !(sfuse_strap & SFUSE_STRAP_FUSE_LOCK))) {
  *   - setup the DRM framebuffer with the allocated memory
  */
 int i915_driver_load(struct drm_device *dev, unsigned long flags)
+{
     struct drm_i915_private *dev_priv;
-	struct intel_device_info *info;
+	struct intel_device_info *info, *device_info;
 	int ret = 0, mmio_bar, mmio_size;
 	uint32_t aperture_size;
 	info = (struct intel_device_info *) flags;
 	dev_priv = kzalloc(sizeof(*dev_priv), GFP_KERNEL);
     if (dev_priv == NULL)
+        return -ENOMEM;
+	dev->dev_private = dev_priv;
-        return -ENOMEM;
+    dev_priv->dev = dev;
-    dev->dev_private = (void *)dev_priv;
+	/* copy initial configuration to dev_priv->info */
-    dev_priv->dev = dev;
+	device_info = (struct intel_device_info *)&dev_priv->info;
-	dev_priv->info = info;
+	*device_info = *info;
+	spin_lock_init(&dev_priv->irq_lock);
-	spin_lock_init(&dev_priv->irq_lock);
+	spin_lock_init(&dev_priv->gpu_error.lock);
-	spin_lock_init(&dev_priv->gpu_error.lock);
+	spin_lock_init(&dev_priv->backlight_lock);
-	spin_lock_init(&dev_priv->backlight_lock);
+	spin_lock_init(&dev_priv->uncore.lock);
 		DRM_ERROR("failed to map registers\n");
 		ret = -EIO;
 		goto put_bridge;
+	}
-	intel_uncore_early_sanitize(dev);
 	/* This must be called before any calls to HAS_PCH_* */
 	intel_detect_pch(dev);
      * According to chipset errata, on the 965GM, MSI interrupts may
      * be lost or delayed, but we use them anyways to avoid
      * stuck interrupts on some machines.
      */
-	dev_priv->num_plane = 1;
-	if (IS_VALLEYVIEW(dev))
-		dev_priv->num_plane = 2;
+	intel_device_info_runtime_init(dev);
 //   if (INTEL_INFO(dev)->num_pipes) {
 //       ret = drm_vblank_init(dev, INTEL_INFO(dev)->num_pipes);
 //       if (ret)
 //           goto out_gem_unload;
 //   }
-	intel_power_domains_init(dev);
+	intel_power_domains_init(dev_priv);
 	if (INTEL_INFO(dev)->num_pipes) {
-    /* Must be done after probing outputs */
-		intel_opregion_init(dev);
+    /* Must be done after probing outputs */
-//		acpi_video_register();
+		intel_opregion_init(dev);
+	}
 	intel_gpu_ips_teardown();
 		/* The i915.ko module is still not prepared to be loaded when
 		 * the power well is not enabled, so just enable it in case
 		 * we're going to unload/reload. */
-	intel_display_set_init_power(dev, true);
+	intel_display_set_init_power(dev_priv, true);
-	intel_power_domains_remove(dev);
+	intel_power_domains_remove(dev_priv);
 	i915_teardown_sysfs(dev);
 	/* Free error state after interrupts are fully disabled. */
 	del_timer_sync(&dev_priv->gpu_error.hangcheck_timer);
 	cancel_work_sync(&dev_priv->gpu_error.work);
 	i915_destroy_error_state(dev);
-	cancel_delayed_work_sync(&dev_priv->pc8.enable_work);
 	if (dev->pdev->msi_enabled)
 		pci_disable_msi(dev->pdev);
 	intel_opregion_fini(dev);
 	if (drm_core_check_feature(dev, DRIVER_MODESET)) {
-		/* Flush any outstanding unpin_work. */
-		flush_workqueue(dev_priv->wq);
+		/* Flush any outstanding unpin_work. */
 		flush_workqueue(dev_priv->wq);
 		mutex_lock(&dev->struct_mutex);
-		i915_gem_free_all_phys_object(dev);
 		i915_gem_cleanup_ringbuffer(dev);
 		i915_gem_context_fini(dev);
-		mutex_unlock(&dev->struct_mutex);
+		WARN_ON(dev_priv->mm.aliasing_ppgtt);
-		i915_gem_cleanup_aliasing_ppgtt(dev);
+		mutex_unlock(&dev->struct_mutex);
-		i915_gem_cleanup_stolen(dev);
 		i915_gem_cleanup_stolen(dev);
 		if (!I915_NEED_GFX_HWS(dev))
-			i915_free_hws(dev);
+		if (!I915_NEED_GFX_HWS(dev))
 			i915_free_hws(dev);
+	}
-	list_del(&dev_priv->gtt.base.global_link);
+	WARN_ON(!list_empty(&dev_priv->vm_list));
 	WARN_ON(!list_empty(&dev_priv->vm_list));
 	if (dev_priv->slab)
 		kmem_cache_destroy(dev_priv->slab);
 	pci_dev_put(dev_priv->bridge_dev);
-	kfree(dev->dev_private);
+	kfree(dev_priv);
 	return 0;
+}
-#endif
-int i915_driver_open(struct drm_device *dev, struct drm_file *file)
-{
-	struct drm_i915_file_private *file_priv;
+#endif
-	DRM_DEBUG_DRIVER("\n");
-	file_priv = kzalloc(sizeof(*file_priv), GFP_KERNEL);
-	if (!file_priv)
-		return -ENOMEM;
-	file->driver_priv = file_priv;
+int i915_driver_open(struct drm_device *dev, struct drm_file *file)
+{
 	int ret;
 	spin_lock_init(&file_priv->mm.lock);
-	INIT_LIST_HEAD(&file_priv->mm.request_list);
+	ret = i915_gem_open(dev, file);
  * and DMA structures, since the kernel won't be using them, and clea
  * up any GEM state.
  */
-void i915_driver_lastclose(struct drm_device * dev)
+void i915_driver_lastclose(struct drm_device *dev)
+{
-	drm_i915_private_t *dev_priv = dev->dev_private;
+	struct drm_i915_private *dev_priv = dev->dev_private;
 	/* On gen6+ we refuse to init without kms enabled, but then the drm core
 	 * goes right around and calls lastclose. Check for this and don't clean
 	 * up anything. */
 	i915_gem_lastclose(dev);
 	i915_dma_cleanup(dev);
 }
-void i915_driver_preclose(struct drm_device * dev, struct drm_file *file_priv)
+void i915_driver_preclose(struct drm_device *dev, struct drm_file *file)
 {
 	mutex_lock(&dev->struct_mutex);
-	i915_gem_context_close(dev, file_priv);
+	i915_gem_context_close(dev, file);
-	i915_gem_release(dev, file_priv);
+	i915_gem_release(dev, file);
 	mutex_unlock(&dev->struct_mutex);
+}
+void i915_driver_postclose(struct drm_device *dev, struct drm_file *file)
+{
-void i915_driver_postclose(struct drm_device *dev, struct drm_file *file)
+	struct drm_i915_file_private *file_priv = file->driver_priv;
-	struct drm_i915_file_private *file_priv = file->driver_priv;
+	if (file_priv && file_priv->bsd_ring)
 		file_priv->bsd_ring = NULL;
 	DRM_IOCTL_DEF_DRV(I915_GEM_WAIT, i915_gem_wait_ioctl, DRM_AUTH|DRM_UNLOCKED|DRM_RENDER_ALLOW),
 	DRM_IOCTL_DEF_DRV(I915_GEM_CONTEXT_CREATE, i915_gem_context_create_ioctl, DRM_UNLOCKED|DRM_RENDER_ALLOW),
 	DRM_IOCTL_DEF_DRV(I915_GEM_CONTEXT_DESTROY, i915_gem_context_destroy_ioctl, DRM_UNLOCKED|DRM_RENDER_ALLOW),
 	DRM_IOCTL_DEF_DRV(I915_REG_READ, i915_reg_read_ioctl, DRM_UNLOCKED|DRM_RENDER_ALLOW),
 	DRM_IOCTL_DEF_DRV(I915_GET_RESET_STATS, i915_get_reset_stats_ioctl, DRM_UNLOCKED|DRM_RENDER_ALLOW),
+	DRM_IOCTL_DEF_DRV(I915_GEM_USERPTR, i915_gem_userptr_ioctl, DRM_UNLOCKED|DRM_RENDER_ALLOW),
 };
-int i915_max_ioctl = DRM_ARRAY_SIZE(i915_ioctls);
+int i915_max_ioctl = ARRAY_SIZE(i915_ioctls);
 /*
  * This is really ugly: Because old userspace abused the linux agp interface to

Subversion Repositories Kolibri OS

(root)/drivers/video/drm/i915/i915_dma.c – Rev 4560 → 5060