-3

drivers/char/agp/intel-agp.c

reviewed

··· 1817 1817 pci_write_config_byte(agp_bridge->dev, INTEL_I845_AGPM, temp2 | (1 << 1)); 1818 1818 /* clear any possible error conditions */ 1819 1819 pci_write_config_word(agp_bridge->dev, INTEL_I845_ERRSTS, 0x001c); 1820 1820 - 1821 1821 - intel_i830_setup_flush(); 1822 1820 return 0; 1823 1821 } 1824 1822 ··· 2186 2188 .agp_destroy_page = agp_generic_destroy_page, 2187 2189 .agp_destroy_pages = agp_generic_destroy_pages, 2188 2190 .agp_type_to_mask_type = agp_generic_type_to_mask_type, 2189 2189 - .chipset_flush = intel_i830_chipset_flush, 2190 2191 }; 2191 2192 2192 2193 static const struct agp_bridge_driver intel_850_driver = {

+1 -1

drivers/gpu/drm/i915/i915_debugfs.c

reviewed

··· 226 226 } else { 227 227 struct drm_i915_gem_object *obj_priv; 228 228 229 229 - obj_priv = obj->driver_private; 229 229 + obj_priv = to_intel_bo(obj); 230 230 seq_printf(m, "Fenced object[%2d] = %p: %s " 231 231 "%08x %08zx %08x %s %08x %08x %d", 232 232 i, obj, get_pin_flag(obj_priv),

+3 -3

drivers/gpu/drm/i915/i915_drv.c

reviewed

··· 80 80 .is_i915g = 1, .is_i9xx = 1, .cursor_needs_physical = 1, 81 81 }; 82 82 const static struct intel_device_info intel_i915gm_info = { 83 83 - .is_i9xx = 1, .is_mobile = 1, .has_fbc = 1, 83 83 + .is_i9xx = 1, .is_mobile = 1, 84 84 .cursor_needs_physical = 1, 85 85 }; 86 86 const static struct intel_device_info intel_i945g_info = { 87 87 .is_i9xx = 1, .has_hotplug = 1, .cursor_needs_physical = 1, 88 88 }; 89 89 const static struct intel_device_info intel_i945gm_info = { 90 90 - .is_i945gm = 1, .is_i9xx = 1, .is_mobile = 1, .has_fbc = 1, 90 90 + .is_i945gm = 1, .is_i9xx = 1, .is_mobile = 1, 91 91 .has_hotplug = 1, .cursor_needs_physical = 1, 92 92 }; 93 93 ··· 361 361 !dev_priv->mm.suspended) { 362 362 drm_i915_ring_buffer_t *ring = &dev_priv->ring; 363 363 struct drm_gem_object *obj = ring->ring_obj; 364 364 - struct drm_i915_gem_object *obj_priv = obj->driver_private; 364 364 + struct drm_i915_gem_object *obj_priv = to_intel_bo(obj); 365 365 dev_priv->mm.suspended = 0; 366 366 367 367 /* Stop the ring if it's running. */

+4

drivers/gpu/drm/i915/i915_drv.h

reviewed

··· 611 611 /* Reclocking support */ 612 612 bool render_reclock_avail; 613 613 bool lvds_downclock_avail; 614 614 + /* indicate whether the LVDS EDID is OK */ 615 615 + bool lvds_edid_good; 614 616 /* indicates the reduced downclock for LVDS*/ 615 617 int lvds_downclock; 616 618 struct work_struct idle_work; ··· 732 730 */ 733 731 atomic_t pending_flip; 734 732 }; 733 733 + 734 734 + #define to_intel_bo(x) ((struct drm_i915_gem_object *) (x)->driver_private) 735 735 736 736 /** 737 737 * Request queue structure.

+66 -66

drivers/gpu/drm/i915/i915_gem.c

reviewed

··· 163 163 static int i915_gem_object_needs_bit17_swizzle(struct drm_gem_object *obj) 164 164 { 165 165 drm_i915_private_t *dev_priv = obj->dev->dev_private; 166 166 - struct drm_i915_gem_object *obj_priv = obj->driver_private; 166 166 + struct drm_i915_gem_object *obj_priv = to_intel_bo(obj); 167 167 168 168 return dev_priv->mm.bit_6_swizzle_x == I915_BIT_6_SWIZZLE_9_10_17 && 169 169 obj_priv->tiling_mode != I915_TILING_NONE; ··· 264 264 struct drm_i915_gem_pread *args, 265 265 struct drm_file *file_priv) 266 266 { 267 267 - struct drm_i915_gem_object *obj_priv = obj->driver_private; 267 267 + struct drm_i915_gem_object *obj_priv = to_intel_bo(obj); 268 268 ssize_t remain; 269 269 loff_t offset, page_base; 270 270 char __user *user_data; ··· 285 285 if (ret != 0) 286 286 goto fail_put_pages; 287 287 288 288 - obj_priv = obj->driver_private; 288 288 + obj_priv = to_intel_bo(obj); 289 289 offset = args->offset; 290 290 291 291 while (remain > 0) { ··· 354 354 struct drm_i915_gem_pread *args, 355 355 struct drm_file *file_priv) 356 356 { 357 357 - struct drm_i915_gem_object *obj_priv = obj->driver_private; 357 357 + struct drm_i915_gem_object *obj_priv = to_intel_bo(obj); 358 358 struct mm_struct *mm = current->mm; 359 359 struct page **user_pages; 360 360 ssize_t remain; ··· 403 403 if (ret != 0) 404 404 goto fail_put_pages; 405 405 406 406 - obj_priv = obj->driver_private; 406 406 + obj_priv = to_intel_bo(obj); 407 407 offset = args->offset; 408 408 409 409 while (remain > 0) { ··· 479 479 obj = drm_gem_object_lookup(dev, file_priv, args->handle); 480 480 if (obj == NULL) 481 481 return -EBADF; 482 482 - obj_priv = obj->driver_private; 482 482 + obj_priv = to_intel_bo(obj); 483 483 484 484 /* Bounds check source. 485 485 * ··· 581 581 struct drm_i915_gem_pwrite *args, 582 582 struct drm_file *file_priv) 583 583 { 584 584 - struct drm_i915_gem_object *obj_priv = obj->driver_private; 584 584 + struct drm_i915_gem_object *obj_priv = to_intel_bo(obj); 585 585 drm_i915_private_t *dev_priv = dev->dev_private; 586 586 ssize_t remain; 587 587 loff_t offset, page_base; ··· 605 605 if (ret) 606 606 goto fail; 607 607 608 608 - obj_priv = obj->driver_private; 608 608 + obj_priv = to_intel_bo(obj); 609 609 offset = obj_priv->gtt_offset + args->offset; 610 610 611 611 while (remain > 0) { ··· 655 655 struct drm_i915_gem_pwrite *args, 656 656 struct drm_file *file_priv) 657 657 { 658 658 - struct drm_i915_gem_object *obj_priv = obj->driver_private; 658 658 + struct drm_i915_gem_object *obj_priv = to_intel_bo(obj); 659 659 drm_i915_private_t *dev_priv = dev->dev_private; 660 660 ssize_t remain; 661 661 loff_t gtt_page_base, offset; ··· 699 699 if (ret) 700 700 goto out_unpin_object; 701 701 702 702 - obj_priv = obj->driver_private; 702 702 + obj_priv = to_intel_bo(obj); 703 703 offset = obj_priv->gtt_offset + args->offset; 704 704 705 705 while (remain > 0) { ··· 761 761 struct drm_i915_gem_pwrite *args, 762 762 struct drm_file *file_priv) 763 763 { 764 764 - struct drm_i915_gem_object *obj_priv = obj->driver_private; 764 764 + struct drm_i915_gem_object *obj_priv = to_intel_bo(obj); 765 765 ssize_t remain; 766 766 loff_t offset, page_base; 767 767 char __user *user_data; ··· 781 781 if (ret != 0) 782 782 goto fail_put_pages; 783 783 784 784 - obj_priv = obj->driver_private; 784 784 + obj_priv = to_intel_bo(obj); 785 785 offset = args->offset; 786 786 obj_priv->dirty = 1; 787 787 ··· 829 829 struct drm_i915_gem_pwrite *args, 830 830 struct drm_file *file_priv) 831 831 { 832 832 - struct drm_i915_gem_object *obj_priv = obj->driver_private; 832 832 + struct drm_i915_gem_object *obj_priv = to_intel_bo(obj); 833 833 struct mm_struct *mm = current->mm; 834 834 struct page **user_pages; 835 835 ssize_t remain; ··· 877 877 if (ret != 0) 878 878 goto fail_put_pages; 879 879 880 880 - obj_priv = obj->driver_private; 880 880 + obj_priv = to_intel_bo(obj); 881 881 offset = args->offset; 882 882 obj_priv->dirty = 1; 883 883 ··· 952 952 obj = drm_gem_object_lookup(dev, file_priv, args->handle); 953 953 if (obj == NULL) 954 954 return -EBADF; 955 955 - obj_priv = obj->driver_private; 955 955 + obj_priv = to_intel_bo(obj); 956 956 957 957 /* Bounds check destination. 958 958 * ··· 1034 1034 obj = drm_gem_object_lookup(dev, file_priv, args->handle); 1035 1035 if (obj == NULL) 1036 1036 return -EBADF; 1037 1037 - obj_priv = obj->driver_private; 1037 1037 + obj_priv = to_intel_bo(obj); 1038 1038 1039 1039 mutex_lock(&dev->struct_mutex); 1040 1040 ··· 1096 1096 DRM_INFO("%s: sw_finish %d (%p %zd)\n", 1097 1097 __func__, args->handle, obj, obj->size); 1098 1098 #endif 1099 1099 - obj_priv = obj->driver_private; 1099 1099 + obj_priv = to_intel_bo(obj); 1100 1100 1101 1101 /* Pinned buffers may be scanout, so flush the cache */ 1102 1102 if (obj_priv->pin_count) ··· 1167 1167 struct drm_gem_object *obj = vma->vm_private_data; 1168 1168 struct drm_device *dev = obj->dev; 1169 1169 struct drm_i915_private *dev_priv = dev->dev_private; 1170 1170 - struct drm_i915_gem_object *obj_priv = obj->driver_private; 1170 1170 + struct drm_i915_gem_object *obj_priv = to_intel_bo(obj); 1171 1171 pgoff_t page_offset; 1172 1172 unsigned long pfn; 1173 1173 int ret = 0; ··· 1234 1234 { 1235 1235 struct drm_device *dev = obj->dev; 1236 1236 struct drm_gem_mm *mm = dev->mm_private; 1237 1237 - struct drm_i915_gem_object *obj_priv = obj->driver_private; 1237 1237 + struct drm_i915_gem_object *obj_priv = to_intel_bo(obj); 1238 1238 struct drm_map_list *list; 1239 1239 struct drm_local_map *map; 1240 1240 int ret = 0; ··· 1305 1305 i915_gem_release_mmap(struct drm_gem_object *obj) 1306 1306 { 1307 1307 struct drm_device *dev = obj->dev; 1308 1308 - struct drm_i915_gem_object *obj_priv = obj->driver_private; 1308 1308 + struct drm_i915_gem_object *obj_priv = to_intel_bo(obj); 1309 1309 1310 1310 if (dev->dev_mapping) 1311 1311 unmap_mapping_range(dev->dev_mapping, ··· 1316 1316 i915_gem_free_mmap_offset(struct drm_gem_object *obj) 1317 1317 { 1318 1318 struct drm_device *dev = obj->dev; 1319 1319 - struct drm_i915_gem_object *obj_priv = obj->driver_private; 1319 1319 + struct drm_i915_gem_object *obj_priv = to_intel_bo(obj); 1320 1320 struct drm_gem_mm *mm = dev->mm_private; 1321 1321 struct drm_map_list *list; 1322 1322 ··· 1347 1347 i915_gem_get_gtt_alignment(struct drm_gem_object *obj) 1348 1348 { 1349 1349 struct drm_device *dev = obj->dev; 1350 1350 - struct drm_i915_gem_object *obj_priv = obj->driver_private; 1350 1350 + struct drm_i915_gem_object *obj_priv = to_intel_bo(obj); 1351 1351 int start, i; 1352 1352 1353 1353 /* ··· 1406 1406 1407 1407 mutex_lock(&dev->struct_mutex); 1408 1408 1409 1409 - obj_priv = obj->driver_private; 1409 1409 + obj_priv = to_intel_bo(obj); 1410 1410 1411 1411 if (obj_priv->madv != I915_MADV_WILLNEED) { 1412 1412 DRM_ERROR("Attempting to mmap a purgeable buffer\n"); ··· 1450 1450 void 1451 1451 i915_gem_object_put_pages(struct drm_gem_object *obj) 1452 1452 { 1453 1453 - struct drm_i915_gem_object *obj_priv = obj->driver_private; 1453 1453 + struct drm_i915_gem_object *obj_priv = to_intel_bo(obj); 1454 1454 int page_count = obj->size / PAGE_SIZE; 1455 1455 int i; 1456 1456 ··· 1486 1486 { 1487 1487 struct drm_device *dev = obj->dev; 1488 1488 drm_i915_private_t *dev_priv = dev->dev_private; 1489 1489 - struct drm_i915_gem_object *obj_priv = obj->driver_private; 1489 1489 + struct drm_i915_gem_object *obj_priv = to_intel_bo(obj); 1490 1490 1491 1491 /* Add a reference if we're newly entering the active list. */ 1492 1492 if (!obj_priv->active) { ··· 1506 1506 { 1507 1507 struct drm_device *dev = obj->dev; 1508 1508 drm_i915_private_t *dev_priv = dev->dev_private; 1509 1509 - struct drm_i915_gem_object *obj_priv = obj->driver_private; 1509 1509 + struct drm_i915_gem_object *obj_priv = to_intel_bo(obj); 1510 1510 1511 1511 BUG_ON(!obj_priv->active); 1512 1512 list_move_tail(&obj_priv->list, &dev_priv->mm.flushing_list); ··· 1517 1517 static void 1518 1518 i915_gem_object_truncate(struct drm_gem_object *obj) 1519 1519 { 1520 1520 - struct drm_i915_gem_object *obj_priv = obj->driver_private; 1520 1520 + struct drm_i915_gem_object *obj_priv = to_intel_bo(obj); 1521 1521 struct inode *inode; 1522 1522 1523 1523 inode = obj->filp->f_path.dentry->d_inode; ··· 1538 1538 { 1539 1539 struct drm_device *dev = obj->dev; 1540 1540 drm_i915_private_t *dev_priv = dev->dev_private; 1541 1541 - struct drm_i915_gem_object *obj_priv = obj->driver_private; 1541 1541 + struct drm_i915_gem_object *obj_priv = to_intel_bo(obj); 1542 1542 1543 1543 i915_verify_inactive(dev, __FILE__, __LINE__); 1544 1544 if (obj_priv->pin_count != 0) ··· 1965 1965 i915_gem_object_wait_rendering(struct drm_gem_object *obj) 1966 1966 { 1967 1967 struct drm_device *dev = obj->dev; 1968 1968 - struct drm_i915_gem_object *obj_priv = obj->driver_private; 1968 1968 + struct drm_i915_gem_object *obj_priv = to_intel_bo(obj); 1969 1969 int ret; 1970 1970 1971 1971 /* This function only exists to support waiting for existing rendering, ··· 1997 1997 { 1998 1998 struct drm_device *dev = obj->dev; 1999 1999 drm_i915_private_t *dev_priv = dev->dev_private; 2000 2000 - struct drm_i915_gem_object *obj_priv = obj->driver_private; 2000 2000 + struct drm_i915_gem_object *obj_priv = to_intel_bo(obj); 2001 2001 int ret = 0; 2002 2002 2003 2003 #if WATCH_BUF ··· 2173 2173 #if WATCH_LRU 2174 2174 DRM_INFO("%s: evicting %p\n", __func__, obj); 2175 2175 #endif 2176 2176 - obj_priv = obj->driver_private; 2176 2176 + obj_priv = to_intel_bo(obj); 2177 2177 BUG_ON(obj_priv->pin_count != 0); 2178 2178 BUG_ON(obj_priv->active); 2179 2179 ··· 2244 2244 i915_gem_object_get_pages(struct drm_gem_object *obj, 2245 2245 gfp_t gfpmask) 2246 2246 { 2247 2247 - struct drm_i915_gem_object *obj_priv = obj->driver_private; 2247 2247 + struct drm_i915_gem_object *obj_priv = to_intel_bo(obj); 2248 2248 int page_count, i; 2249 2249 struct address_space *mapping; 2250 2250 struct inode *inode; ··· 2297 2297 struct drm_gem_object *obj = reg->obj; 2298 2298 struct drm_device *dev = obj->dev; 2299 2299 drm_i915_private_t *dev_priv = dev->dev_private; 2300 2300 - struct drm_i915_gem_object *obj_priv = obj->driver_private; 2300 2300 + struct drm_i915_gem_object *obj_priv = to_intel_bo(obj); 2301 2301 int regnum = obj_priv->fence_reg; 2302 2302 uint64_t val; 2303 2303 ··· 2319 2319 struct drm_gem_object *obj = reg->obj; 2320 2320 struct drm_device *dev = obj->dev; 2321 2321 drm_i915_private_t *dev_priv = dev->dev_private; 2322 2322 - struct drm_i915_gem_object *obj_priv = obj->driver_private; 2322 2322 + struct drm_i915_gem_object *obj_priv = to_intel_bo(obj); 2323 2323 int regnum = obj_priv->fence_reg; 2324 2324 uint64_t val; 2325 2325 ··· 2339 2339 struct drm_gem_object *obj = reg->obj; 2340 2340 struct drm_device *dev = obj->dev; 2341 2341 drm_i915_private_t *dev_priv = dev->dev_private; 2342 2342 - struct drm_i915_gem_object *obj_priv = obj->driver_private; 2342 2342 + struct drm_i915_gem_object *obj_priv = to_intel_bo(obj); 2343 2343 int regnum = obj_priv->fence_reg; 2344 2344 int tile_width; 2345 2345 uint32_t fence_reg, val; ··· 2381 2381 struct drm_gem_object *obj = reg->obj; 2382 2382 struct drm_device *dev = obj->dev; 2383 2383 drm_i915_private_t *dev_priv = dev->dev_private; 2384 2384 - struct drm_i915_gem_object *obj_priv = obj->driver_private; 2384 2384 + struct drm_i915_gem_object *obj_priv = to_intel_bo(obj); 2385 2385 int regnum = obj_priv->fence_reg; 2386 2386 uint32_t val; 2387 2387 uint32_t pitch_val; ··· 2425 2425 if (!reg->obj) 2426 2426 return i; 2427 2427 2428 2428 - obj_priv = reg->obj->driver_private; 2428 2428 + obj_priv = to_intel_bo(reg->obj); 2429 2429 if (!obj_priv->pin_count) 2430 2430 avail++; 2431 2431 } ··· 2480 2480 { 2481 2481 struct drm_device *dev = obj->dev; 2482 2482 struct drm_i915_private *dev_priv = dev->dev_private; 2483 2483 - struct drm_i915_gem_object *obj_priv = obj->driver_private; 2483 2483 + struct drm_i915_gem_object *obj_priv = to_intel_bo(obj); 2484 2484 struct drm_i915_fence_reg *reg = NULL; 2485 2485 int ret; 2486 2486 ··· 2547 2547 { 2548 2548 struct drm_device *dev = obj->dev; 2549 2549 drm_i915_private_t *dev_priv = dev->dev_private; 2550 2550 - struct drm_i915_gem_object *obj_priv = obj->driver_private; 2550 2550 + struct drm_i915_gem_object *obj_priv = to_intel_bo(obj); 2551 2551 2552 2552 if (IS_GEN6(dev)) { 2553 2553 I915_WRITE64(FENCE_REG_SANDYBRIDGE_0 + ··· 2583 2583 i915_gem_object_put_fence_reg(struct drm_gem_object *obj) 2584 2584 { 2585 2585 struct drm_device *dev = obj->dev; 2586 2586 - struct drm_i915_gem_object *obj_priv = obj->driver_private; 2586 2586 + struct drm_i915_gem_object *obj_priv = to_intel_bo(obj); 2587 2587 2588 2588 if (obj_priv->fence_reg == I915_FENCE_REG_NONE) 2589 2589 return 0; ··· 2621 2621 { 2622 2622 struct drm_device *dev = obj->dev; 2623 2623 drm_i915_private_t *dev_priv = dev->dev_private; 2624 2624 - struct drm_i915_gem_object *obj_priv = obj->driver_private; 2624 2624 + struct drm_i915_gem_object *obj_priv = to_intel_bo(obj); 2625 2625 struct drm_mm_node *free_space; 2626 2626 gfp_t gfpmask = __GFP_NORETRY | __GFP_NOWARN; 2627 2627 int ret; ··· 2728 2728 void 2729 2729 i915_gem_clflush_object(struct drm_gem_object *obj) 2730 2730 { 2731 2731 - struct drm_i915_gem_object *obj_priv = obj->driver_private; 2731 2731 + struct drm_i915_gem_object *obj_priv = to_intel_bo(obj); 2732 2732 2733 2733 /* If we don't have a page list set up, then we're not pinned 2734 2734 * to GPU, and we can ignore the cache flush because it'll happen ··· 2829 2829 int 2830 2830 i915_gem_object_set_to_gtt_domain(struct drm_gem_object *obj, int write) 2831 2831 { 2832 2832 - struct drm_i915_gem_object *obj_priv = obj->driver_private; 2832 2832 + struct drm_i915_gem_object *obj_priv = to_intel_bo(obj); 2833 2833 uint32_t old_write_domain, old_read_domains; 2834 2834 int ret; 2835 2835 ··· 2879 2879 i915_gem_object_set_to_display_plane(struct drm_gem_object *obj) 2880 2880 { 2881 2881 struct drm_device *dev = obj->dev; 2882 2882 - struct drm_i915_gem_object *obj_priv = obj->driver_private; 2882 2882 + struct drm_i915_gem_object *obj_priv = to_intel_bo(obj); 2883 2883 uint32_t old_write_domain, old_read_domains; 2884 2884 int ret; 2885 2885 ··· 3092 3092 i915_gem_object_set_to_gpu_domain(struct drm_gem_object *obj) 3093 3093 { 3094 3094 struct drm_device *dev = obj->dev; 3095 3095 - struct drm_i915_gem_object *obj_priv = obj->driver_private; 3095 3095 + struct drm_i915_gem_object *obj_priv = to_intel_bo(obj); 3096 3096 uint32_t invalidate_domains = 0; 3097 3097 uint32_t flush_domains = 0; 3098 3098 uint32_t old_read_domains; ··· 3177 3177 static void 3178 3178 i915_gem_object_set_to_full_cpu_read_domain(struct drm_gem_object *obj) 3179 3179 { 3180 3180 - struct drm_i915_gem_object *obj_priv = obj->driver_private; 3180 3180 + struct drm_i915_gem_object *obj_priv = to_intel_bo(obj); 3181 3181 3182 3182 if (!obj_priv->page_cpu_valid) 3183 3183 return; ··· 3217 3217 i915_gem_object_set_cpu_read_domain_range(struct drm_gem_object *obj, 3218 3218 uint64_t offset, uint64_t size) 3219 3219 { 3220 3220 - struct drm_i915_gem_object *obj_priv = obj->driver_private; 3220 3220 + struct drm_i915_gem_object *obj_priv = to_intel_bo(obj); 3221 3221 uint32_t old_read_domains; 3222 3222 int i, ret; 3223 3223 ··· 3286 3286 { 3287 3287 struct drm_device *dev = obj->dev; 3288 3288 drm_i915_private_t *dev_priv = dev->dev_private; 3289 3289 - struct drm_i915_gem_object *obj_priv = obj->driver_private; 3289 3289 + struct drm_i915_gem_object *obj_priv = to_intel_bo(obj); 3290 3290 int i, ret; 3291 3291 void __iomem *reloc_page; 3292 3292 bool need_fence; ··· 3337 3337 i915_gem_object_unpin(obj); 3338 3338 return -EBADF; 3339 3339 } 3340 3340 - target_obj_priv = target_obj->driver_private; 3340 3340 + target_obj_priv = to_intel_bo(target_obj); 3341 3341 3342 3342 #if WATCH_RELOC 3343 3343 DRM_INFO("%s: obj %p offset %08x target %d " ··· 3689 3689 prepare_to_wait(&dev_priv->pending_flip_queue, 3690 3690 &wait, TASK_INTERRUPTIBLE); 3691 3691 for (i = 0; i < count; i++) { 3692 3692 - obj_priv = object_list[i]->driver_private; 3692 3692 + obj_priv = to_intel_bo(object_list[i]); 3693 3693 if (atomic_read(&obj_priv->pending_flip) > 0) 3694 3694 break; 3695 3695 } ··· 3798 3798 goto err; 3799 3799 } 3800 3800 3801 3801 - obj_priv = object_list[i]->driver_private; 3801 3801 + obj_priv = to_intel_bo(object_list[i]); 3802 3802 if (obj_priv->in_execbuffer) { 3803 3803 DRM_ERROR("Object %p appears more than once in object list\n", 3804 3804 object_list[i]); ··· 3924 3924 3925 3925 for (i = 0; i < args->buffer_count; i++) { 3926 3926 struct drm_gem_object *obj = object_list[i]; 3927 3927 - struct drm_i915_gem_object *obj_priv = obj->driver_private; 3927 3927 + struct drm_i915_gem_object *obj_priv = to_intel_bo(obj); 3928 3928 uint32_t old_write_domain = obj->write_domain; 3929 3929 3930 3930 obj->write_domain = obj->pending_write_domain; ··· 3999 3999 4000 4000 for (i = 0; i < args->buffer_count; i++) { 4001 4001 if (object_list[i]) { 4002 4002 - obj_priv = object_list[i]->driver_private; 4002 4002 + obj_priv = to_intel_bo(object_list[i]); 4003 4003 obj_priv->in_execbuffer = false; 4004 4004 } 4005 4005 drm_gem_object_unreference(object_list[i]); ··· 4177 4177 i915_gem_object_pin(struct drm_gem_object *obj, uint32_t alignment) 4178 4178 { 4179 4179 struct drm_device *dev = obj->dev; 4180 4180 - struct drm_i915_gem_object *obj_priv = obj->driver_private; 4180 4180 + struct drm_i915_gem_object *obj_priv = to_intel_bo(obj); 4181 4181 int ret; 4182 4182 4183 4183 i915_verify_inactive(dev, __FILE__, __LINE__); ··· 4210 4210 { 4211 4211 struct drm_device *dev = obj->dev; 4212 4212 drm_i915_private_t *dev_priv = dev->dev_private; 4213 4213 - struct drm_i915_gem_object *obj_priv = obj->driver_private; 4213 4213 + struct drm_i915_gem_object *obj_priv = to_intel_bo(obj); 4214 4214 4215 4215 i915_verify_inactive(dev, __FILE__, __LINE__); 4216 4216 obj_priv->pin_count--; ··· 4250 4250 mutex_unlock(&dev->struct_mutex); 4251 4251 return -EBADF; 4252 4252 } 4253 4253 - obj_priv = obj->driver_private; 4253 4253 + obj_priv = to_intel_bo(obj); 4254 4254 4255 4255 if (obj_priv->madv != I915_MADV_WILLNEED) { 4256 4256 DRM_ERROR("Attempting to pin a purgeable buffer\n"); ··· 4307 4307 return -EBADF; 4308 4308 } 4309 4309 4310 4310 - obj_priv = obj->driver_private; 4310 4310 + obj_priv = to_intel_bo(obj); 4311 4311 if (obj_priv->pin_filp != file_priv) { 4312 4312 DRM_ERROR("Not pinned by caller in i915_gem_pin_ioctl(): %d\n", 4313 4313 args->handle); ··· 4349 4349 */ 4350 4350 i915_gem_retire_requests(dev); 4351 4351 4352 4352 - obj_priv = obj->driver_private; 4352 4352 + obj_priv = to_intel_bo(obj); 4353 4353 /* Don't count being on the flushing list against the object being 4354 4354 * done. Otherwise, a buffer left on the flushing list but not getting 4355 4355 * flushed (because nobody's flushing that domain) won't ever return ··· 4395 4395 } 4396 4396 4397 4397 mutex_lock(&dev->struct_mutex); 4398 4398 - obj_priv = obj->driver_private; 4398 4398 + obj_priv = to_intel_bo(obj); 4399 4399 4400 4400 if (obj_priv->pin_count) { 4401 4401 drm_gem_object_unreference(obj); ··· 4456 4456 void i915_gem_free_object(struct drm_gem_object *obj) 4457 4457 { 4458 4458 struct drm_device *dev = obj->dev; 4459 4459 - struct drm_i915_gem_object *obj_priv = obj->driver_private; 4459 4459 + struct drm_i915_gem_object *obj_priv = to_intel_bo(obj); 4460 4460 4461 4461 trace_i915_gem_object_destroy(obj); 4462 4462 ··· 4565 4565 DRM_ERROR("Failed to allocate status page\n"); 4566 4566 return -ENOMEM; 4567 4567 } 4568 4568 - obj_priv = obj->driver_private; 4568 4568 + obj_priv = to_intel_bo(obj); 4569 4569 obj_priv->agp_type = AGP_USER_CACHED_MEMORY; 4570 4570 4571 4571 ret = i915_gem_object_pin(obj, 4096); ··· 4609 4609 return; 4610 4610 4611 4611 obj = dev_priv->hws_obj; 4612 4612 - obj_priv = obj->driver_private; 4612 4612 + obj_priv = to_intel_bo(obj); 4613 4613 4614 4614 kunmap(obj_priv->pages[0]); 4615 4615 i915_gem_object_unpin(obj); ··· 4643 4643 i915_gem_cleanup_hws(dev); 4644 4644 return -ENOMEM; 4645 4645 } 4646 4646 - obj_priv = obj->driver_private; 4646 4646 + obj_priv = to_intel_bo(obj); 4647 4647 4648 4648 ret = i915_gem_object_pin(obj, 4096); 4649 4649 if (ret != 0) { ··· 4936 4936 int ret; 4937 4937 int page_count; 4938 4938 4939 4939 - obj_priv = obj->driver_private; 4939 4939 + obj_priv = to_intel_bo(obj); 4940 4940 if (!obj_priv->phys_obj) 4941 4941 return; 4942 4942 ··· 4975 4975 if (id > I915_MAX_PHYS_OBJECT) 4976 4976 return -EINVAL; 4977 4977 4978 4978 - obj_priv = obj->driver_private; 4978 4978 + obj_priv = to_intel_bo(obj); 4979 4979 4980 4980 if (obj_priv->phys_obj) { 4981 4981 if (obj_priv->phys_obj->id == id) ··· 5026 5026 struct drm_i915_gem_pwrite *args, 5027 5027 struct drm_file *file_priv) 5028 5028 { 5029 5029 - struct drm_i915_gem_object *obj_priv = obj->driver_private; 5029 5029 + struct drm_i915_gem_object *obj_priv = to_intel_bo(obj); 5030 5030 void *obj_addr; 5031 5031 int ret; 5032 5032 char __user *user_data;

+2 -2

drivers/gpu/drm/i915/i915_gem_debug.c

reviewed

··· 72 72 i915_gem_dump_object(struct drm_gem_object *obj, int len, 73 73 const char *where, uint32_t mark) 74 74 { 75 75 - struct drm_i915_gem_object *obj_priv = obj->driver_private; 75 75 + struct drm_i915_gem_object *obj_priv = to_intel_bo(obj); 76 76 int page; 77 77 78 78 DRM_INFO("%s: object at offset %08x\n", where, obj_priv->gtt_offset); ··· 137 137 i915_gem_object_check_coherency(struct drm_gem_object *obj, int handle) 138 138 { 139 139 struct drm_device *dev = obj->dev; 140 140 - struct drm_i915_gem_object *obj_priv = obj->driver_private; 140 140 + struct drm_i915_gem_object *obj_priv = to_intel_bo(obj); 141 141 int page; 142 142 uint32_t *gtt_mapping; 143 143 uint32_t *backing_map = NULL;

+5 -5

drivers/gpu/drm/i915/i915_gem_tiling.c

reviewed

··· 240 240 i915_gem_object_fence_offset_ok(struct drm_gem_object *obj, int tiling_mode) 241 241 { 242 242 struct drm_device *dev = obj->dev; 243 243 - struct drm_i915_gem_object *obj_priv = obj->driver_private; 243 243 + struct drm_i915_gem_object *obj_priv = to_intel_bo(obj); 244 244 245 245 if (obj_priv->gtt_space == NULL) 246 246 return true; ··· 280 280 obj = drm_gem_object_lookup(dev, file_priv, args->handle); 281 281 if (obj == NULL) 282 282 return -EINVAL; 283 283 - obj_priv = obj->driver_private; 283 283 + obj_priv = to_intel_bo(obj); 284 284 285 285 if (!i915_tiling_ok(dev, args->stride, obj->size, args->tiling_mode)) { 286 286 drm_gem_object_unreference_unlocked(obj); ··· 364 364 obj = drm_gem_object_lookup(dev, file_priv, args->handle); 365 365 if (obj == NULL) 366 366 return -EINVAL; 367 367 - obj_priv = obj->driver_private; 367 367 + obj_priv = to_intel_bo(obj); 368 368 369 369 mutex_lock(&dev->struct_mutex); 370 370 ··· 427 427 { 428 428 struct drm_device *dev = obj->dev; 429 429 drm_i915_private_t *dev_priv = dev->dev_private; 430 430 - struct drm_i915_gem_object *obj_priv = obj->driver_private; 430 430 + struct drm_i915_gem_object *obj_priv = to_intel_bo(obj); 431 431 int page_count = obj->size >> PAGE_SHIFT; 432 432 int i; 433 433 ··· 456 456 { 457 457 struct drm_device *dev = obj->dev; 458 458 drm_i915_private_t *dev_priv = dev->dev_private; 459 459 - struct drm_i915_gem_object *obj_priv = obj->driver_private; 459 459 + struct drm_i915_gem_object *obj_priv = to_intel_bo(obj); 460 460 int page_count = obj->size >> PAGE_SHIFT; 461 461 int i; 462 462

+4 -4

drivers/gpu/drm/i915/i915_irq.c

reviewed

··· 260 260 261 261 if (mode_config->num_connector) { 262 262 list_for_each_entry(connector, &mode_config->connector_list, head) { 263 263 - struct intel_output *intel_output = to_intel_output(connector); 263 263 + struct intel_encoder *intel_encoder = to_intel_encoder(connector); 264 264 265 265 - if (intel_output->hot_plug) 266 266 - (*intel_output->hot_plug) (intel_output); 265 265 + if (intel_encoder->hot_plug) 266 266 + (*intel_encoder->hot_plug) (intel_encoder); 267 267 } 268 268 } 269 269 /* Just fire off a uevent and let userspace tell us what to do */ ··· 444 444 if (src == NULL) 445 445 return NULL; 446 446 447 447 - src_priv = src->driver_private; 447 447 + src_priv = to_intel_bo(src); 448 448 if (src_priv->pages == NULL) 449 449 return NULL; 450 450

+34 -34

drivers/gpu/drm/i915/intel_crt.c

reviewed

··· 247 247 248 248 static bool intel_crt_detect_ddc(struct drm_connector *connector) 249 249 { 250 250 - struct intel_output *intel_output = to_intel_output(connector); 250 250 + struct intel_encoder *intel_encoder = to_intel_encoder(connector); 251 251 252 252 /* CRT should always be at 0, but check anyway */ 253 253 - if (intel_output->type != INTEL_OUTPUT_ANALOG) 253 253 + if (intel_encoder->type != INTEL_OUTPUT_ANALOG) 254 254 return false; 255 255 256 256 - return intel_ddc_probe(intel_output); 256 256 + return intel_ddc_probe(intel_encoder); 257 257 } 258 258 259 259 static enum drm_connector_status 260 260 - intel_crt_load_detect(struct drm_crtc *crtc, struct intel_output *intel_output) 260 260 + intel_crt_load_detect(struct drm_crtc *crtc, struct intel_encoder *intel_encoder) 261 261 { 262 262 - struct drm_encoder *encoder = &intel_output->enc; 262 262 + struct drm_encoder *encoder = &intel_encoder->enc; 263 263 struct drm_device *dev = encoder->dev; 264 264 struct drm_i915_private *dev_priv = dev->dev_private; 265 265 struct intel_crtc *intel_crtc = to_intel_crtc(crtc); ··· 387 387 static enum drm_connector_status intel_crt_detect(struct drm_connector *connector) 388 388 { 389 389 struct drm_device *dev = connector->dev; 390 390 - struct intel_output *intel_output = to_intel_output(connector); 391 391 - struct drm_encoder *encoder = &intel_output->enc; 390 390 + struct intel_encoder *intel_encoder = to_intel_encoder(connector); 391 391 + struct drm_encoder *encoder = &intel_encoder->enc; 392 392 struct drm_crtc *crtc; 393 393 int dpms_mode; 394 394 enum drm_connector_status status; ··· 405 405 406 406 /* for pre-945g platforms use load detect */ 407 407 if (encoder->crtc && encoder->crtc->enabled) { 408 408 - status = intel_crt_load_detect(encoder->crtc, intel_output); 408 408 + status = intel_crt_load_detect(encoder->crtc, intel_encoder); 409 409 } else { 410 410 - crtc = intel_get_load_detect_pipe(intel_output, 410 410 + crtc = intel_get_load_detect_pipe(intel_encoder, 411 411 NULL, &dpms_mode); 412 412 if (crtc) { 413 413 - status = intel_crt_load_detect(crtc, intel_output); 414 414 - intel_release_load_detect_pipe(intel_output, dpms_mode); 413 413 + status = intel_crt_load_detect(crtc, intel_encoder); 414 414 + intel_release_load_detect_pipe(intel_encoder, dpms_mode); 415 415 } else 416 416 status = connector_status_unknown; 417 417 } ··· 421 421 422 422 static void intel_crt_destroy(struct drm_connector *connector) 423 423 { 424 424 - struct intel_output *intel_output = to_intel_output(connector); 424 424 + struct intel_encoder *intel_encoder = to_intel_encoder(connector); 425 425 426 426 - intel_i2c_destroy(intel_output->ddc_bus); 426 426 + intel_i2c_destroy(intel_encoder->ddc_bus); 427 427 drm_sysfs_connector_remove(connector); 428 428 drm_connector_cleanup(connector); 429 429 kfree(connector); ··· 432 432 static int intel_crt_get_modes(struct drm_connector *connector) 433 433 { 434 434 int ret; 435 435 - struct intel_output *intel_output = to_intel_output(connector); 435 435 + struct intel_encoder *intel_encoder = to_intel_encoder(connector); 436 436 struct i2c_adapter *ddcbus; 437 437 struct drm_device *dev = connector->dev; 438 438 439 439 440 440 - ret = intel_ddc_get_modes(intel_output); 440 440 + ret = intel_ddc_get_modes(intel_encoder); 441 441 if (ret || !IS_G4X(dev)) 442 442 goto end; 443 443 444 444 - ddcbus = intel_output->ddc_bus; 444 444 + ddcbus = intel_encoder->ddc_bus; 445 445 /* Try to probe digital port for output in DVI-I -> VGA mode. */ 446 446 - intel_output->ddc_bus = 446 446 + intel_encoder->ddc_bus = 447 447 intel_i2c_create(connector->dev, GPIOD, "CRTDDC_D"); 448 448 449 449 - if (!intel_output->ddc_bus) { 450 450 - intel_output->ddc_bus = ddcbus; 449 449 + if (!intel_encoder->ddc_bus) { 450 450 + intel_encoder->ddc_bus = ddcbus; 451 451 dev_printk(KERN_ERR, &connector->dev->pdev->dev, 452 452 "DDC bus registration failed for CRTDDC_D.\n"); 453 453 goto end; 454 454 } 455 455 /* Try to get modes by GPIOD port */ 456 456 - ret = intel_ddc_get_modes(intel_output); 456 456 + ret = intel_ddc_get_modes(intel_encoder); 457 457 intel_i2c_destroy(ddcbus); 458 458 459 459 end: ··· 506 506 void intel_crt_init(struct drm_device *dev) 507 507 { 508 508 struct drm_connector *connector; 509 509 - struct intel_output *intel_output; 509 509 + struct intel_encoder *intel_encoder; 510 510 struct drm_i915_private *dev_priv = dev->dev_private; 511 511 u32 i2c_reg; 512 512 513 513 - intel_output = kzalloc(sizeof(struct intel_output), GFP_KERNEL); 514 514 - if (!intel_output) 513 513 + intel_encoder = kzalloc(sizeof(struct intel_encoder), GFP_KERNEL); 514 514 + if (!intel_encoder) 515 515 return; 516 516 517 517 - connector = &intel_output->base; 518 518 - drm_connector_init(dev, &intel_output->base, 517 517 + connector = &intel_encoder->base; 518 518 + drm_connector_init(dev, &intel_encoder->base, 519 519 &intel_crt_connector_funcs, DRM_MODE_CONNECTOR_VGA); 520 520 521 521 - drm_encoder_init(dev, &intel_output->enc, &intel_crt_enc_funcs, 521 521 + drm_encoder_init(dev, &intel_encoder->enc, &intel_crt_enc_funcs, 522 522 DRM_MODE_ENCODER_DAC); 523 523 524 524 - drm_mode_connector_attach_encoder(&intel_output->base, 525 525 - &intel_output->enc); 524 524 + drm_mode_connector_attach_encoder(&intel_encoder->base, 525 525 + &intel_encoder->enc); 526 526 527 527 /* Set up the DDC bus. */ 528 528 if (HAS_PCH_SPLIT(dev)) ··· 533 533 if (dev_priv->crt_ddc_bus != 0) 534 534 i2c_reg = dev_priv->crt_ddc_bus; 535 535 } 536 536 - intel_output->ddc_bus = intel_i2c_create(dev, i2c_reg, "CRTDDC_A"); 537 537 - if (!intel_output->ddc_bus) { 536 536 + intel_encoder->ddc_bus = intel_i2c_create(dev, i2c_reg, "CRTDDC_A"); 537 537 + if (!intel_encoder->ddc_bus) { 538 538 dev_printk(KERN_ERR, &dev->pdev->dev, "DDC bus registration " 539 539 "failed.\n"); 540 540 return; 541 541 } 542 542 543 543 - intel_output->type = INTEL_OUTPUT_ANALOG; 544 544 - intel_output->clone_mask = (1 << INTEL_SDVO_NON_TV_CLONE_BIT) | 543 543 + intel_encoder->type = INTEL_OUTPUT_ANALOG; 544 544 + intel_encoder->clone_mask = (1 << INTEL_SDVO_NON_TV_CLONE_BIT) | 545 545 (1 << INTEL_ANALOG_CLONE_BIT) | 546 546 (1 << INTEL_SDVO_LVDS_CLONE_BIT); 547 547 - intel_output->crtc_mask = (1 << 0) | (1 << 1); 547 547 + intel_encoder->crtc_mask = (1 << 0) | (1 << 1); 548 548 connector->interlace_allowed = 0; 549 549 connector->doublescan_allowed = 0; 550 550 551 551 - drm_encoder_helper_add(&intel_output->enc, &intel_crt_helper_funcs); 551 551 + drm_encoder_helper_add(&intel_encoder->enc, &intel_crt_helper_funcs); 552 552 drm_connector_helper_add(connector, &intel_crt_connector_helper_funcs); 553 553 554 554 drm_sysfs_connector_add(connector);

+48 -48

drivers/gpu/drm/i915/intel_display.c

reviewed

··· 747 747 list_for_each_entry(l_entry, &mode_config->connector_list, head) { 748 748 if (l_entry->encoder && 749 749 l_entry->encoder->crtc == crtc) { 750 750 - struct intel_output *intel_output = to_intel_output(l_entry); 751 751 - if (intel_output->type == type) 750 750 + struct intel_encoder *intel_encoder = to_intel_encoder(l_entry); 751 751 + if (intel_encoder->type == type) 752 752 return true; 753 753 } 754 754 } 755 755 return false; 756 756 } 757 757 758 758 - struct drm_connector * 759 759 - intel_pipe_get_output (struct drm_crtc *crtc) 758 758 + static struct drm_connector * 759 759 + intel_pipe_get_connector (struct drm_crtc *crtc) 760 760 { 761 761 struct drm_device *dev = crtc->dev; 762 762 struct drm_mode_config *mode_config = &dev->mode_config; ··· 1003 1003 struct drm_i915_private *dev_priv = dev->dev_private; 1004 1004 struct drm_framebuffer *fb = crtc->fb; 1005 1005 struct intel_framebuffer *intel_fb = to_intel_framebuffer(fb); 1006 1006 - struct drm_i915_gem_object *obj_priv = intel_fb->obj->driver_private; 1006 1006 + struct drm_i915_gem_object *obj_priv = to_intel_bo(intel_fb->obj); 1007 1007 struct intel_crtc *intel_crtc = to_intel_crtc(crtc); 1008 1008 int plane, i; 1009 1009 u32 fbc_ctl, fbc_ctl2; ··· 1080 1080 struct drm_i915_private *dev_priv = dev->dev_private; 1081 1081 struct drm_framebuffer *fb = crtc->fb; 1082 1082 struct intel_framebuffer *intel_fb = to_intel_framebuffer(fb); 1083 1083 - struct drm_i915_gem_object *obj_priv = intel_fb->obj->driver_private; 1083 1083 + struct drm_i915_gem_object *obj_priv = to_intel_bo(intel_fb->obj); 1084 1084 struct intel_crtc *intel_crtc = to_intel_crtc(crtc); 1085 1085 int plane = (intel_crtc->plane == 0 ? DPFC_CTL_PLANEA : 1086 1086 DPFC_CTL_PLANEB); ··· 1176 1176 return; 1177 1177 1178 1178 intel_fb = to_intel_framebuffer(fb); 1179 1179 - obj_priv = intel_fb->obj->driver_private; 1179 1179 + obj_priv = to_intel_bo(intel_fb->obj); 1180 1180 1181 1181 /* 1182 1182 * If FBC is already on, we just have to verify that we can ··· 1243 1243 static int 1244 1244 intel_pin_and_fence_fb_obj(struct drm_device *dev, struct drm_gem_object *obj) 1245 1245 { 1246 1246 - struct drm_i915_gem_object *obj_priv = obj->driver_private; 1246 1246 + struct drm_i915_gem_object *obj_priv = to_intel_bo(obj); 1247 1247 u32 alignment; 1248 1248 int ret; 1249 1249 ··· 1323 1323 1324 1324 intel_fb = to_intel_framebuffer(crtc->fb); 1325 1325 obj = intel_fb->obj; 1326 1326 - obj_priv = obj->driver_private; 1326 1326 + obj_priv = to_intel_bo(obj); 1327 1327 1328 1328 mutex_lock(&dev->struct_mutex); 1329 1329 ret = intel_pin_and_fence_fb_obj(dev, obj); ··· 1401 1401 1402 1402 if (old_fb) { 1403 1403 intel_fb = to_intel_framebuffer(old_fb); 1404 1404 - obj_priv = intel_fb->obj->driver_private; 1404 1404 + obj_priv = to_intel_bo(intel_fb->obj); 1405 1405 i915_gem_object_unpin(intel_fb->obj); 1406 1406 } 1407 1407 intel_increase_pllclock(crtc, true); ··· 2917 2917 int dspsize_reg = (plane == 0) ? DSPASIZE : DSPBSIZE; 2918 2918 int dsppos_reg = (plane == 0) ? DSPAPOS : DSPBPOS; 2919 2919 int pipesrc_reg = (pipe == 0) ? PIPEASRC : PIPEBSRC; 2920 2920 - int refclk, num_outputs = 0; 2920 2920 + int refclk, num_connectors = 0; 2921 2921 intel_clock_t clock, reduced_clock; 2922 2922 u32 dpll = 0, fp = 0, fp2 = 0, dspcntr, pipeconf; 2923 2923 bool ok, has_reduced_clock = false, is_sdvo = false, is_dvo = false; ··· 2943 2943 drm_vblank_pre_modeset(dev, pipe); 2944 2944 2945 2945 list_for_each_entry(connector, &mode_config->connector_list, head) { 2946 2946 - struct intel_output *intel_output = to_intel_output(connector); 2946 2946 + struct intel_encoder *intel_encoder = to_intel_encoder(connector); 2947 2947 2948 2948 if (!connector->encoder || connector->encoder->crtc != crtc) 2949 2949 continue; 2950 2950 2951 2951 - switch (intel_output->type) { 2951 2951 + switch (intel_encoder->type) { 2952 2952 case INTEL_OUTPUT_LVDS: 2953 2953 is_lvds = true; 2954 2954 break; 2955 2955 case INTEL_OUTPUT_SDVO: 2956 2956 case INTEL_OUTPUT_HDMI: 2957 2957 is_sdvo = true; 2958 2958 - if (intel_output->needs_tv_clock) 2958 2958 + if (intel_encoder->needs_tv_clock) 2959 2959 is_tv = true; 2960 2960 break; 2961 2961 case INTEL_OUTPUT_DVO: ··· 2975 2975 break; 2976 2976 } 2977 2977 2978 2978 - num_outputs++; 2978 2978 + num_connectors++; 2979 2979 } 2980 2980 2981 2981 - if (is_lvds && dev_priv->lvds_use_ssc && num_outputs < 2) { 2981 2981 + if (is_lvds && dev_priv->lvds_use_ssc && num_connectors < 2) { 2982 2982 refclk = dev_priv->lvds_ssc_freq * 1000; 2983 2983 DRM_DEBUG_KMS("using SSC reference clock of %d MHz\n", 2984 2984 refclk / 1000); ··· 3049 3049 if (is_edp) { 3050 3050 struct drm_connector *edp; 3051 3051 target_clock = mode->clock; 3052 3052 - edp = intel_pipe_get_output(crtc); 3053 3053 - intel_edp_link_config(to_intel_output(edp), 3052 3052 + edp = intel_pipe_get_connector(crtc); 3053 3053 + intel_edp_link_config(to_intel_encoder(edp), 3054 3054 &lane, &link_bw); 3055 3055 } else { 3056 3056 /* DP over FDI requires target mode clock ··· 3231 3231 /* XXX: just matching BIOS for now */ 3232 3232 /* dpll |= PLL_REF_INPUT_TVCLKINBC; */ 3233 3233 dpll |= 3; 3234 3234 - else if (is_lvds && dev_priv->lvds_use_ssc && num_outputs < 2) 3234 3234 + else if (is_lvds && dev_priv->lvds_use_ssc && num_connectors < 2) 3235 3235 dpll |= PLLB_REF_INPUT_SPREADSPECTRUMIN; 3236 3236 else 3237 3237 dpll |= PLL_REF_INPUT_DREFCLK; ··· 3511 3511 if (!bo) 3512 3512 return -ENOENT; 3513 3513 3514 3514 - obj_priv = bo->driver_private; 3514 3514 + obj_priv = to_intel_bo(bo); 3515 3515 3516 3516 if (bo->size < width * height * 4) { 3517 3517 DRM_ERROR("buffer is to small\n"); ··· 3655 3655 * detection. 3656 3656 * 3657 3657 * It will be up to the load-detect code to adjust the pipe as appropriate for 3658 3658 - * its requirements. The pipe will be connected to no other outputs. 3658 3658 + * its requirements. The pipe will be connected to no other encoders. 3659 3659 * 3660 3660 - * Currently this code will only succeed if there is a pipe with no outputs 3660 3660 + * Currently this code will only succeed if there is a pipe with no encoders 3661 3661 * configured for it. In the future, it could choose to temporarily disable 3662 3662 * some outputs to free up a pipe for its use. 3663 3663 * ··· 3670 3670 704, 832, 0, 480, 489, 491, 520, 0, DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_NVSYNC), 3671 3671 }; 3672 3672 3673 3673 - struct drm_crtc *intel_get_load_detect_pipe(struct intel_output *intel_output, 3673 3673 + struct drm_crtc *intel_get_load_detect_pipe(struct intel_encoder *intel_encoder, 3674 3674 struct drm_display_mode *mode, 3675 3675 int *dpms_mode) 3676 3676 { 3677 3677 struct intel_crtc *intel_crtc; 3678 3678 struct drm_crtc *possible_crtc; 3679 3679 struct drm_crtc *supported_crtc =NULL; 3680 3680 - struct drm_encoder *encoder = &intel_output->enc; 3680 3680 + struct drm_encoder *encoder = &intel_encoder->enc; 3681 3681 struct drm_crtc *crtc = NULL; 3682 3682 struct drm_device *dev = encoder->dev; 3683 3683 struct drm_encoder_helper_funcs *encoder_funcs = encoder->helper_private; ··· 3729 3729 } 3730 3730 3731 3731 encoder->crtc = crtc; 3732 3732 - intel_output->base.encoder = encoder; 3733 3733 - intel_output->load_detect_temp = true; 3732 3732 + intel_encoder->base.encoder = encoder; 3733 3733 + intel_encoder->load_detect_temp = true; 3734 3734 3735 3735 intel_crtc = to_intel_crtc(crtc); 3736 3736 *dpms_mode = intel_crtc->dpms_mode; ··· 3755 3755 return crtc; 3756 3756 } 3757 3757 3758 3758 - void intel_release_load_detect_pipe(struct intel_output *intel_output, int dpms_mode) 3758 3758 + void intel_release_load_detect_pipe(struct intel_encoder *intel_encoder, int dpms_mode) 3759 3759 { 3760 3760 - struct drm_encoder *encoder = &intel_output->enc; 3760 3760 + struct drm_encoder *encoder = &intel_encoder->enc; 3761 3761 struct drm_device *dev = encoder->dev; 3762 3762 struct drm_crtc *crtc = encoder->crtc; 3763 3763 struct drm_encoder_helper_funcs *encoder_funcs = encoder->helper_private; 3764 3764 struct drm_crtc_helper_funcs *crtc_funcs = crtc->helper_private; 3765 3765 3766 3766 - if (intel_output->load_detect_temp) { 3766 3766 + if (intel_encoder->load_detect_temp) { 3767 3767 encoder->crtc = NULL; 3768 3768 - intel_output->base.encoder = NULL; 3769 3769 - intel_output->load_detect_temp = false; 3768 3768 + intel_encoder->base.encoder = NULL; 3769 3769 + intel_encoder->load_detect_temp = false; 3770 3770 crtc->enabled = drm_helper_crtc_in_use(crtc); 3771 3771 drm_helper_disable_unused_functions(dev); 3772 3772 } 3773 3773 3774 3774 - /* Switch crtc and output back off if necessary */ 3774 3774 + /* Switch crtc and encoder back off if necessary */ 3775 3775 if (crtc->enabled && dpms_mode != DRM_MODE_DPMS_ON) { 3776 3776 if (encoder->crtc == crtc) 3777 3777 encoder_funcs->dpms(encoder, dpms_mode); ··· 4156 4156 work = intel_crtc->unpin_work; 4157 4157 if (work == NULL || !work->pending) { 4158 4158 if (work && !work->pending) { 4159 4159 - obj_priv = work->pending_flip_obj->driver_private; 4159 4159 + obj_priv = to_intel_bo(work->pending_flip_obj); 4160 4160 DRM_DEBUG_DRIVER("flip finish: %p (%d) not pending?\n", 4161 4161 obj_priv, 4162 4162 atomic_read(&obj_priv->pending_flip)); ··· 4181 4181 4182 4182 spin_unlock_irqrestore(&dev->event_lock, flags); 4183 4183 4184 4184 - obj_priv = work->pending_flip_obj->driver_private; 4184 4184 + obj_priv = to_intel_bo(work->pending_flip_obj); 4185 4185 4186 4186 /* Initial scanout buffer will have a 0 pending flip count */ 4187 4187 if ((atomic_read(&obj_priv->pending_flip) == 0) || ··· 4252 4252 ret = intel_pin_and_fence_fb_obj(dev, obj); 4253 4253 if (ret != 0) { 4254 4254 DRM_DEBUG_DRIVER("flip queue: %p pin & fence failed\n", 4255 4255 - obj->driver_private); 4255 4255 + to_intel_bo(obj)); 4256 4256 kfree(work); 4257 4257 intel_crtc->unpin_work = NULL; 4258 4258 mutex_unlock(&dev->struct_mutex); ··· 4266 4266 crtc->fb = fb; 4267 4267 i915_gem_object_flush_write_domain(obj); 4268 4268 drm_vblank_get(dev, intel_crtc->pipe); 4269 4269 - obj_priv = obj->driver_private; 4269 4269 + obj_priv = to_intel_bo(obj); 4270 4270 atomic_inc(&obj_priv->pending_flip); 4271 4271 work->pending_flip_obj = obj; 4272 4272 ··· 4399 4399 int entry = 0; 4400 4400 4401 4401 list_for_each_entry(connector, &dev->mode_config.connector_list, head) { 4402 4402 - struct intel_output *intel_output = to_intel_output(connector); 4403 4403 - if (type_mask & intel_output->clone_mask) 4402 4402 + struct intel_encoder *intel_encoder = to_intel_encoder(connector); 4403 4403 + if (type_mask & intel_encoder->clone_mask) 4404 4404 index_mask |= (1 << entry); 4405 4405 entry++; 4406 4406 } ··· 4495 4495 intel_tv_init(dev); 4496 4496 4497 4497 list_for_each_entry(connector, &dev->mode_config.connector_list, head) { 4498 4498 - struct intel_output *intel_output = to_intel_output(connector); 4499 4499 - struct drm_encoder *encoder = &intel_output->enc; 4498 4498 + struct intel_encoder *intel_encoder = to_intel_encoder(connector); 4499 4499 + struct drm_encoder *encoder = &intel_encoder->enc; 4500 4500 4501 4501 - encoder->possible_crtcs = intel_output->crtc_mask; 4501 4501 + encoder->possible_crtcs = intel_encoder->crtc_mask; 4502 4502 encoder->possible_clones = intel_connector_clones(dev, 4503 4503 - intel_output->clone_mask); 4503 4503 + intel_encoder->clone_mask); 4504 4504 } 4505 4505 } 4506 4506 ··· 4779 4779 struct drm_i915_gem_object *obj_priv = NULL; 4780 4780 4781 4781 if (dev_priv->pwrctx) { 4782 4782 - obj_priv = dev_priv->pwrctx->driver_private; 4782 4782 + obj_priv = to_intel_bo(dev_priv->pwrctx); 4783 4783 } else { 4784 4784 struct drm_gem_object *pwrctx; 4785 4785 4786 4786 pwrctx = intel_alloc_power_context(dev); 4787 4787 if (pwrctx) { 4788 4788 dev_priv->pwrctx = pwrctx; 4789 4789 - obj_priv = pwrctx->driver_private; 4789 4789 + obj_priv = to_intel_bo(pwrctx); 4790 4790 } 4791 4791 } 4792 4792 ··· 4815 4815 dev_priv->display.fbc_enabled = g4x_fbc_enabled; 4816 4816 dev_priv->display.enable_fbc = g4x_enable_fbc; 4817 4817 dev_priv->display.disable_fbc = g4x_disable_fbc; 4818 4818 - } else if (IS_I965GM(dev) || IS_I945GM(dev) || IS_I915GM(dev)) { 4818 4818 + } else if (IS_I965GM(dev)) { 4819 4819 dev_priv->display.fbc_enabled = i8xx_fbc_enabled; 4820 4820 dev_priv->display.enable_fbc = i8xx_enable_fbc; 4821 4821 dev_priv->display.disable_fbc = i8xx_disable_fbc; ··· 4957 4957 if (dev_priv->pwrctx) { 4958 4958 struct drm_i915_gem_object *obj_priv; 4959 4959 4960 4960 - obj_priv = dev_priv->pwrctx->driver_private; 4960 4960 + obj_priv = to_intel_bo(dev_priv->pwrctx); 4961 4961 I915_WRITE(PWRCTXA, obj_priv->gtt_offset &~ PWRCTX_EN); 4962 4962 I915_READ(PWRCTXA); 4963 4963 i915_gem_object_unpin(dev_priv->pwrctx); ··· 4978 4978 */ 4979 4979 struct drm_encoder *intel_best_encoder(struct drm_connector *connector) 4980 4980 { 4981 4981 - struct intel_output *intel_output = to_intel_output(connector); 4981 4981 + struct intel_encoder *intel_encoder = to_intel_encoder(connector); 4982 4982 4983 4983 - return &intel_output->enc; 4983 4983 + return &intel_encoder->enc; 4984 4984 } 4985 4985 4986 4986 /*

+128 -128

drivers/gpu/drm/i915/intel_dp.c

reviewed

··· 55 55 uint8_t link_bw; 56 56 uint8_t lane_count; 57 57 uint8_t dpcd[4]; 58 58 - struct intel_output *intel_output; 58 58 + struct intel_encoder *intel_encoder; 59 59 struct i2c_adapter adapter; 60 60 struct i2c_algo_dp_aux_data algo; 61 61 }; 62 62 63 63 static void 64 64 - intel_dp_link_train(struct intel_output *intel_output, uint32_t DP, 64 64 + intel_dp_link_train(struct intel_encoder *intel_encoder, uint32_t DP, 65 65 uint8_t link_configuration[DP_LINK_CONFIGURATION_SIZE]); 66 66 67 67 static void 68 68 - intel_dp_link_down(struct intel_output *intel_output, uint32_t DP); 68 68 + intel_dp_link_down(struct intel_encoder *intel_encoder, uint32_t DP); 69 69 70 70 void 71 71 - intel_edp_link_config (struct intel_output *intel_output, 71 71 + intel_edp_link_config (struct intel_encoder *intel_encoder, 72 72 int *lane_num, int *link_bw) 73 73 { 74 74 - struct intel_dp_priv *dp_priv = intel_output->dev_priv; 74 74 + struct intel_dp_priv *dp_priv = intel_encoder->dev_priv; 75 75 76 76 *lane_num = dp_priv->lane_count; 77 77 if (dp_priv->link_bw == DP_LINK_BW_1_62) ··· 81 81 } 82 82 83 83 static int 84 84 - intel_dp_max_lane_count(struct intel_output *intel_output) 84 84 + intel_dp_max_lane_count(struct intel_encoder *intel_encoder) 85 85 { 86 86 - struct intel_dp_priv *dp_priv = intel_output->dev_priv; 86 86 + struct intel_dp_priv *dp_priv = intel_encoder->dev_priv; 87 87 int max_lane_count = 4; 88 88 89 89 if (dp_priv->dpcd[0] >= 0x11) { ··· 99 99 } 100 100 101 101 static int 102 102 - intel_dp_max_link_bw(struct intel_output *intel_output) 102 102 + intel_dp_max_link_bw(struct intel_encoder *intel_encoder) 103 103 { 104 104 - struct intel_dp_priv *dp_priv = intel_output->dev_priv; 104 104 + struct intel_dp_priv *dp_priv = intel_encoder->dev_priv; 105 105 int max_link_bw = dp_priv->dpcd[1]; 106 106 107 107 switch (max_link_bw) { ··· 127 127 /* I think this is a fiction */ 128 128 static int 129 129 intel_dp_link_required(struct drm_device *dev, 130 130 - struct intel_output *intel_output, int pixel_clock) 130 130 + struct intel_encoder *intel_encoder, int pixel_clock) 131 131 { 132 132 struct drm_i915_private *dev_priv = dev->dev_private; 133 133 134 134 - if (IS_eDP(intel_output)) 134 134 + if (IS_eDP(intel_encoder)) 135 135 return (pixel_clock * dev_priv->edp_bpp) / 8; 136 136 else 137 137 return pixel_clock * 3; ··· 141 141 intel_dp_mode_valid(struct drm_connector *connector, 142 142 struct drm_display_mode *mode) 143 143 { 144 144 - struct intel_output *intel_output = to_intel_output(connector); 145 145 - int max_link_clock = intel_dp_link_clock(intel_dp_max_link_bw(intel_output)); 146 146 - int max_lanes = intel_dp_max_lane_count(intel_output); 144 144 + struct intel_encoder *intel_encoder = to_intel_encoder(connector); 145 145 + int max_link_clock = intel_dp_link_clock(intel_dp_max_link_bw(intel_encoder)); 146 146 + int max_lanes = intel_dp_max_lane_count(intel_encoder); 147 147 148 148 - if (intel_dp_link_required(connector->dev, intel_output, mode->clock) 148 148 + if (intel_dp_link_required(connector->dev, intel_encoder, mode->clock) 149 149 > max_link_clock * max_lanes) 150 150 return MODE_CLOCK_HIGH; 151 151 ··· 209 209 } 210 210 211 211 static int 212 212 - intel_dp_aux_ch(struct intel_output *intel_output, 212 212 + intel_dp_aux_ch(struct intel_encoder *intel_encoder, 213 213 uint8_t *send, int send_bytes, 214 214 uint8_t *recv, int recv_size) 215 215 { 216 216 - struct intel_dp_priv *dp_priv = intel_output->dev_priv; 216 216 + struct intel_dp_priv *dp_priv = intel_encoder->dev_priv; 217 217 uint32_t output_reg = dp_priv->output_reg; 218 218 - struct drm_device *dev = intel_output->base.dev; 218 218 + struct drm_device *dev = intel_encoder->base.dev; 219 219 struct drm_i915_private *dev_priv = dev->dev_private; 220 220 uint32_t ch_ctl = output_reg + 0x10; 221 221 uint32_t ch_data = ch_ctl + 4; ··· 230 230 * and would like to run at 2MHz. So, take the 231 231 * hrawclk value and divide by 2 and use that 232 232 */ 233 233 - if (IS_eDP(intel_output)) 233 233 + if (IS_eDP(intel_encoder)) 234 234 aux_clock_divider = 225; /* eDP input clock at 450Mhz */ 235 235 else if (HAS_PCH_SPLIT(dev)) 236 236 aux_clock_divider = 62; /* IRL input clock fixed at 125Mhz */ ··· 313 313 314 314 /* Write data to the aux channel in native mode */ 315 315 static int 316 316 - intel_dp_aux_native_write(struct intel_output *intel_output, 316 316 + intel_dp_aux_native_write(struct intel_encoder *intel_encoder, 317 317 uint16_t address, uint8_t *send, int send_bytes) 318 318 { 319 319 int ret; ··· 330 330 memcpy(&msg[4], send, send_bytes); 331 331 msg_bytes = send_bytes + 4; 332 332 for (;;) { 333 333 - ret = intel_dp_aux_ch(intel_output, msg, msg_bytes, &ack, 1); 333 333 + ret = intel_dp_aux_ch(intel_encoder, msg, msg_bytes, &ack, 1); 334 334 if (ret < 0) 335 335 return ret; 336 336 if ((ack & AUX_NATIVE_REPLY_MASK) == AUX_NATIVE_REPLY_ACK) ··· 345 345 346 346 /* Write a single byte to the aux channel in native mode */ 347 347 static int 348 348 - intel_dp_aux_native_write_1(struct intel_output *intel_output, 348 348 + intel_dp_aux_native_write_1(struct intel_encoder *intel_encoder, 349 349 uint16_t address, uint8_t byte) 350 350 { 351 351 - return intel_dp_aux_native_write(intel_output, address, &byte, 1); 351 351 + return intel_dp_aux_native_write(intel_encoder, address, &byte, 1); 352 352 } 353 353 354 354 /* read bytes from a native aux channel */ 355 355 static int 356 356 - intel_dp_aux_native_read(struct intel_output *intel_output, 356 356 + intel_dp_aux_native_read(struct intel_encoder *intel_encoder, 357 357 uint16_t address, uint8_t *recv, int recv_bytes) 358 358 { 359 359 uint8_t msg[4]; ··· 372 372 reply_bytes = recv_bytes + 1; 373 373 374 374 for (;;) { 375 375 - ret = intel_dp_aux_ch(intel_output, msg, msg_bytes, 375 375 + ret = intel_dp_aux_ch(intel_encoder, msg, msg_bytes, 376 376 reply, reply_bytes); 377 377 if (ret == 0) 378 378 return -EPROTO; ··· 398 398 struct intel_dp_priv *dp_priv = container_of(adapter, 399 399 struct intel_dp_priv, 400 400 adapter); 401 401 - struct intel_output *intel_output = dp_priv->intel_output; 401 401 + struct intel_encoder *intel_encoder = dp_priv->intel_encoder; 402 402 uint16_t address = algo_data->address; 403 403 uint8_t msg[5]; 404 404 uint8_t reply[2]; ··· 437 437 } 438 438 439 439 for (;;) { 440 440 - ret = intel_dp_aux_ch(intel_output, 440 440 + ret = intel_dp_aux_ch(intel_encoder, 441 441 msg, msg_bytes, 442 442 reply, reply_bytes); 443 443 if (ret < 0) { ··· 465 465 } 466 466 467 467 static int 468 468 - intel_dp_i2c_init(struct intel_output *intel_output, const char *name) 468 468 + intel_dp_i2c_init(struct intel_encoder *intel_encoder, const char *name) 469 469 { 470 470 - struct intel_dp_priv *dp_priv = intel_output->dev_priv; 470 470 + struct intel_dp_priv *dp_priv = intel_encoder->dev_priv; 471 471 472 472 DRM_DEBUG_KMS("i2c_init %s\n", name); 473 473 dp_priv->algo.running = false; ··· 480 480 strncpy (dp_priv->adapter.name, name, sizeof(dp_priv->adapter.name) - 1); 481 481 dp_priv->adapter.name[sizeof(dp_priv->adapter.name) - 1] = '\0'; 482 482 dp_priv->adapter.algo_data = &dp_priv->algo; 483 483 - dp_priv->adapter.dev.parent = &intel_output->base.kdev; 483 483 + dp_priv->adapter.dev.parent = &intel_encoder->base.kdev; 484 484 485 485 return i2c_dp_aux_add_bus(&dp_priv->adapter); 486 486 } ··· 489 489 intel_dp_mode_fixup(struct drm_encoder *encoder, struct drm_display_mode *mode, 490 490 struct drm_display_mode *adjusted_mode) 491 491 { 492 492 - struct intel_output *intel_output = enc_to_intel_output(encoder); 493 493 - struct intel_dp_priv *dp_priv = intel_output->dev_priv; 492 492 + struct intel_encoder *intel_encoder = enc_to_intel_encoder(encoder); 493 493 + struct intel_dp_priv *dp_priv = intel_encoder->dev_priv; 494 494 int lane_count, clock; 495 495 - int max_lane_count = intel_dp_max_lane_count(intel_output); 496 496 - int max_clock = intel_dp_max_link_bw(intel_output) == DP_LINK_BW_2_7 ? 1 : 0; 495 495 + int max_lane_count = intel_dp_max_lane_count(intel_encoder); 496 496 + int max_clock = intel_dp_max_link_bw(intel_encoder) == DP_LINK_BW_2_7 ? 1 : 0; 497 497 static int bws[2] = { DP_LINK_BW_1_62, DP_LINK_BW_2_7 }; 498 498 499 499 for (lane_count = 1; lane_count <= max_lane_count; lane_count <<= 1) { 500 500 for (clock = 0; clock <= max_clock; clock++) { 501 501 int link_avail = intel_dp_link_clock(bws[clock]) * lane_count; 502 502 503 503 - if (intel_dp_link_required(encoder->dev, intel_output, mode->clock) 503 503 + if (intel_dp_link_required(encoder->dev, intel_encoder, mode->clock) 504 504 <= link_avail) { 505 505 dp_priv->link_bw = bws[clock]; 506 506 dp_priv->lane_count = lane_count; ··· 562 562 struct intel_dp_m_n m_n; 563 563 564 564 /* 565 565 - * Find the lane count in the intel_output private 565 565 + * Find the lane count in the intel_encoder private 566 566 */ 567 567 list_for_each_entry(connector, &mode_config->connector_list, head) { 568 568 - struct intel_output *intel_output = to_intel_output(connector); 569 569 - struct intel_dp_priv *dp_priv = intel_output->dev_priv; 568 568 + struct intel_encoder *intel_encoder = to_intel_encoder(connector); 569 569 + struct intel_dp_priv *dp_priv = intel_encoder->dev_priv; 570 570 571 571 if (!connector->encoder || connector->encoder->crtc != crtc) 572 572 continue; 573 573 574 574 - if (intel_output->type == INTEL_OUTPUT_DISPLAYPORT) { 574 574 + if (intel_encoder->type == INTEL_OUTPUT_DISPLAYPORT) { 575 575 lane_count = dp_priv->lane_count; 576 576 break; 577 577 } ··· 626 626 intel_dp_mode_set(struct drm_encoder *encoder, struct drm_display_mode *mode, 627 627 struct drm_display_mode *adjusted_mode) 628 628 { 629 629 - struct intel_output *intel_output = enc_to_intel_output(encoder); 630 630 - struct intel_dp_priv *dp_priv = intel_output->dev_priv; 631 631 - struct drm_crtc *crtc = intel_output->enc.crtc; 629 629 + struct intel_encoder *intel_encoder = enc_to_intel_encoder(encoder); 630 630 + struct intel_dp_priv *dp_priv = intel_encoder->dev_priv; 631 631 + struct drm_crtc *crtc = intel_encoder->enc.crtc; 632 632 struct intel_crtc *intel_crtc = to_intel_crtc(crtc); 633 633 634 634 dp_priv->DP = (DP_LINK_TRAIN_OFF | ··· 667 667 if (intel_crtc->pipe == 1) 668 668 dp_priv->DP |= DP_PIPEB_SELECT; 669 669 670 670 - if (IS_eDP(intel_output)) { 670 670 + if (IS_eDP(intel_encoder)) { 671 671 /* don't miss out required setting for eDP */ 672 672 dp_priv->DP |= DP_PLL_ENABLE; 673 673 if (adjusted_mode->clock < 200000) ··· 702 702 static void 703 703 intel_dp_dpms(struct drm_encoder *encoder, int mode) 704 704 { 705 705 - struct intel_output *intel_output = enc_to_intel_output(encoder); 706 706 - struct intel_dp_priv *dp_priv = intel_output->dev_priv; 707 707 - struct drm_device *dev = intel_output->base.dev; 705 705 + struct intel_encoder *intel_encoder = enc_to_intel_encoder(encoder); 706 706 + struct intel_dp_priv *dp_priv = intel_encoder->dev_priv; 707 707 + struct drm_device *dev = intel_encoder->base.dev; 708 708 struct drm_i915_private *dev_priv = dev->dev_private; 709 709 uint32_t dp_reg = I915_READ(dp_priv->output_reg); 710 710 711 711 if (mode != DRM_MODE_DPMS_ON) { 712 712 if (dp_reg & DP_PORT_EN) { 713 713 - intel_dp_link_down(intel_output, dp_priv->DP); 714 714 - if (IS_eDP(intel_output)) 713 713 + intel_dp_link_down(intel_encoder, dp_priv->DP); 714 714 + if (IS_eDP(intel_encoder)) 715 715 ironlake_edp_backlight_off(dev); 716 716 } 717 717 } else { 718 718 if (!(dp_reg & DP_PORT_EN)) { 719 719 - intel_dp_link_train(intel_output, dp_priv->DP, dp_priv->link_configuration); 720 720 - if (IS_eDP(intel_output)) 719 719 + intel_dp_link_train(intel_encoder, dp_priv->DP, dp_priv->link_configuration); 720 720 + if (IS_eDP(intel_encoder)) 721 721 ironlake_edp_backlight_on(dev); 722 722 } 723 723 } ··· 729 729 * link status information 730 730 */ 731 731 static bool 732 732 - intel_dp_get_link_status(struct intel_output *intel_output, 732 732 + intel_dp_get_link_status(struct intel_encoder *intel_encoder, 733 733 uint8_t link_status[DP_LINK_STATUS_SIZE]) 734 734 { 735 735 int ret; 736 736 737 737 - ret = intel_dp_aux_native_read(intel_output, 737 737 + ret = intel_dp_aux_native_read(intel_encoder, 738 738 DP_LANE0_1_STATUS, 739 739 link_status, DP_LINK_STATUS_SIZE); 740 740 if (ret != DP_LINK_STATUS_SIZE) ··· 752 752 static void 753 753 intel_dp_save(struct drm_connector *connector) 754 754 { 755 755 - struct intel_output *intel_output = to_intel_output(connector); 756 756 - struct drm_device *dev = intel_output->base.dev; 755 755 + struct intel_encoder *intel_encoder = to_intel_encoder(connector); 756 756 + struct drm_device *dev = intel_encoder->base.dev; 757 757 struct drm_i915_private *dev_priv = dev->dev_private; 758 758 - struct intel_dp_priv *dp_priv = intel_output->dev_priv; 758 758 + struct intel_dp_priv *dp_priv = intel_encoder->dev_priv; 759 759 760 760 dp_priv->save_DP = I915_READ(dp_priv->output_reg); 761 761 - intel_dp_aux_native_read(intel_output, DP_LINK_BW_SET, 761 761 + intel_dp_aux_native_read(intel_encoder, DP_LINK_BW_SET, 762 762 dp_priv->save_link_configuration, 763 763 sizeof (dp_priv->save_link_configuration)); 764 764 } ··· 825 825 } 826 826 827 827 static void 828 828 - intel_get_adjust_train(struct intel_output *intel_output, 828 828 + intel_get_adjust_train(struct intel_encoder *intel_encoder, 829 829 uint8_t link_status[DP_LINK_STATUS_SIZE], 830 830 int lane_count, 831 831 uint8_t train_set[4]) ··· 942 942 } 943 943 944 944 static bool 945 945 - intel_dp_set_link_train(struct intel_output *intel_output, 945 945 + intel_dp_set_link_train(struct intel_encoder *intel_encoder, 946 946 uint32_t dp_reg_value, 947 947 uint8_t dp_train_pat, 948 948 uint8_t train_set[4], 949 949 bool first) 950 950 { 951 951 - struct drm_device *dev = intel_output->base.dev; 951 951 + struct drm_device *dev = intel_encoder->base.dev; 952 952 struct drm_i915_private *dev_priv = dev->dev_private; 953 953 - struct intel_dp_priv *dp_priv = intel_output->dev_priv; 953 953 + struct intel_dp_priv *dp_priv = intel_encoder->dev_priv; 954 954 int ret; 955 955 956 956 I915_WRITE(dp_priv->output_reg, dp_reg_value); ··· 958 958 if (first) 959 959 intel_wait_for_vblank(dev); 960 960 961 961 - intel_dp_aux_native_write_1(intel_output, 961 961 + intel_dp_aux_native_write_1(intel_encoder, 962 962 DP_TRAINING_PATTERN_SET, 963 963 dp_train_pat); 964 964 965 965 - ret = intel_dp_aux_native_write(intel_output, 965 965 + ret = intel_dp_aux_native_write(intel_encoder, 966 966 DP_TRAINING_LANE0_SET, train_set, 4); 967 967 if (ret != 4) 968 968 return false; ··· 971 971 } 972 972 973 973 static void 974 974 - intel_dp_link_train(struct intel_output *intel_output, uint32_t DP, 974 974 + intel_dp_link_train(struct intel_encoder *intel_encoder, uint32_t DP, 975 975 uint8_t link_configuration[DP_LINK_CONFIGURATION_SIZE]) 976 976 { 977 977 - struct drm_device *dev = intel_output->base.dev; 977 977 + struct drm_device *dev = intel_encoder->base.dev; 978 978 struct drm_i915_private *dev_priv = dev->dev_private; 979 979 - struct intel_dp_priv *dp_priv = intel_output->dev_priv; 979 979 + struct intel_dp_priv *dp_priv = intel_encoder->dev_priv; 980 980 uint8_t train_set[4]; 981 981 uint8_t link_status[DP_LINK_STATUS_SIZE]; 982 982 int i; ··· 987 987 int tries; 988 988 989 989 /* Write the link configuration data */ 990 990 - intel_dp_aux_native_write(intel_output, 0x100, 990 990 + intel_dp_aux_native_write(intel_encoder, 0x100, 991 991 link_configuration, DP_LINK_CONFIGURATION_SIZE); 992 992 993 993 DP |= DP_PORT_EN; ··· 1001 1001 uint32_t signal_levels = intel_dp_signal_levels(train_set[0], dp_priv->lane_count); 1002 1002 DP = (DP & ~(DP_VOLTAGE_MASK|DP_PRE_EMPHASIS_MASK)) | signal_levels; 1003 1003 1004 1004 - if (!intel_dp_set_link_train(intel_output, DP | DP_LINK_TRAIN_PAT_1, 1004 1004 + if (!intel_dp_set_link_train(intel_encoder, DP | DP_LINK_TRAIN_PAT_1, 1005 1005 DP_TRAINING_PATTERN_1, train_set, first)) 1006 1006 break; 1007 1007 first = false; 1008 1008 /* Set training pattern 1 */ 1009 1009 1010 1010 udelay(100); 1011 1011 - if (!intel_dp_get_link_status(intel_output, link_status)) 1011 1011 + if (!intel_dp_get_link_status(intel_encoder, link_status)) 1012 1012 break; 1013 1013 1014 1014 if (intel_clock_recovery_ok(link_status, dp_priv->lane_count)) { ··· 1033 1033 voltage = train_set[0] & DP_TRAIN_VOLTAGE_SWING_MASK; 1034 1034 1035 1035 /* Compute new train_set as requested by target */ 1036 1036 - intel_get_adjust_train(intel_output, link_status, dp_priv->lane_count, train_set); 1036 1036 + intel_get_adjust_train(intel_encoder, link_status, dp_priv->lane_count, train_set); 1037 1037 } 1038 1038 1039 1039 /* channel equalization */ ··· 1045 1045 DP = (DP & ~(DP_VOLTAGE_MASK|DP_PRE_EMPHASIS_MASK)) | signal_levels; 1046 1046 1047 1047 /* channel eq pattern */ 1048 1048 - if (!intel_dp_set_link_train(intel_output, DP | DP_LINK_TRAIN_PAT_2, 1048 1048 + if (!intel_dp_set_link_train(intel_encoder, DP | DP_LINK_TRAIN_PAT_2, 1049 1049 DP_TRAINING_PATTERN_2, train_set, 1050 1050 false)) 1051 1051 break; 1052 1052 1053 1053 udelay(400); 1054 1054 - if (!intel_dp_get_link_status(intel_output, link_status)) 1054 1054 + if (!intel_dp_get_link_status(intel_encoder, link_status)) 1055 1055 break; 1056 1056 1057 1057 if (intel_channel_eq_ok(link_status, dp_priv->lane_count)) { ··· 1064 1064 break; 1065 1065 1066 1066 /* Compute new train_set as requested by target */ 1067 1067 - intel_get_adjust_train(intel_output, link_status, dp_priv->lane_count, train_set); 1067 1067 + intel_get_adjust_train(intel_encoder, link_status, dp_priv->lane_count, train_set); 1068 1068 ++tries; 1069 1069 } 1070 1070 1071 1071 I915_WRITE(dp_priv->output_reg, DP | DP_LINK_TRAIN_OFF); 1072 1072 POSTING_READ(dp_priv->output_reg); 1073 1073 - intel_dp_aux_native_write_1(intel_output, 1073 1073 + intel_dp_aux_native_write_1(intel_encoder, 1074 1074 DP_TRAINING_PATTERN_SET, DP_TRAINING_PATTERN_DISABLE); 1075 1075 } 1076 1076 1077 1077 static void 1078 1078 - intel_dp_link_down(struct intel_output *intel_output, uint32_t DP) 1078 1078 + intel_dp_link_down(struct intel_encoder *intel_encoder, uint32_t DP) 1079 1079 { 1080 1080 - struct drm_device *dev = intel_output->base.dev; 1080 1080 + struct drm_device *dev = intel_encoder->base.dev; 1081 1081 struct drm_i915_private *dev_priv = dev->dev_private; 1082 1082 - struct intel_dp_priv *dp_priv = intel_output->dev_priv; 1082 1082 + struct intel_dp_priv *dp_priv = intel_encoder->dev_priv; 1083 1083 1084 1084 DRM_DEBUG_KMS("\n"); 1085 1085 1086 1086 - if (IS_eDP(intel_output)) { 1086 1086 + if (IS_eDP(intel_encoder)) { 1087 1087 DP &= ~DP_PLL_ENABLE; 1088 1088 I915_WRITE(dp_priv->output_reg, DP); 1089 1089 POSTING_READ(dp_priv->output_reg); ··· 1096 1096 1097 1097 udelay(17000); 1098 1098 1099 1099 - if (IS_eDP(intel_output)) 1099 1099 + if (IS_eDP(intel_encoder)) 1100 1100 DP |= DP_LINK_TRAIN_OFF; 1101 1101 I915_WRITE(dp_priv->output_reg, DP & ~DP_PORT_EN); 1102 1102 POSTING_READ(dp_priv->output_reg); ··· 1105 1105 static void 1106 1106 intel_dp_restore(struct drm_connector *connector) 1107 1107 { 1108 1108 - struct intel_output *intel_output = to_intel_output(connector); 1109 1109 - struct intel_dp_priv *dp_priv = intel_output->dev_priv; 1108 1108 + struct intel_encoder *intel_encoder = to_intel_encoder(connector); 1109 1109 + struct intel_dp_priv *dp_priv = intel_encoder->dev_priv; 1110 1110 1111 1111 if (dp_priv->save_DP & DP_PORT_EN) 1112 1112 - intel_dp_link_train(intel_output, dp_priv->save_DP, dp_priv->save_link_configuration); 1112 1112 + intel_dp_link_train(intel_encoder, dp_priv->save_DP, dp_priv->save_link_configuration); 1113 1113 else 1114 1114 - intel_dp_link_down(intel_output, dp_priv->save_DP); 1114 1114 + intel_dp_link_down(intel_encoder, dp_priv->save_DP); 1115 1115 } 1116 1116 1117 1117 /* ··· 1124 1124 */ 1125 1125 1126 1126 static void 1127 1127 - intel_dp_check_link_status(struct intel_output *intel_output) 1127 1127 + intel_dp_check_link_status(struct intel_encoder *intel_encoder) 1128 1128 { 1129 1129 - struct intel_dp_priv *dp_priv = intel_output->dev_priv; 1129 1129 + struct intel_dp_priv *dp_priv = intel_encoder->dev_priv; 1130 1130 uint8_t link_status[DP_LINK_STATUS_SIZE]; 1131 1131 1132 1132 - if (!intel_output->enc.crtc) 1132 1132 + if (!intel_encoder->enc.crtc) 1133 1133 return; 1134 1134 1135 1135 - if (!intel_dp_get_link_status(intel_output, link_status)) { 1136 1136 - intel_dp_link_down(intel_output, dp_priv->DP); 1135 1135 + if (!intel_dp_get_link_status(intel_encoder, link_status)) { 1136 1136 + intel_dp_link_down(intel_encoder, dp_priv->DP); 1137 1137 return; 1138 1138 } 1139 1139 1140 1140 if (!intel_channel_eq_ok(link_status, dp_priv->lane_count)) 1141 1141 - intel_dp_link_train(intel_output, dp_priv->DP, dp_priv->link_configuration); 1141 1141 + intel_dp_link_train(intel_encoder, dp_priv->DP, dp_priv->link_configuration); 1142 1142 } 1143 1143 1144 1144 static enum drm_connector_status 1145 1145 ironlake_dp_detect(struct drm_connector *connector) 1146 1146 { 1147 1147 - struct intel_output *intel_output = to_intel_output(connector); 1148 1148 - struct intel_dp_priv *dp_priv = intel_output->dev_priv; 1147 1147 + struct intel_encoder *intel_encoder = to_intel_encoder(connector); 1148 1148 + struct intel_dp_priv *dp_priv = intel_encoder->dev_priv; 1149 1149 enum drm_connector_status status; 1150 1150 1151 1151 status = connector_status_disconnected; 1152 1152 - if (intel_dp_aux_native_read(intel_output, 1152 1152 + if (intel_dp_aux_native_read(intel_encoder, 1153 1153 0x000, dp_priv->dpcd, 1154 1154 sizeof (dp_priv->dpcd)) == sizeof (dp_priv->dpcd)) 1155 1155 { ··· 1168 1168 static enum drm_connector_status 1169 1169 intel_dp_detect(struct drm_connector *connector) 1170 1170 { 1171 1171 - struct intel_output *intel_output = to_intel_output(connector); 1172 1172 - struct drm_device *dev = intel_output->base.dev; 1171 1171 + struct intel_encoder *intel_encoder = to_intel_encoder(connector); 1172 1172 + struct drm_device *dev = intel_encoder->base.dev; 1173 1173 struct drm_i915_private *dev_priv = dev->dev_private; 1174 1174 - struct intel_dp_priv *dp_priv = intel_output->dev_priv; 1174 1174 + struct intel_dp_priv *dp_priv = intel_encoder->dev_priv; 1175 1175 uint32_t temp, bit; 1176 1176 enum drm_connector_status status; 1177 1177 ··· 1210 1210 return connector_status_disconnected; 1211 1211 1212 1212 status = connector_status_disconnected; 1213 1213 - if (intel_dp_aux_native_read(intel_output, 1213 1213 + if (intel_dp_aux_native_read(intel_encoder, 1214 1214 0x000, dp_priv->dpcd, 1215 1215 sizeof (dp_priv->dpcd)) == sizeof (dp_priv->dpcd)) 1216 1216 { ··· 1222 1222 1223 1223 static int intel_dp_get_modes(struct drm_connector *connector) 1224 1224 { 1225 1225 - struct intel_output *intel_output = to_intel_output(connector); 1226 1226 - struct drm_device *dev = intel_output->base.dev; 1225 1225 + struct intel_encoder *intel_encoder = to_intel_encoder(connector); 1226 1226 + struct drm_device *dev = intel_encoder->base.dev; 1227 1227 struct drm_i915_private *dev_priv = dev->dev_private; 1228 1228 int ret; 1229 1229 1230 1230 /* We should parse the EDID data and find out if it has an audio sink 1231 1231 */ 1232 1232 1233 1233 - ret = intel_ddc_get_modes(intel_output); 1233 1233 + ret = intel_ddc_get_modes(intel_encoder); 1234 1234 if (ret) 1235 1235 return ret; 1236 1236 1237 1237 /* if eDP has no EDID, try to use fixed panel mode from VBT */ 1238 1238 - if (IS_eDP(intel_output)) { 1238 1238 + if (IS_eDP(intel_encoder)) { 1239 1239 if (dev_priv->panel_fixed_mode != NULL) { 1240 1240 struct drm_display_mode *mode; 1241 1241 mode = drm_mode_duplicate(dev, dev_priv->panel_fixed_mode); ··· 1249 1249 static void 1250 1250 intel_dp_destroy (struct drm_connector *connector) 1251 1251 { 1252 1252 - struct intel_output *intel_output = to_intel_output(connector); 1252 1252 + struct intel_encoder *intel_encoder = to_intel_encoder(connector); 1253 1253 1254 1254 - if (intel_output->i2c_bus) 1255 1255 - intel_i2c_destroy(intel_output->i2c_bus); 1254 1254 + if (intel_encoder->i2c_bus) 1255 1255 + intel_i2c_destroy(intel_encoder->i2c_bus); 1256 1256 drm_sysfs_connector_remove(connector); 1257 1257 drm_connector_cleanup(connector); 1258 1258 - kfree(intel_output); 1258 1258 + kfree(intel_encoder); 1259 1259 } 1260 1260 1261 1261 static const struct drm_encoder_helper_funcs intel_dp_helper_funcs = { ··· 1291 1291 }; 1292 1292 1293 1293 void 1294 1294 - intel_dp_hot_plug(struct intel_output *intel_output) 1294 1294 + intel_dp_hot_plug(struct intel_encoder *intel_encoder) 1295 1295 { 1296 1296 - struct intel_dp_priv *dp_priv = intel_output->dev_priv; 1296 1296 + struct intel_dp_priv *dp_priv = intel_encoder->dev_priv; 1297 1297 1298 1298 if (dp_priv->dpms_mode == DRM_MODE_DPMS_ON) 1299 1299 - intel_dp_check_link_status(intel_output); 1299 1299 + intel_dp_check_link_status(intel_encoder); 1300 1300 } 1301 1301 1302 1302 void ··· 1304 1304 { 1305 1305 struct drm_i915_private *dev_priv = dev->dev_private; 1306 1306 struct drm_connector *connector; 1307 1307 - struct intel_output *intel_output; 1307 1307 + struct intel_encoder *intel_encoder; 1308 1308 struct intel_dp_priv *dp_priv; 1309 1309 const char *name = NULL; 1310 1310 1311 1311 - intel_output = kcalloc(sizeof(struct intel_output) + 1311 1311 + intel_encoder = kcalloc(sizeof(struct intel_encoder) + 1312 1312 sizeof(struct intel_dp_priv), 1, GFP_KERNEL); 1313 1313 - if (!intel_output) 1313 1313 + if (!intel_encoder) 1314 1314 return; 1315 1315 1316 1316 - dp_priv = (struct intel_dp_priv *)(intel_output + 1); 1316 1316 + dp_priv = (struct intel_dp_priv *)(intel_encoder + 1); 1317 1317 1318 1318 - connector = &intel_output->base; 1318 1318 + connector = &intel_encoder->base; 1319 1319 drm_connector_init(dev, connector, &intel_dp_connector_funcs, 1320 1320 DRM_MODE_CONNECTOR_DisplayPort); 1321 1321 drm_connector_helper_add(connector, &intel_dp_connector_helper_funcs); 1322 1322 1323 1323 if (output_reg == DP_A) 1324 1324 - intel_output->type = INTEL_OUTPUT_EDP; 1324 1324 + intel_encoder->type = INTEL_OUTPUT_EDP; 1325 1325 else 1326 1326 - intel_output->type = INTEL_OUTPUT_DISPLAYPORT; 1326 1326 + intel_encoder->type = INTEL_OUTPUT_DISPLAYPORT; 1327 1327 1328 1328 if (output_reg == DP_B || output_reg == PCH_DP_B) 1329 1329 - intel_output->clone_mask = (1 << INTEL_DP_B_CLONE_BIT); 1329 1329 + intel_encoder->clone_mask = (1 << INTEL_DP_B_CLONE_BIT); 1330 1330 else if (output_reg == DP_C || output_reg == PCH_DP_C) 1331 1331 - intel_output->clone_mask = (1 << INTEL_DP_C_CLONE_BIT); 1331 1331 + intel_encoder->clone_mask = (1 << INTEL_DP_C_CLONE_BIT); 1332 1332 else if (output_reg == DP_D || output_reg == PCH_DP_D) 1333 1333 - intel_output->clone_mask = (1 << INTEL_DP_D_CLONE_BIT); 1333 1333 + intel_encoder->clone_mask = (1 << INTEL_DP_D_CLONE_BIT); 1334 1334 1335 1335 - if (IS_eDP(intel_output)) 1336 1336 - intel_output->clone_mask = (1 << INTEL_EDP_CLONE_BIT); 1335 1335 + if (IS_eDP(intel_encoder)) 1336 1336 + intel_encoder->clone_mask = (1 << INTEL_EDP_CLONE_BIT); 1337 1337 1338 1338 - intel_output->crtc_mask = (1 << 0) | (1 << 1); 1338 1338 + intel_encoder->crtc_mask = (1 << 0) | (1 << 1); 1339 1339 connector->interlace_allowed = true; 1340 1340 connector->doublescan_allowed = 0; 1341 1341 1342 1342 - dp_priv->intel_output = intel_output; 1342 1342 + dp_priv->intel_encoder = intel_encoder; 1343 1343 dp_priv->output_reg = output_reg; 1344 1344 dp_priv->has_audio = false; 1345 1345 dp_priv->dpms_mode = DRM_MODE_DPMS_ON; 1346 1346 - intel_output->dev_priv = dp_priv; 1346 1346 + intel_encoder->dev_priv = dp_priv; 1347 1347 1348 1348 - drm_encoder_init(dev, &intel_output->enc, &intel_dp_enc_funcs, 1348 1348 + drm_encoder_init(dev, &intel_encoder->enc, &intel_dp_enc_funcs, 1349 1349 DRM_MODE_ENCODER_TMDS); 1350 1350 - drm_encoder_helper_add(&intel_output->enc, &intel_dp_helper_funcs); 1350 1350 + drm_encoder_helper_add(&intel_encoder->enc, &intel_dp_helper_funcs); 1351 1351 1352 1352 - drm_mode_connector_attach_encoder(&intel_output->base, 1353 1353 - &intel_output->enc); 1352 1352 + drm_mode_connector_attach_encoder(&intel_encoder->base, 1353 1353 + &intel_encoder->enc); 1354 1354 drm_sysfs_connector_add(connector); 1355 1355 1356 1356 /* Set up the DDC bus. */ ··· 1378 1378 break; 1379 1379 } 1380 1380 1381 1381 - intel_dp_i2c_init(intel_output, name); 1381 1381 + intel_dp_i2c_init(intel_encoder, name); 1382 1382 1383 1383 - intel_output->ddc_bus = &dp_priv->adapter; 1384 1384 - intel_output->hot_plug = intel_dp_hot_plug; 1383 1383 + intel_encoder->ddc_bus = &dp_priv->adapter; 1384 1384 + intel_encoder->hot_plug = intel_dp_hot_plug; 1385 1385 1386 1386 if (output_reg == DP_A) { 1387 1387 /* initialize panel mode from VBT if available for eDP */

+9 -9

drivers/gpu/drm/i915/intel_drv.h

reviewed

··· 95 95 }; 96 96 97 97 98 98 - struct intel_output { 98 98 + struct intel_encoder { 99 99 struct drm_connector base; 100 100 101 101 struct drm_encoder enc; ··· 105 105 bool load_detect_temp; 106 106 bool needs_tv_clock; 107 107 void *dev_priv; 108 108 - void (*hot_plug)(struct intel_output *); 108 108 + void (*hot_plug)(struct intel_encoder *); 109 109 int crtc_mask; 110 110 int clone_mask; 111 111 }; ··· 152 152 }; 153 153 154 154 #define to_intel_crtc(x) container_of(x, struct intel_crtc, base) 155 155 - #define to_intel_output(x) container_of(x, struct intel_output, base) 156 156 - #define enc_to_intel_output(x) container_of(x, struct intel_output, enc) 155 155 + #define to_intel_encoder(x) container_of(x, struct intel_encoder, base) 156 156 + #define enc_to_intel_encoder(x) container_of(x, struct intel_encoder, enc) 157 157 #define to_intel_framebuffer(x) container_of(x, struct intel_framebuffer, base) 158 158 159 159 struct i2c_adapter *intel_i2c_create(struct drm_device *dev, const u32 reg, 160 160 const char *name); 161 161 void intel_i2c_destroy(struct i2c_adapter *adapter); 162 162 - int intel_ddc_get_modes(struct intel_output *intel_output); 163 163 - extern bool intel_ddc_probe(struct intel_output *intel_output); 162 162 + int intel_ddc_get_modes(struct intel_encoder *intel_encoder); 163 163 + extern bool intel_ddc_probe(struct intel_encoder *intel_encoder); 164 164 void intel_i2c_quirk_set(struct drm_device *dev, bool enable); 165 165 void intel_i2c_reset_gmbus(struct drm_device *dev); 166 166 ··· 175 175 void 176 176 intel_dp_set_m_n(struct drm_crtc *crtc, struct drm_display_mode *mode, 177 177 struct drm_display_mode *adjusted_mode); 178 178 - extern void intel_edp_link_config (struct intel_output *, int *, int *); 178 178 + extern void intel_edp_link_config (struct intel_encoder *, int *, int *); 179 179 180 180 181 181 extern int intel_panel_fitter_pipe (struct drm_device *dev); ··· 191 191 struct drm_file *file_priv); 192 192 extern void intel_wait_for_vblank(struct drm_device *dev); 193 193 extern struct drm_crtc *intel_get_crtc_from_pipe(struct drm_device *dev, int pipe); 194 194 - extern struct drm_crtc *intel_get_load_detect_pipe(struct intel_output *intel_output, 194 194 + extern struct drm_crtc *intel_get_load_detect_pipe(struct intel_encoder *intel_encoder, 195 195 struct drm_display_mode *mode, 196 196 int *dpms_mode); 197 197 - extern void intel_release_load_detect_pipe(struct intel_output *intel_output, 197 197 + extern void intel_release_load_detect_pipe(struct intel_encoder *intel_encoder, 198 198 int dpms_mode); 199 199 200 200 extern struct drm_connector* intel_sdvo_find(struct drm_device *dev, int sdvoB);

+46 -46

drivers/gpu/drm/i915/intel_dvo.c

reviewed

··· 80 80 static void intel_dvo_dpms(struct drm_encoder *encoder, int mode) 81 81 { 82 82 struct drm_i915_private *dev_priv = encoder->dev->dev_private; 83 83 - struct intel_output *intel_output = enc_to_intel_output(encoder); 84 84 - struct intel_dvo_device *dvo = intel_output->dev_priv; 83 83 + struct intel_encoder *intel_encoder = enc_to_intel_encoder(encoder); 84 84 + struct intel_dvo_device *dvo = intel_encoder->dev_priv; 85 85 u32 dvo_reg = dvo->dvo_reg; 86 86 u32 temp = I915_READ(dvo_reg); 87 87 ··· 99 99 static void intel_dvo_save(struct drm_connector *connector) 100 100 { 101 101 struct drm_i915_private *dev_priv = connector->dev->dev_private; 102 102 - struct intel_output *intel_output = to_intel_output(connector); 103 103 - struct intel_dvo_device *dvo = intel_output->dev_priv; 102 102 + struct intel_encoder *intel_encoder = to_intel_encoder(connector); 103 103 + struct intel_dvo_device *dvo = intel_encoder->dev_priv; 104 104 105 105 /* Each output should probably just save the registers it touches, 106 106 * but for now, use more overkill. ··· 115 115 static void intel_dvo_restore(struct drm_connector *connector) 116 116 { 117 117 struct drm_i915_private *dev_priv = connector->dev->dev_private; 118 118 - struct intel_output *intel_output = to_intel_output(connector); 119 119 - struct intel_dvo_device *dvo = intel_output->dev_priv; 118 118 + struct intel_encoder *intel_encoder = to_intel_encoder(connector); 119 119 + struct intel_dvo_device *dvo = intel_encoder->dev_priv; 120 120 121 121 dvo->dev_ops->restore(dvo); 122 122 ··· 128 128 static int intel_dvo_mode_valid(struct drm_connector *connector, 129 129 struct drm_display_mode *mode) 130 130 { 131 131 - struct intel_output *intel_output = to_intel_output(connector); 132 132 - struct intel_dvo_device *dvo = intel_output->dev_priv; 131 131 + struct intel_encoder *intel_encoder = to_intel_encoder(connector); 132 132 + struct intel_dvo_device *dvo = intel_encoder->dev_priv; 133 133 134 134 if (mode->flags & DRM_MODE_FLAG_DBLSCAN) 135 135 return MODE_NO_DBLESCAN; ··· 150 150 struct drm_display_mode *mode, 151 151 struct drm_display_mode *adjusted_mode) 152 152 { 153 153 - struct intel_output *intel_output = enc_to_intel_output(encoder); 154 154 - struct intel_dvo_device *dvo = intel_output->dev_priv; 153 153 + struct intel_encoder *intel_encoder = enc_to_intel_encoder(encoder); 154 154 + struct intel_dvo_device *dvo = intel_encoder->dev_priv; 155 155 156 156 /* If we have timings from the BIOS for the panel, put them in 157 157 * to the adjusted mode. The CRTC will be set up for this mode, ··· 186 186 struct drm_device *dev = encoder->dev; 187 187 struct drm_i915_private *dev_priv = dev->dev_private; 188 188 struct intel_crtc *intel_crtc = to_intel_crtc(encoder->crtc); 189 189 - struct intel_output *intel_output = enc_to_intel_output(encoder); 190 190 - struct intel_dvo_device *dvo = intel_output->dev_priv; 189 189 + struct intel_encoder *intel_encoder = enc_to_intel_encoder(encoder); 190 190 + struct intel_dvo_device *dvo = intel_encoder->dev_priv; 191 191 int pipe = intel_crtc->pipe; 192 192 u32 dvo_val; 193 193 u32 dvo_reg = dvo->dvo_reg, dvo_srcdim_reg; ··· 241 241 */ 242 242 static enum drm_connector_status intel_dvo_detect(struct drm_connector *connector) 243 243 { 244 244 - struct intel_output *intel_output = to_intel_output(connector); 245 245 - struct intel_dvo_device *dvo = intel_output->dev_priv; 244 244 + struct intel_encoder *intel_encoder = to_intel_encoder(connector); 245 245 + struct intel_dvo_device *dvo = intel_encoder->dev_priv; 246 246 247 247 return dvo->dev_ops->detect(dvo); 248 248 } 249 249 250 250 static int intel_dvo_get_modes(struct drm_connector *connector) 251 251 { 252 252 - struct intel_output *intel_output = to_intel_output(connector); 253 253 - struct intel_dvo_device *dvo = intel_output->dev_priv; 252 252 + struct intel_encoder *intel_encoder = to_intel_encoder(connector); 253 253 + struct intel_dvo_device *dvo = intel_encoder->dev_priv; 254 254 255 255 /* We should probably have an i2c driver get_modes function for those 256 256 * devices which will have a fixed set of modes determined by the chip 257 257 * (TV-out, for example), but for now with just TMDS and LVDS, 258 258 * that's not the case. 259 259 */ 260 260 - intel_ddc_get_modes(intel_output); 260 260 + intel_ddc_get_modes(intel_encoder); 261 261 if (!list_empty(&connector->probed_modes)) 262 262 return 1; 263 263 ··· 275 275 276 276 static void intel_dvo_destroy (struct drm_connector *connector) 277 277 { 278 278 - struct intel_output *intel_output = to_intel_output(connector); 279 279 - struct intel_dvo_device *dvo = intel_output->dev_priv; 278 278 + struct intel_encoder *intel_encoder = to_intel_encoder(connector); 279 279 + struct intel_dvo_device *dvo = intel_encoder->dev_priv; 280 280 281 281 if (dvo) { 282 282 if (dvo->dev_ops->destroy) ··· 286 286 /* no need, in i830_dvoices[] now */ 287 287 //kfree(dvo); 288 288 } 289 289 - if (intel_output->i2c_bus) 290 290 - intel_i2c_destroy(intel_output->i2c_bus); 291 291 - if (intel_output->ddc_bus) 292 292 - intel_i2c_destroy(intel_output->ddc_bus); 289 289 + if (intel_encoder->i2c_bus) 290 290 + intel_i2c_destroy(intel_encoder->i2c_bus); 291 291 + if (intel_encoder->ddc_bus) 292 292 + intel_i2c_destroy(intel_encoder->ddc_bus); 293 293 drm_sysfs_connector_remove(connector); 294 294 drm_connector_cleanup(connector); 295 295 - kfree(intel_output); 295 295 + kfree(intel_encoder); 296 296 } 297 297 298 298 #ifdef RANDR_GET_CRTC_INTERFACE ··· 300 300 { 301 301 struct drm_device *dev = connector->dev; 302 302 struct drm_i915_private *dev_priv = dev->dev_private; 303 303 - struct intel_output *intel_output = to_intel_output(connector); 304 304 - struct intel_dvo_device *dvo = intel_output->dev_priv; 303 303 + struct intel_encoder *intel_encoder = to_intel_encoder(connector); 304 304 + struct intel_dvo_device *dvo = intel_encoder->dev_priv; 305 305 int pipe = !!(I915_READ(dvo->dvo_reg) & SDVO_PIPE_B_SELECT); 306 306 307 307 return intel_pipe_to_crtc(pScrn, pipe); ··· 352 352 { 353 353 struct drm_device *dev = connector->dev; 354 354 struct drm_i915_private *dev_priv = dev->dev_private; 355 355 - struct intel_output *intel_output = to_intel_output(connector); 356 356 - struct intel_dvo_device *dvo = intel_output->dev_priv; 355 355 + struct intel_encoder *intel_encoder = to_intel_encoder(connector); 356 356 + struct intel_dvo_device *dvo = intel_encoder->dev_priv; 357 357 uint32_t dvo_reg = dvo->dvo_reg; 358 358 uint32_t dvo_val = I915_READ(dvo_reg); 359 359 struct drm_display_mode *mode = NULL; ··· 383 383 384 384 void intel_dvo_init(struct drm_device *dev) 385 385 { 386 386 - struct intel_output *intel_output; 386 386 + struct intel_encoder *intel_encoder; 387 387 struct intel_dvo_device *dvo; 388 388 struct i2c_adapter *i2cbus = NULL; 389 389 int ret = 0; 390 390 int i; 391 391 int encoder_type = DRM_MODE_ENCODER_NONE; 392 392 - intel_output = kzalloc (sizeof(struct intel_output), GFP_KERNEL); 393 393 - if (!intel_output) 392 392 + intel_encoder = kzalloc (sizeof(struct intel_encoder), GFP_KERNEL); 393 393 + if (!intel_encoder) 394 394 return; 395 395 396 396 /* Set up the DDC bus */ 397 397 - intel_output->ddc_bus = intel_i2c_create(dev, GPIOD, "DVODDC_D"); 398 398 - if (!intel_output->ddc_bus) 397 397 + intel_encoder->ddc_bus = intel_i2c_create(dev, GPIOD, "DVODDC_D"); 398 398 + if (!intel_encoder->ddc_bus) 399 399 goto free_intel; 400 400 401 401 /* Now, try to find a controller */ 402 402 for (i = 0; i < ARRAY_SIZE(intel_dvo_devices); i++) { 403 403 - struct drm_connector *connector = &intel_output->base; 403 403 + struct drm_connector *connector = &intel_encoder->base; 404 404 int gpio; 405 405 406 406 dvo = &intel_dvo_devices[i]; ··· 435 435 if (!ret) 436 436 continue; 437 437 438 438 - intel_output->type = INTEL_OUTPUT_DVO; 439 439 - intel_output->crtc_mask = (1 << 0) | (1 << 1); 438 438 + intel_encoder->type = INTEL_OUTPUT_DVO; 439 439 + intel_encoder->crtc_mask = (1 << 0) | (1 << 1); 440 440 switch (dvo->type) { 441 441 case INTEL_DVO_CHIP_TMDS: 442 442 - intel_output->clone_mask = 442 442 + intel_encoder->clone_mask = 443 443 (1 << INTEL_DVO_TMDS_CLONE_BIT) | 444 444 (1 << INTEL_ANALOG_CLONE_BIT); 445 445 drm_connector_init(dev, connector, ··· 448 448 encoder_type = DRM_MODE_ENCODER_TMDS; 449 449 break; 450 450 case INTEL_DVO_CHIP_LVDS: 451 451 - intel_output->clone_mask = 451 451 + intel_encoder->clone_mask = 452 452 (1 << INTEL_DVO_LVDS_CLONE_BIT); 453 453 drm_connector_init(dev, connector, 454 454 &intel_dvo_connector_funcs, ··· 463 463 connector->interlace_allowed = false; 464 464 connector->doublescan_allowed = false; 465 465 466 466 - intel_output->dev_priv = dvo; 467 467 - intel_output->i2c_bus = i2cbus; 466 466 + intel_encoder->dev_priv = dvo; 467 467 + intel_encoder->i2c_bus = i2cbus; 468 468 469 469 - drm_encoder_init(dev, &intel_output->enc, 469 469 + drm_encoder_init(dev, &intel_encoder->enc, 470 470 &intel_dvo_enc_funcs, encoder_type); 471 471 - drm_encoder_helper_add(&intel_output->enc, 471 471 + drm_encoder_helper_add(&intel_encoder->enc, 472 472 &intel_dvo_helper_funcs); 473 473 474 474 - drm_mode_connector_attach_encoder(&intel_output->base, 475 475 - &intel_output->enc); 474 474 + drm_mode_connector_attach_encoder(&intel_encoder->base, 475 475 + &intel_encoder->enc); 476 476 if (dvo->type == INTEL_DVO_CHIP_LVDS) { 477 477 /* For our LVDS chipsets, we should hopefully be able 478 478 * to dig the fixed panel mode out of the BIOS data. ··· 490 490 return; 491 491 } 492 492 493 493 - intel_i2c_destroy(intel_output->ddc_bus); 493 493 + intel_i2c_destroy(intel_encoder->ddc_bus); 494 494 /* Didn't find a chip, so tear down. */ 495 495 if (i2cbus != NULL) 496 496 intel_i2c_destroy(i2cbus); 497 497 free_intel: 498 498 - kfree(intel_output); 498 498 + kfree(intel_encoder); 499 499 }

+1 -1

drivers/gpu/drm/i915/intel_fb.c

reviewed

··· 144 144 ret = -ENOMEM; 145 145 goto out; 146 146 } 147 147 - obj_priv = fbo->driver_private; 147 147 + obj_priv = to_intel_bo(fbo); 148 148 149 149 mutex_lock(&dev->struct_mutex); 150 150

+43 -43

drivers/gpu/drm/i915/intel_hdmi.c

reviewed

··· 51 51 struct drm_i915_private *dev_priv = dev->dev_private; 52 52 struct drm_crtc *crtc = encoder->crtc; 53 53 struct intel_crtc *intel_crtc = to_intel_crtc(crtc); 54 54 - struct intel_output *intel_output = enc_to_intel_output(encoder); 55 55 - struct intel_hdmi_priv *hdmi_priv = intel_output->dev_priv; 54 54 + struct intel_encoder *intel_encoder = enc_to_intel_encoder(encoder); 55 55 + struct intel_hdmi_priv *hdmi_priv = intel_encoder->dev_priv; 56 56 u32 sdvox; 57 57 58 58 sdvox = SDVO_ENCODING_HDMI | ··· 74 74 { 75 75 struct drm_device *dev = encoder->dev; 76 76 struct drm_i915_private *dev_priv = dev->dev_private; 77 77 - struct intel_output *intel_output = enc_to_intel_output(encoder); 78 78 - struct intel_hdmi_priv *hdmi_priv = intel_output->dev_priv; 77 77 + struct intel_encoder *intel_encoder = enc_to_intel_encoder(encoder); 78 78 + struct intel_hdmi_priv *hdmi_priv = intel_encoder->dev_priv; 79 79 u32 temp; 80 80 81 81 temp = I915_READ(hdmi_priv->sdvox_reg); ··· 110 110 { 111 111 struct drm_device *dev = connector->dev; 112 112 struct drm_i915_private *dev_priv = dev->dev_private; 113 113 - struct intel_output *intel_output = to_intel_output(connector); 114 114 - struct intel_hdmi_priv *hdmi_priv = intel_output->dev_priv; 113 113 + struct intel_encoder *intel_encoder = to_intel_encoder(connector); 114 114 + struct intel_hdmi_priv *hdmi_priv = intel_encoder->dev_priv; 115 115 116 116 hdmi_priv->save_SDVOX = I915_READ(hdmi_priv->sdvox_reg); 117 117 } ··· 120 120 { 121 121 struct drm_device *dev = connector->dev; 122 122 struct drm_i915_private *dev_priv = dev->dev_private; 123 123 - struct intel_output *intel_output = to_intel_output(connector); 124 124 - struct intel_hdmi_priv *hdmi_priv = intel_output->dev_priv; 123 123 + struct intel_encoder *intel_encoder = to_intel_encoder(connector); 124 124 + struct intel_hdmi_priv *hdmi_priv = intel_encoder->dev_priv; 125 125 126 126 I915_WRITE(hdmi_priv->sdvox_reg, hdmi_priv->save_SDVOX); 127 127 POSTING_READ(hdmi_priv->sdvox_reg); ··· 151 151 static enum drm_connector_status 152 152 intel_hdmi_detect(struct drm_connector *connector) 153 153 { 154 154 - struct intel_output *intel_output = to_intel_output(connector); 155 155 - struct intel_hdmi_priv *hdmi_priv = intel_output->dev_priv; 154 154 + struct intel_encoder *intel_encoder = to_intel_encoder(connector); 155 155 + struct intel_hdmi_priv *hdmi_priv = intel_encoder->dev_priv; 156 156 struct edid *edid = NULL; 157 157 enum drm_connector_status status = connector_status_disconnected; 158 158 159 159 hdmi_priv->has_hdmi_sink = false; 160 160 - edid = drm_get_edid(&intel_output->base, 161 161 - intel_output->ddc_bus); 160 160 + edid = drm_get_edid(&intel_encoder->base, 161 161 + intel_encoder->ddc_bus); 162 162 163 163 if (edid) { 164 164 if (edid->input & DRM_EDID_INPUT_DIGITAL) { 165 165 status = connector_status_connected; 166 166 hdmi_priv->has_hdmi_sink = drm_detect_hdmi_monitor(edid); 167 167 } 168 168 - intel_output->base.display_info.raw_edid = NULL; 168 168 + intel_encoder->base.display_info.raw_edid = NULL; 169 169 kfree(edid); 170 170 } 171 171 ··· 174 174 175 175 static int intel_hdmi_get_modes(struct drm_connector *connector) 176 176 { 177 177 - struct intel_output *intel_output = to_intel_output(connector); 177 177 + struct intel_encoder *intel_encoder = to_intel_encoder(connector); 178 178 179 179 /* We should parse the EDID data and find out if it's an HDMI sink so 180 180 * we can send audio to it. 181 181 */ 182 182 183 183 - return intel_ddc_get_modes(intel_output); 183 183 + return intel_ddc_get_modes(intel_encoder); 184 184 } 185 185 186 186 static void intel_hdmi_destroy(struct drm_connector *connector) 187 187 { 188 188 - struct intel_output *intel_output = to_intel_output(connector); 188 188 + struct intel_encoder *intel_encoder = to_intel_encoder(connector); 189 189 190 190 - if (intel_output->i2c_bus) 191 191 - intel_i2c_destroy(intel_output->i2c_bus); 190 190 + if (intel_encoder->i2c_bus) 191 191 + intel_i2c_destroy(intel_encoder->i2c_bus); 192 192 drm_sysfs_connector_remove(connector); 193 193 drm_connector_cleanup(connector); 194 194 - kfree(intel_output); 194 194 + kfree(intel_encoder); 195 195 } 196 196 197 197 static const struct drm_encoder_helper_funcs intel_hdmi_helper_funcs = { ··· 230 230 { 231 231 struct drm_i915_private *dev_priv = dev->dev_private; 232 232 struct drm_connector *connector; 233 233 - struct intel_output *intel_output; 233 233 + struct intel_encoder *intel_encoder; 234 234 struct intel_hdmi_priv *hdmi_priv; 235 235 236 236 - intel_output = kcalloc(sizeof(struct intel_output) + 236 236 + intel_encoder = kcalloc(sizeof(struct intel_encoder) + 237 237 sizeof(struct intel_hdmi_priv), 1, GFP_KERNEL); 238 238 - if (!intel_output) 238 238 + if (!intel_encoder) 239 239 return; 240 240 - hdmi_priv = (struct intel_hdmi_priv *)(intel_output + 1); 240 240 + hdmi_priv = (struct intel_hdmi_priv *)(intel_encoder + 1); 241 241 242 242 - connector = &intel_output->base; 242 242 + connector = &intel_encoder->base; 243 243 drm_connector_init(dev, connector, &intel_hdmi_connector_funcs, 244 244 DRM_MODE_CONNECTOR_HDMIA); 245 245 drm_connector_helper_add(connector, &intel_hdmi_connector_helper_funcs); 246 246 247 247 - intel_output->type = INTEL_OUTPUT_HDMI; 247 247 + intel_encoder->type = INTEL_OUTPUT_HDMI; 248 248 249 249 connector->interlace_allowed = 0; 250 250 connector->doublescan_allowed = 0; 251 251 - intel_output->crtc_mask = (1 << 0) | (1 << 1); 251 251 + intel_encoder->crtc_mask = (1 << 0) | (1 << 1); 252 252 253 253 /* Set up the DDC bus. */ 254 254 if (sdvox_reg == SDVOB) { 255 255 - intel_output->clone_mask = (1 << INTEL_HDMIB_CLONE_BIT); 256 256 - intel_output->ddc_bus = intel_i2c_create(dev, GPIOE, "HDMIB"); 255 255 + intel_encoder->clone_mask = (1 << INTEL_HDMIB_CLONE_BIT); 256 256 + intel_encoder->ddc_bus = intel_i2c_create(dev, GPIOE, "HDMIB"); 257 257 dev_priv->hotplug_supported_mask |= HDMIB_HOTPLUG_INT_STATUS; 258 258 } else if (sdvox_reg == SDVOC) { 259 259 - intel_output->clone_mask = (1 << INTEL_HDMIC_CLONE_BIT); 260 260 - intel_output->ddc_bus = intel_i2c_create(dev, GPIOD, "HDMIC"); 259 259 + intel_encoder->clone_mask = (1 << INTEL_HDMIC_CLONE_BIT); 260 260 + intel_encoder->ddc_bus = intel_i2c_create(dev, GPIOD, "HDMIC"); 261 261 dev_priv->hotplug_supported_mask |= HDMIC_HOTPLUG_INT_STATUS; 262 262 } else if (sdvox_reg == HDMIB) { 263 263 - intel_output->clone_mask = (1 << INTEL_HDMID_CLONE_BIT); 264 264 - intel_output->ddc_bus = intel_i2c_create(dev, PCH_GPIOE, 263 263 + intel_encoder->clone_mask = (1 << INTEL_HDMID_CLONE_BIT); 264 264 + intel_encoder->ddc_bus = intel_i2c_create(dev, PCH_GPIOE, 265 265 "HDMIB"); 266 266 dev_priv->hotplug_supported_mask |= HDMIB_HOTPLUG_INT_STATUS; 267 267 } else if (sdvox_reg == HDMIC) { 268 268 - intel_output->clone_mask = (1 << INTEL_HDMIE_CLONE_BIT); 269 269 - intel_output->ddc_bus = intel_i2c_create(dev, PCH_GPIOD, 268 268 + intel_encoder->clone_mask = (1 << INTEL_HDMIE_CLONE_BIT); 269 269 + intel_encoder->ddc_bus = intel_i2c_create(dev, PCH_GPIOD, 270 270 "HDMIC"); 271 271 dev_priv->hotplug_supported_mask |= HDMIC_HOTPLUG_INT_STATUS; 272 272 } else if (sdvox_reg == HDMID) { 273 273 - intel_output->clone_mask = (1 << INTEL_HDMIF_CLONE_BIT); 274 274 - intel_output->ddc_bus = intel_i2c_create(dev, PCH_GPIOF, 273 273 + intel_encoder->clone_mask = (1 << INTEL_HDMIF_CLONE_BIT); 274 274 + intel_encoder->ddc_bus = intel_i2c_create(dev, PCH_GPIOF, 275 275 "HDMID"); 276 276 dev_priv->hotplug_supported_mask |= HDMID_HOTPLUG_INT_STATUS; 277 277 } 278 278 - if (!intel_output->ddc_bus) 278 278 + if (!intel_encoder->ddc_bus) 279 279 goto err_connector; 280 280 281 281 hdmi_priv->sdvox_reg = sdvox_reg; 282 282 - intel_output->dev_priv = hdmi_priv; 282 282 + intel_encoder->dev_priv = hdmi_priv; 283 283 284 284 - drm_encoder_init(dev, &intel_output->enc, &intel_hdmi_enc_funcs, 284 284 + drm_encoder_init(dev, &intel_encoder->enc, &intel_hdmi_enc_funcs, 285 285 DRM_MODE_ENCODER_TMDS); 286 286 - drm_encoder_helper_add(&intel_output->enc, &intel_hdmi_helper_funcs); 286 286 + drm_encoder_helper_add(&intel_encoder->enc, &intel_hdmi_helper_funcs); 287 287 288 288 - drm_mode_connector_attach_encoder(&intel_output->base, 289 289 - &intel_output->enc); 288 288 + drm_mode_connector_attach_encoder(&intel_encoder->base, 289 289 + &intel_encoder->enc); 290 290 drm_sysfs_connector_add(connector); 291 291 292 292 /* For G4X desktop chip, PEG_BAND_GAP_DATA 3:0 must first be written ··· 302 302 303 303 err_connector: 304 304 drm_connector_cleanup(connector); 305 305 - kfree(intel_output); 305 305 + kfree(intel_encoder); 306 306 307 307 return; 308 308 }

+47 -34

drivers/gpu/drm/i915/intel_lvds.c

reviewed

··· 239 239 struct drm_i915_private *dev_priv = dev->dev_private; 240 240 struct intel_crtc *intel_crtc = to_intel_crtc(encoder->crtc); 241 241 struct drm_encoder *tmp_encoder; 242 242 - struct intel_output *intel_output = enc_to_intel_output(encoder); 243 243 - struct intel_lvds_priv *lvds_priv = intel_output->dev_priv; 242 242 + struct intel_encoder *intel_encoder = enc_to_intel_encoder(encoder); 243 243 + struct intel_lvds_priv *lvds_priv = intel_encoder->dev_priv; 244 244 u32 pfit_control = 0, pfit_pgm_ratios = 0; 245 245 int left_border = 0, right_border = 0, top_border = 0; 246 246 int bottom_border = 0; ··· 587 587 { 588 588 struct drm_device *dev = encoder->dev; 589 589 struct drm_i915_private *dev_priv = dev->dev_private; 590 590 - struct intel_output *intel_output = enc_to_intel_output(encoder); 591 591 - struct intel_lvds_priv *lvds_priv = intel_output->dev_priv; 590 590 + struct intel_encoder *intel_encoder = enc_to_intel_encoder(encoder); 591 591 + struct intel_lvds_priv *lvds_priv = intel_encoder->dev_priv; 592 592 593 593 /* 594 594 * The LVDS pin pair will already have been turned on in the ··· 635 635 static int intel_lvds_get_modes(struct drm_connector *connector) 636 636 { 637 637 struct drm_device *dev = connector->dev; 638 638 - struct intel_output *intel_output = to_intel_output(connector); 638 638 + struct intel_encoder *intel_encoder = to_intel_encoder(connector); 639 639 struct drm_i915_private *dev_priv = dev->dev_private; 640 640 int ret = 0; 641 641 642 642 - ret = intel_ddc_get_modes(intel_output); 642 642 + if (dev_priv->lvds_edid_good) { 643 643 + ret = intel_ddc_get_modes(intel_encoder); 643 644 644 644 - if (ret) 645 645 - return ret; 645 645 + if (ret) 646 646 + return ret; 647 647 + } 646 648 647 649 /* Didn't get an EDID, so 648 650 * Set wide sync ranges so we get all modes ··· 717 715 static void intel_lvds_destroy(struct drm_connector *connector) 718 716 { 719 717 struct drm_device *dev = connector->dev; 720 720 - struct intel_output *intel_output = to_intel_output(connector); 718 718 + struct intel_encoder *intel_encoder = to_intel_encoder(connector); 721 719 struct drm_i915_private *dev_priv = dev->dev_private; 722 720 723 723 - if (intel_output->ddc_bus) 724 724 - intel_i2c_destroy(intel_output->ddc_bus); 721 721 + if (intel_encoder->ddc_bus) 722 722 + intel_i2c_destroy(intel_encoder->ddc_bus); 725 723 if (dev_priv->lid_notifier.notifier_call) 726 724 acpi_lid_notifier_unregister(&dev_priv->lid_notifier); 727 725 drm_sysfs_connector_remove(connector); ··· 734 732 uint64_t value) 735 733 { 736 734 struct drm_device *dev = connector->dev; 737 737 - struct intel_output *intel_output = 738 738 - to_intel_output(connector); 735 735 + struct intel_encoder *intel_encoder = 736 736 + to_intel_encoder(connector); 739 737 740 738 if (property == dev->mode_config.scaling_mode_property && 741 739 connector->encoder) { 742 740 struct drm_crtc *crtc = connector->encoder->crtc; 743 743 - struct intel_lvds_priv *lvds_priv = intel_output->dev_priv; 741 741 + struct intel_lvds_priv *lvds_priv = intel_encoder->dev_priv; 744 742 if (value == DRM_MODE_SCALE_NONE) { 745 743 DRM_DEBUG_KMS("no scaling not supported\n"); 746 744 return 0; ··· 860 858 DMI_MATCH(DMI_PRODUCT_VERSION, "AO00001JW"), 861 859 }, 862 860 }, 861 861 + { 862 862 + .callback = intel_no_lvds_dmi_callback, 863 863 + .ident = "Clientron U800", 864 864 + .matches = { 865 865 + DMI_MATCH(DMI_SYS_VENDOR, "Clientron"), 866 866 + DMI_MATCH(DMI_PRODUCT_NAME, "U800"), 867 867 + }, 868 868 + }, 863 869 864 870 { } /* terminating entry */ 865 871 }; ··· 978 968 void intel_lvds_init(struct drm_device *dev) 979 969 { 980 970 struct drm_i915_private *dev_priv = dev->dev_private; 981 981 - struct intel_output *intel_output; 971 971 + struct intel_encoder *intel_encoder; 982 972 struct drm_connector *connector; 983 973 struct drm_encoder *encoder; 984 974 struct drm_display_mode *scan; /* *modes, *bios_mode; */ ··· 1006 996 gpio = PCH_GPIOC; 1007 997 } 1008 998 1009 1009 - intel_output = kzalloc(sizeof(struct intel_output) + 999 999 + intel_encoder = kzalloc(sizeof(struct intel_encoder) + 1010 1000 sizeof(struct intel_lvds_priv), GFP_KERNEL); 1011 1011 - if (!intel_output) { 1001 1001 + if (!intel_encoder) { 1012 1002 return; 1013 1003 } 1014 1004 1015 1015 - connector = &intel_output->base; 1016 1016 - encoder = &intel_output->enc; 1017 1017 - drm_connector_init(dev, &intel_output->base, &intel_lvds_connector_funcs, 1005 1005 + connector = &intel_encoder->base; 1006 1006 + encoder = &intel_encoder->enc; 1007 1007 + drm_connector_init(dev, &intel_encoder->base, &intel_lvds_connector_funcs, 1018 1008 DRM_MODE_CONNECTOR_LVDS); 1019 1009 1020 1020 - drm_encoder_init(dev, &intel_output->enc, &intel_lvds_enc_funcs, 1010 1010 + drm_encoder_init(dev, &intel_encoder->enc, &intel_lvds_enc_funcs, 1021 1011 DRM_MODE_ENCODER_LVDS); 1022 1012 1023 1023 - drm_mode_connector_attach_encoder(&intel_output->base, &intel_output->enc); 1024 1024 - intel_output->type = INTEL_OUTPUT_LVDS; 1013 1013 + drm_mode_connector_attach_encoder(&intel_encoder->base, &intel_encoder->enc); 1014 1014 + intel_encoder->type = INTEL_OUTPUT_LVDS; 1025 1015 1026 1026 - intel_output->clone_mask = (1 << INTEL_LVDS_CLONE_BIT); 1027 1027 - intel_output->crtc_mask = (1 << 1); 1016 1016 + intel_encoder->clone_mask = (1 << INTEL_LVDS_CLONE_BIT); 1017 1017 + intel_encoder->crtc_mask = (1 << 1); 1028 1018 drm_encoder_helper_add(encoder, &intel_lvds_helper_funcs); 1029 1019 drm_connector_helper_add(connector, &intel_lvds_connector_helper_funcs); 1030 1020 connector->display_info.subpixel_order = SubPixelHorizontalRGB; 1031 1021 connector->interlace_allowed = false; 1032 1022 connector->doublescan_allowed = false; 1033 1023 1034 1034 - lvds_priv = (struct intel_lvds_priv *)(intel_output + 1); 1035 1035 - intel_output->dev_priv = lvds_priv; 1024 1024 + lvds_priv = (struct intel_lvds_priv *)(intel_encoder + 1); 1025 1025 + intel_encoder->dev_priv = lvds_priv; 1036 1026 /* create the scaling mode property */ 1037 1027 drm_mode_create_scaling_mode_property(dev); 1038 1028 /* 1039 1029 * the initial panel fitting mode will be FULL_SCREEN. 1040 1030 */ 1041 1031 1042 1042 - drm_connector_attach_property(&intel_output->base, 1032 1032 + drm_connector_attach_property(&intel_encoder->base, 1043 1033 dev->mode_config.scaling_mode_property, 1044 1034 DRM_MODE_SCALE_FULLSCREEN); 1045 1035 lvds_priv->fitting_mode = DRM_MODE_SCALE_FULLSCREEN; ··· 1054 1044 */ 1055 1045 1056 1046 /* Set up the DDC bus. */ 1057 1057 - intel_output->ddc_bus = intel_i2c_create(dev, gpio, "LVDSDDC_C"); 1058 1058 - if (!intel_output->ddc_bus) { 1047 1047 + intel_encoder->ddc_bus = intel_i2c_create(dev, gpio, "LVDSDDC_C"); 1048 1048 + if (!intel_encoder->ddc_bus) { 1059 1049 dev_printk(KERN_ERR, &dev->pdev->dev, "DDC bus registration " 1060 1050 "failed.\n"); 1061 1051 goto failed; ··· 1065 1055 * Attempt to get the fixed panel mode from DDC. Assume that the 1066 1056 * preferred mode is the right one. 1067 1057 */ 1068 1068 - intel_ddc_get_modes(intel_output); 1058 1058 + dev_priv->lvds_edid_good = true; 1059 1059 + 1060 1060 + if (!intel_ddc_get_modes(intel_encoder)) 1061 1061 + dev_priv->lvds_edid_good = false; 1069 1062 1070 1063 list_for_each_entry(scan, &connector->probed_modes, head) { 1071 1064 mutex_lock(&dev->mode_config.mutex); ··· 1146 1133 1147 1134 failed: 1148 1135 DRM_DEBUG_KMS("No LVDS modes found, disabling.\n"); 1149 1149 - if (intel_output->ddc_bus) 1150 1150 - intel_i2c_destroy(intel_output->ddc_bus); 1136 1136 + if (intel_encoder->ddc_bus) 1137 1137 + intel_i2c_destroy(intel_encoder->ddc_bus); 1151 1138 drm_connector_cleanup(connector); 1152 1139 drm_encoder_cleanup(encoder); 1153 1153 - kfree(intel_output); 1140 1140 + kfree(intel_encoder); 1154 1141 }

+11 -11

drivers/gpu/drm/i915/intel_modes.c

reviewed

··· 34 34 * intel_ddc_probe 35 35 * 36 36 */ 37 37 - bool intel_ddc_probe(struct intel_output *intel_output) 37 37 + bool intel_ddc_probe(struct intel_encoder *intel_encoder) 38 38 { 39 39 u8 out_buf[] = { 0x0, 0x0}; 40 40 u8 buf[2]; ··· 54 54 } 55 55 }; 56 56 57 57 - intel_i2c_quirk_set(intel_output->base.dev, true); 58 58 - ret = i2c_transfer(intel_output->ddc_bus, msgs, 2); 59 59 - intel_i2c_quirk_set(intel_output->base.dev, false); 57 57 + intel_i2c_quirk_set(intel_encoder->base.dev, true); 58 58 + ret = i2c_transfer(intel_encoder->ddc_bus, msgs, 2); 59 59 + intel_i2c_quirk_set(intel_encoder->base.dev, false); 60 60 if (ret == 2) 61 61 return true; 62 62 ··· 69 69 * 70 70 * Fetch the EDID information from @connector using the DDC bus. 71 71 */ 72 72 - int intel_ddc_get_modes(struct intel_output *intel_output) 72 72 + int intel_ddc_get_modes(struct intel_encoder *intel_encoder) 73 73 { 74 74 struct edid *edid; 75 75 int ret = 0; 76 76 77 77 - intel_i2c_quirk_set(intel_output->base.dev, true); 78 78 - edid = drm_get_edid(&intel_output->base, intel_output->ddc_bus); 79 79 - intel_i2c_quirk_set(intel_output->base.dev, false); 77 77 + intel_i2c_quirk_set(intel_encoder->base.dev, true); 78 78 + edid = drm_get_edid(&intel_encoder->base, intel_encoder->ddc_bus); 79 79 + intel_i2c_quirk_set(intel_encoder->base.dev, false); 80 80 if (edid) { 81 81 - drm_mode_connector_update_edid_property(&intel_output->base, 81 81 + drm_mode_connector_update_edid_property(&intel_encoder->base, 82 82 edid); 83 83 - ret = drm_add_edid_modes(&intel_output->base, edid); 84 84 - intel_output->base.display_info.raw_edid = NULL; 83 83 + ret = drm_add_edid_modes(&intel_encoder->base, edid); 84 84 + intel_encoder->base.display_info.raw_edid = NULL; 85 85 kfree(edid); 86 86 } 87 87

+3 -3

drivers/gpu/drm/i915/intel_overlay.c

reviewed

··· 724 724 int ret, tmp_width; 725 725 struct overlay_registers *regs; 726 726 bool scale_changed = false; 727 727 - struct drm_i915_gem_object *bo_priv = new_bo->driver_private; 727 727 + struct drm_i915_gem_object *bo_priv = to_intel_bo(new_bo); 728 728 struct drm_device *dev = overlay->dev; 729 729 730 730 BUG_ON(!mutex_is_locked(&dev->struct_mutex)); ··· 809 809 intel_overlay_continue(overlay, scale_changed); 810 810 811 811 overlay->old_vid_bo = overlay->vid_bo; 812 812 - overlay->vid_bo = new_bo->driver_private; 812 812 + overlay->vid_bo = to_intel_bo(new_bo); 813 813 814 814 return 0; 815 815 ··· 1344 1344 reg_bo = drm_gem_object_alloc(dev, PAGE_SIZE); 1345 1345 if (!reg_bo) 1346 1346 goto out_free; 1347 1347 - overlay->reg_bo = reg_bo->driver_private; 1347 1347 + overlay->reg_bo = to_intel_bo(reg_bo); 1348 1348 1349 1349 if (OVERLAY_NONPHYSICAL(dev)) { 1350 1350 ret = i915_gem_object_pin(reg_bo, PAGE_SIZE);

+368 -363

drivers/gpu/drm/i915/intel_sdvo.c

reviewed

··· 54 54 u8 slave_addr; 55 55 56 56 /* Register for the SDVO device: SDVOB or SDVOC */ 57 57 - int output_device; 57 57 + int sdvo_reg; 58 58 59 59 /* Active outputs controlled by this SDVO output */ 60 60 uint16_t controlled_output; ··· 124 124 */ 125 125 struct intel_sdvo_encode encode; 126 126 127 127 - /* DDC bus used by this SDVO output */ 127 127 + /* DDC bus used by this SDVO encoder */ 128 128 uint8_t ddc_bus; 129 129 130 130 /* Mac mini hack -- use the same DDC as the analog connector */ ··· 162 162 }; 163 163 164 164 static bool 165 165 - intel_sdvo_output_setup(struct intel_output *intel_output, uint16_t flags); 165 165 + intel_sdvo_output_setup(struct intel_encoder *intel_encoder, uint16_t flags); 166 166 167 167 /** 168 168 * Writes the SDVOB or SDVOC with the given value, but always writes both 169 169 * SDVOB and SDVOC to work around apparent hardware issues (according to 170 170 * comments in the BIOS). 171 171 */ 172 172 - static void intel_sdvo_write_sdvox(struct intel_output *intel_output, u32 val) 172 172 + static void intel_sdvo_write_sdvox(struct intel_encoder *intel_encoder, u32 val) 173 173 { 174 174 - struct drm_device *dev = intel_output->base.dev; 174 174 + struct drm_device *dev = intel_encoder->base.dev; 175 175 struct drm_i915_private *dev_priv = dev->dev_private; 176 176 - struct intel_sdvo_priv *sdvo_priv = intel_output->dev_priv; 176 176 + struct intel_sdvo_priv *sdvo_priv = intel_encoder->dev_priv; 177 177 u32 bval = val, cval = val; 178 178 int i; 179 179 180 180 - if (sdvo_priv->output_device == SDVOB) { 180 180 + if (sdvo_priv->sdvo_reg == SDVOB) { 181 181 cval = I915_READ(SDVOC); 182 182 } else { 183 183 bval = I915_READ(SDVOB); ··· 196 196 } 197 197 } 198 198 199 199 - static bool intel_sdvo_read_byte(struct intel_output *intel_output, u8 addr, 199 199 + static bool intel_sdvo_read_byte(struct intel_encoder *intel_encoder, u8 addr, 200 200 u8 *ch) 201 201 { 202 202 - struct intel_sdvo_priv *sdvo_priv = intel_output->dev_priv; 202 202 + struct intel_sdvo_priv *sdvo_priv = intel_encoder->dev_priv; 203 203 u8 out_buf[2]; 204 204 u8 buf[2]; 205 205 int ret; ··· 222 222 out_buf[0] = addr; 223 223 out_buf[1] = 0; 224 224 225 225 - if ((ret = i2c_transfer(intel_output->i2c_bus, msgs, 2)) == 2) 225 225 + if ((ret = i2c_transfer(intel_encoder->i2c_bus, msgs, 2)) == 2) 226 226 { 227 227 *ch = buf[0]; 228 228 return true; ··· 232 232 return false; 233 233 } 234 234 235 235 - static bool intel_sdvo_write_byte(struct intel_output *intel_output, int addr, 235 235 + static bool intel_sdvo_write_byte(struct intel_encoder *intel_encoder, int addr, 236 236 u8 ch) 237 237 { 238 238 - struct intel_sdvo_priv *sdvo_priv = intel_output->dev_priv; 238 238 + struct intel_sdvo_priv *sdvo_priv = intel_encoder->dev_priv; 239 239 u8 out_buf[2]; 240 240 struct i2c_msg msgs[] = { 241 241 { ··· 249 249 out_buf[0] = addr; 250 250 out_buf[1] = ch; 251 251 252 252 - if (i2c_transfer(intel_output->i2c_bus, msgs, 1) == 1) 252 252 + if (i2c_transfer(intel_encoder->i2c_bus, msgs, 1) == 1) 253 253 { 254 254 return true; 255 255 } ··· 353 353 SDVO_CMD_NAME_ENTRY(SDVO_CMD_GET_HBUF_DATA), 354 354 }; 355 355 356 356 - #define SDVO_NAME(dev_priv) ((dev_priv)->output_device == SDVOB ? "SDVOB" : "SDVOC") 357 357 - #define SDVO_PRIV(output) ((struct intel_sdvo_priv *) (output)->dev_priv) 356 356 + #define SDVO_NAME(dev_priv) ((dev_priv)->sdvo_reg == SDVOB ? "SDVOB" : "SDVOC") 357 357 + #define SDVO_PRIV(encoder) ((struct intel_sdvo_priv *) (encoder)->dev_priv) 358 358 359 359 - static void intel_sdvo_debug_write(struct intel_output *intel_output, u8 cmd, 359 359 + static void intel_sdvo_debug_write(struct intel_encoder *intel_encoder, u8 cmd, 360 360 void *args, int args_len) 361 361 { 362 362 - struct intel_sdvo_priv *sdvo_priv = intel_output->dev_priv; 362 362 + struct intel_sdvo_priv *sdvo_priv = intel_encoder->dev_priv; 363 363 int i; 364 364 365 365 DRM_DEBUG_KMS("%s: W: %02X ", ··· 379 379 DRM_LOG_KMS("\n"); 380 380 } 381 381 382 382 - static void intel_sdvo_write_cmd(struct intel_output *intel_output, u8 cmd, 382 382 + static void intel_sdvo_write_cmd(struct intel_encoder *intel_encoder, u8 cmd, 383 383 void *args, int args_len) 384 384 { 385 385 int i; 386 386 387 387 - intel_sdvo_debug_write(intel_output, cmd, args, args_len); 387 387 + intel_sdvo_debug_write(intel_encoder, cmd, args, args_len); 388 388 389 389 for (i = 0; i < args_len; i++) { 390 390 - intel_sdvo_write_byte(intel_output, SDVO_I2C_ARG_0 - i, 390 390 + intel_sdvo_write_byte(intel_encoder, SDVO_I2C_ARG_0 - i, 391 391 ((u8*)args)[i]); 392 392 } 393 393 394 394 - intel_sdvo_write_byte(intel_output, SDVO_I2C_OPCODE, cmd); 394 394 + intel_sdvo_write_byte(intel_encoder, SDVO_I2C_OPCODE, cmd); 395 395 } 396 396 397 397 static const char *cmd_status_names[] = { ··· 404 404 "Scaling not supported" 405 405 }; 406 406 407 407 - static void intel_sdvo_debug_response(struct intel_output *intel_output, 407 407 + static void intel_sdvo_debug_response(struct intel_encoder *intel_encoder, 408 408 void *response, int response_len, 409 409 u8 status) 410 410 { 411 411 - struct intel_sdvo_priv *sdvo_priv = intel_output->dev_priv; 411 411 + struct intel_sdvo_priv *sdvo_priv = intel_encoder->dev_priv; 412 412 int i; 413 413 414 414 DRM_DEBUG_KMS("%s: R: ", SDVO_NAME(sdvo_priv)); ··· 423 423 DRM_LOG_KMS("\n"); 424 424 } 425 425 426 426 - static u8 intel_sdvo_read_response(struct intel_output *intel_output, 426 426 + static u8 intel_sdvo_read_response(struct intel_encoder *intel_encoder, 427 427 void *response, int response_len) 428 428 { 429 429 int i; ··· 433 433 while (retry--) { 434 434 /* Read the command response */ 435 435 for (i = 0; i < response_len; i++) { 436 436 - intel_sdvo_read_byte(intel_output, 436 436 + intel_sdvo_read_byte(intel_encoder, 437 437 SDVO_I2C_RETURN_0 + i, 438 438 &((u8 *)response)[i]); 439 439 } 440 440 441 441 /* read the return status */ 442 442 - intel_sdvo_read_byte(intel_output, SDVO_I2C_CMD_STATUS, 442 442 + intel_sdvo_read_byte(intel_encoder, SDVO_I2C_CMD_STATUS, 443 443 &status); 444 444 445 445 - intel_sdvo_debug_response(intel_output, response, response_len, 445 445 + intel_sdvo_debug_response(intel_encoder, response, response_len, 446 446 status); 447 447 if (status != SDVO_CMD_STATUS_PENDING) 448 448 return status; ··· 470 470 * another I2C transaction after issuing the DDC bus switch, it will be 471 471 * switched to the internal SDVO register. 472 472 */ 473 473 - static void intel_sdvo_set_control_bus_switch(struct intel_output *intel_output, 473 473 + static void intel_sdvo_set_control_bus_switch(struct intel_encoder *intel_encoder, 474 474 u8 target) 475 475 { 476 476 - struct intel_sdvo_priv *sdvo_priv = intel_output->dev_priv; 476 476 + struct intel_sdvo_priv *sdvo_priv = intel_encoder->dev_priv; 477 477 u8 out_buf[2], cmd_buf[2], ret_value[2], ret; 478 478 struct i2c_msg msgs[] = { 479 479 { ··· 497 497 }, 498 498 }; 499 499 500 500 - intel_sdvo_debug_write(intel_output, SDVO_CMD_SET_CONTROL_BUS_SWITCH, 500 500 + intel_sdvo_debug_write(intel_encoder, SDVO_CMD_SET_CONTROL_BUS_SWITCH, 501 501 &target, 1); 502 502 /* write the DDC switch command argument */ 503 503 - intel_sdvo_write_byte(intel_output, SDVO_I2C_ARG_0, target); 503 503 + intel_sdvo_write_byte(intel_encoder, SDVO_I2C_ARG_0, target); 504 504 505 505 out_buf[0] = SDVO_I2C_OPCODE; 506 506 out_buf[1] = SDVO_CMD_SET_CONTROL_BUS_SWITCH; ··· 509 509 ret_value[0] = 0; 510 510 ret_value[1] = 0; 511 511 512 512 - ret = i2c_transfer(intel_output->i2c_bus, msgs, 3); 512 512 + ret = i2c_transfer(intel_encoder->i2c_bus, msgs, 3); 513 513 if (ret != 3) { 514 514 /* failure in I2C transfer */ 515 515 DRM_DEBUG_KMS("I2c transfer returned %d\n", ret); ··· 523 523 return; 524 524 } 525 525 526 526 - static bool intel_sdvo_set_target_input(struct intel_output *intel_output, bool target_0, bool target_1) 526 526 + static bool intel_sdvo_set_target_input(struct intel_encoder *intel_encoder, bool target_0, bool target_1) 527 527 { 528 528 struct intel_sdvo_set_target_input_args targets = {0}; 529 529 u8 status; ··· 534 534 if (target_1) 535 535 targets.target_1 = 1; 536 536 537 537 - intel_sdvo_write_cmd(intel_output, SDVO_CMD_SET_TARGET_INPUT, &targets, 537 537 + intel_sdvo_write_cmd(intel_encoder, SDVO_CMD_SET_TARGET_INPUT, &targets, 538 538 sizeof(targets)); 539 539 540 540 - status = intel_sdvo_read_response(intel_output, NULL, 0); 540 540 + status = intel_sdvo_read_response(intel_encoder, NULL, 0); 541 541 542 542 return (status == SDVO_CMD_STATUS_SUCCESS); 543 543 } ··· 548 548 * This function is making an assumption about the layout of the response, 549 549 * which should be checked against the docs. 550 550 */ 551 551 - static bool intel_sdvo_get_trained_inputs(struct intel_output *intel_output, bool *input_1, bool *input_2) 551 551 + static bool intel_sdvo_get_trained_inputs(struct intel_encoder *intel_encoder, bool *input_1, bool *input_2) 552 552 { 553 553 struct intel_sdvo_get_trained_inputs_response response; 554 554 u8 status; 555 555 556 556 - intel_sdvo_write_cmd(intel_output, SDVO_CMD_GET_TRAINED_INPUTS, NULL, 0); 557 557 - status = intel_sdvo_read_response(intel_output, &response, sizeof(response)); 556 556 + intel_sdvo_write_cmd(intel_encoder, SDVO_CMD_GET_TRAINED_INPUTS, NULL, 0); 557 557 + status = intel_sdvo_read_response(intel_encoder, &response, sizeof(response)); 558 558 if (status != SDVO_CMD_STATUS_SUCCESS) 559 559 return false; 560 560 ··· 563 563 return true; 564 564 } 565 565 566 566 - static bool intel_sdvo_get_active_outputs(struct intel_output *intel_output, 566 566 + static bool intel_sdvo_get_active_outputs(struct intel_encoder *intel_encoder, 567 567 u16 *outputs) 568 568 { 569 569 u8 status; 570 570 571 571 - intel_sdvo_write_cmd(intel_output, SDVO_CMD_GET_ACTIVE_OUTPUTS, NULL, 0); 572 572 - status = intel_sdvo_read_response(intel_output, outputs, sizeof(*outputs)); 571 571 + intel_sdvo_write_cmd(intel_encoder, SDVO_CMD_GET_ACTIVE_OUTPUTS, NULL, 0); 572 572 + status = intel_sdvo_read_response(intel_encoder, outputs, sizeof(*outputs)); 573 573 574 574 return (status == SDVO_CMD_STATUS_SUCCESS); 575 575 } 576 576 577 577 - static bool intel_sdvo_set_active_outputs(struct intel_output *intel_output, 577 577 + static bool intel_sdvo_set_active_outputs(struct intel_encoder *intel_encoder, 578 578 u16 outputs) 579 579 { 580 580 u8 status; 581 581 582 582 - intel_sdvo_write_cmd(intel_output, SDVO_CMD_SET_ACTIVE_OUTPUTS, &outputs, 582 582 + intel_sdvo_write_cmd(intel_encoder, SDVO_CMD_SET_ACTIVE_OUTPUTS, &outputs, 583 583 sizeof(outputs)); 584 584 - status = intel_sdvo_read_response(intel_output, NULL, 0); 584 584 + status = intel_sdvo_read_response(intel_encoder, NULL, 0); 585 585 return (status == SDVO_CMD_STATUS_SUCCESS); 586 586 } 587 587 588 588 - static bool intel_sdvo_set_encoder_power_state(struct intel_output *intel_output, 588 588 + static bool intel_sdvo_set_encoder_power_state(struct intel_encoder *intel_encoder, 589 589 int mode) 590 590 { 591 591 u8 status, state = SDVO_ENCODER_STATE_ON; ··· 605 605 break; 606 606 } 607 607 608 608 - intel_sdvo_write_cmd(intel_output, SDVO_CMD_SET_ENCODER_POWER_STATE, &state, 608 608 + intel_sdvo_write_cmd(intel_encoder, SDVO_CMD_SET_ENCODER_POWER_STATE, &state, 609 609 sizeof(state)); 610 610 - status = intel_sdvo_read_response(intel_output, NULL, 0); 610 610 + status = intel_sdvo_read_response(intel_encoder, NULL, 0); 611 611 612 612 return (status == SDVO_CMD_STATUS_SUCCESS); 613 613 } 614 614 615 615 - static bool intel_sdvo_get_input_pixel_clock_range(struct intel_output *intel_output, 615 615 + static bool intel_sdvo_get_input_pixel_clock_range(struct intel_encoder *intel_encoder, 616 616 int *clock_min, 617 617 int *clock_max) 618 618 { 619 619 struct intel_sdvo_pixel_clock_range clocks; 620 620 u8 status; 621 621 622 622 - intel_sdvo_write_cmd(intel_output, SDVO_CMD_GET_INPUT_PIXEL_CLOCK_RANGE, 622 622 + intel_sdvo_write_cmd(intel_encoder, SDVO_CMD_GET_INPUT_PIXEL_CLOCK_RANGE, 623 623 NULL, 0); 624 624 625 625 - status = intel_sdvo_read_response(intel_output, &clocks, sizeof(clocks)); 625 625 + status = intel_sdvo_read_response(intel_encoder, &clocks, sizeof(clocks)); 626 626 627 627 if (status != SDVO_CMD_STATUS_SUCCESS) 628 628 return false; ··· 634 634 return true; 635 635 } 636 636 637 637 - static bool intel_sdvo_set_target_output(struct intel_output *intel_output, 637 637 + static bool intel_sdvo_set_target_output(struct intel_encoder *intel_encoder, 638 638 u16 outputs) 639 639 { 640 640 u8 status; 641 641 642 642 - intel_sdvo_write_cmd(intel_output, SDVO_CMD_SET_TARGET_OUTPUT, &outputs, 642 642 + intel_sdvo_write_cmd(intel_encoder, SDVO_CMD_SET_TARGET_OUTPUT, &outputs, 643 643 sizeof(outputs)); 644 644 645 645 - status = intel_sdvo_read_response(intel_output, NULL, 0); 645 645 + status = intel_sdvo_read_response(intel_encoder, NULL, 0); 646 646 return (status == SDVO_CMD_STATUS_SUCCESS); 647 647 } 648 648 649 649 - static bool intel_sdvo_get_timing(struct intel_output *intel_output, u8 cmd, 649 649 + static bool intel_sdvo_get_timing(struct intel_encoder *intel_encoder, u8 cmd, 650 650 struct intel_sdvo_dtd *dtd) 651 651 { 652 652 u8 status; 653 653 654 654 - intel_sdvo_write_cmd(intel_output, cmd, NULL, 0); 655 655 - status = intel_sdvo_read_response(intel_output, &dtd->part1, 654 654 + intel_sdvo_write_cmd(intel_encoder, cmd, NULL, 0); 655 655 + status = intel_sdvo_read_response(intel_encoder, &dtd->part1, 656 656 sizeof(dtd->part1)); 657 657 if (status != SDVO_CMD_STATUS_SUCCESS) 658 658 return false; 659 659 660 660 - intel_sdvo_write_cmd(intel_output, cmd + 1, NULL, 0); 661 661 - status = intel_sdvo_read_response(intel_output, &dtd->part2, 660 660 + intel_sdvo_write_cmd(intel_encoder, cmd + 1, NULL, 0); 661 661 + status = intel_sdvo_read_response(intel_encoder, &dtd->part2, 662 662 sizeof(dtd->part2)); 663 663 if (status != SDVO_CMD_STATUS_SUCCESS) 664 664 return false; ··· 666 666 return true; 667 667 } 668 668 669 669 - static bool intel_sdvo_get_input_timing(struct intel_output *intel_output, 669 669 + static bool intel_sdvo_get_input_timing(struct intel_encoder *intel_encoder, 670 670 struct intel_sdvo_dtd *dtd) 671 671 { 672 672 - return intel_sdvo_get_timing(intel_output, 672 672 + return intel_sdvo_get_timing(intel_encoder, 673 673 SDVO_CMD_GET_INPUT_TIMINGS_PART1, dtd); 674 674 } 675 675 676 676 - static bool intel_sdvo_get_output_timing(struct intel_output *intel_output, 676 676 + static bool intel_sdvo_get_output_timing(struct intel_encoder *intel_encoder, 677 677 struct intel_sdvo_dtd *dtd) 678 678 { 679 679 - return intel_sdvo_get_timing(intel_output, 679 679 + return intel_sdvo_get_timing(intel_encoder, 680 680 SDVO_CMD_GET_OUTPUT_TIMINGS_PART1, dtd); 681 681 } 682 682 683 683 - static bool intel_sdvo_set_timing(struct intel_output *intel_output, u8 cmd, 683 683 + static bool intel_sdvo_set_timing(struct intel_encoder *intel_encoder, u8 cmd, 684 684 struct intel_sdvo_dtd *dtd) 685 685 { 686 686 u8 status; 687 687 688 688 - intel_sdvo_write_cmd(intel_output, cmd, &dtd->part1, sizeof(dtd->part1)); 689 689 - status = intel_sdvo_read_response(intel_output, NULL, 0); 688 688 + intel_sdvo_write_cmd(intel_encoder, cmd, &dtd->part1, sizeof(dtd->part1)); 689 689 + status = intel_sdvo_read_response(intel_encoder, NULL, 0); 690 690 if (status != SDVO_CMD_STATUS_SUCCESS) 691 691 return false; 692 692 693 693 - intel_sdvo_write_cmd(intel_output, cmd + 1, &dtd->part2, sizeof(dtd->part2)); 694 694 - status = intel_sdvo_read_response(intel_output, NULL, 0); 693 693 + intel_sdvo_write_cmd(intel_encoder, cmd + 1, &dtd->part2, sizeof(dtd->part2)); 694 694 + status = intel_sdvo_read_response(intel_encoder, NULL, 0); 695 695 if (status != SDVO_CMD_STATUS_SUCCESS) 696 696 return false; 697 697 698 698 return true; 699 699 } 700 700 701 701 - static bool intel_sdvo_set_input_timing(struct intel_output *intel_output, 701 701 + static bool intel_sdvo_set_input_timing(struct intel_encoder *intel_encoder, 702 702 struct intel_sdvo_dtd *dtd) 703 703 { 704 704 - return intel_sdvo_set_timing(intel_output, 704 704 + return intel_sdvo_set_timing(intel_encoder, 705 705 SDVO_CMD_SET_INPUT_TIMINGS_PART1, dtd); 706 706 } 707 707 708 708 - static bool intel_sdvo_set_output_timing(struct intel_output *intel_output, 708 708 + static bool intel_sdvo_set_output_timing(struct intel_encoder *intel_encoder, 709 709 struct intel_sdvo_dtd *dtd) 710 710 { 711 711 - return intel_sdvo_set_timing(intel_output, 711 711 + return intel_sdvo_set_timing(intel_encoder, 712 712 SDVO_CMD_SET_OUTPUT_TIMINGS_PART1, dtd); 713 713 } 714 714 715 715 static bool 716 716 - intel_sdvo_create_preferred_input_timing(struct intel_output *output, 716 716 + intel_sdvo_create_preferred_input_timing(struct intel_encoder *intel_encoder, 717 717 uint16_t clock, 718 718 uint16_t width, 719 719 uint16_t height) 720 720 { 721 721 struct intel_sdvo_preferred_input_timing_args args; 722 722 - struct intel_sdvo_priv *sdvo_priv = output->dev_priv; 722 722 + struct intel_sdvo_priv *sdvo_priv = intel_encoder->dev_priv; 723 723 uint8_t status; 724 724 725 725 memset(&args, 0, sizeof(args)); ··· 733 733 sdvo_priv->sdvo_lvds_fixed_mode->vdisplay != height)) 734 734 args.scaled = 1; 735 735 736 736 - intel_sdvo_write_cmd(output, SDVO_CMD_CREATE_PREFERRED_INPUT_TIMING, 736 736 + intel_sdvo_write_cmd(intel_encoder, 737 737 + SDVO_CMD_CREATE_PREFERRED_INPUT_TIMING, 737 738 &args, sizeof(args)); 738 738 - status = intel_sdvo_read_response(output, NULL, 0); 739 739 + status = intel_sdvo_read_response(intel_encoder, NULL, 0); 739 740 if (status != SDVO_CMD_STATUS_SUCCESS) 740 741 return false; 741 742 742 743 return true; 743 744 } 744 745 745 745 - static bool intel_sdvo_get_preferred_input_timing(struct intel_output *output, 746 746 + static bool intel_sdvo_get_preferred_input_timing(struct intel_encoder *intel_encoder, 746 747 struct intel_sdvo_dtd *dtd) 747 748 { 748 749 bool status; 749 750 750 750 - intel_sdvo_write_cmd(output, SDVO_CMD_GET_PREFERRED_INPUT_TIMING_PART1, 751 751 + intel_sdvo_write_cmd(intel_encoder, SDVO_CMD_GET_PREFERRED_INPUT_TIMING_PART1, 751 752 NULL, 0); 752 753 753 753 - status = intel_sdvo_read_response(output, &dtd->part1, 754 754 + status = intel_sdvo_read_response(intel_encoder, &dtd->part1, 754 755 sizeof(dtd->part1)); 755 756 if (status != SDVO_CMD_STATUS_SUCCESS) 756 757 return false; 757 758 758 758 - intel_sdvo_write_cmd(output, SDVO_CMD_GET_PREFERRED_INPUT_TIMING_PART2, 759 759 + intel_sdvo_write_cmd(intel_encoder, SDVO_CMD_GET_PREFERRED_INPUT_TIMING_PART2, 759 760 NULL, 0); 760 761 761 761 - status = intel_sdvo_read_response(output, &dtd->part2, 762 762 + status = intel_sdvo_read_response(intel_encoder, &dtd->part2, 762 763 sizeof(dtd->part2)); 763 764 if (status != SDVO_CMD_STATUS_SUCCESS) 764 765 return false; ··· 767 766 return false; 768 767 } 769 768 770 770 - static int intel_sdvo_get_clock_rate_mult(struct intel_output *intel_output) 769 769 + static int intel_sdvo_get_clock_rate_mult(struct intel_encoder *intel_encoder) 771 770 { 772 771 u8 response, status; 773 772 774 774 - intel_sdvo_write_cmd(intel_output, SDVO_CMD_GET_CLOCK_RATE_MULT, NULL, 0); 775 775 - status = intel_sdvo_read_response(intel_output, &response, 1); 773 773 + intel_sdvo_write_cmd(intel_encoder, SDVO_CMD_GET_CLOCK_RATE_MULT, NULL, 0); 774 774 + status = intel_sdvo_read_response(intel_encoder, &response, 1); 776 775 777 776 if (status != SDVO_CMD_STATUS_SUCCESS) { 778 777 DRM_DEBUG_KMS("Couldn't get SDVO clock rate multiplier\n"); ··· 784 783 return response; 785 784 } 786 785 787 787 - static bool intel_sdvo_set_clock_rate_mult(struct intel_output *intel_output, u8 val) 786 786 + static bool intel_sdvo_set_clock_rate_mult(struct intel_encoder *intel_encoder, u8 val) 788 787 { 789 788 u8 status; 790 789 791 791 - intel_sdvo_write_cmd(intel_output, SDVO_CMD_SET_CLOCK_RATE_MULT, &val, 1); 792 792 - status = intel_sdvo_read_response(intel_output, NULL, 0); 790 790 + intel_sdvo_write_cmd(intel_encoder, SDVO_CMD_SET_CLOCK_RATE_MULT, &val, 1); 791 791 + status = intel_sdvo_read_response(intel_encoder, NULL, 0); 793 792 if (status != SDVO_CMD_STATUS_SUCCESS) 794 793 return false; 795 794 ··· 878 877 mode->flags |= DRM_MODE_FLAG_PVSYNC; 879 878 } 880 879 881 881 - static bool intel_sdvo_get_supp_encode(struct intel_output *output, 880 880 + static bool intel_sdvo_get_supp_encode(struct intel_encoder *intel_encoder, 882 881 struct intel_sdvo_encode *encode) 883 882 { 884 883 uint8_t status; 885 884 886 886 - intel_sdvo_write_cmd(output, SDVO_CMD_GET_SUPP_ENCODE, NULL, 0); 887 887 - status = intel_sdvo_read_response(output, encode, sizeof(*encode)); 885 885 + intel_sdvo_write_cmd(intel_encoder, SDVO_CMD_GET_SUPP_ENCODE, NULL, 0); 886 886 + status = intel_sdvo_read_response(intel_encoder, encode, sizeof(*encode)); 888 887 if (status != SDVO_CMD_STATUS_SUCCESS) { /* non-support means DVI */ 889 888 memset(encode, 0, sizeof(*encode)); 890 889 return false; ··· 893 892 return true; 894 893 } 895 894 896 896 - static bool intel_sdvo_set_encode(struct intel_output *output, uint8_t mode) 895 895 + static bool intel_sdvo_set_encode(struct intel_encoder *intel_encoder, 896 896 + uint8_t mode) 897 897 { 898 898 uint8_t status; 899 899 900 900 - intel_sdvo_write_cmd(output, SDVO_CMD_SET_ENCODE, &mode, 1); 901 901 - status = intel_sdvo_read_response(output, NULL, 0); 900 900 + intel_sdvo_write_cmd(intel_encoder, SDVO_CMD_SET_ENCODE, &mode, 1); 901 901 + status = intel_sdvo_read_response(intel_encoder, NULL, 0); 902 902 903 903 return (status == SDVO_CMD_STATUS_SUCCESS); 904 904 } 905 905 906 906 - static bool intel_sdvo_set_colorimetry(struct intel_output *output, 906 906 + static bool intel_sdvo_set_colorimetry(struct intel_encoder *intel_encoder, 907 907 uint8_t mode) 908 908 { 909 909 uint8_t status; 910 910 911 911 - intel_sdvo_write_cmd(output, SDVO_CMD_SET_COLORIMETRY, &mode, 1); 912 912 - status = intel_sdvo_read_response(output, NULL, 0); 911 911 + intel_sdvo_write_cmd(intel_encoder, SDVO_CMD_SET_COLORIMETRY, &mode, 1); 912 912 + status = intel_sdvo_read_response(intel_encoder, NULL, 0); 913 913 914 914 return (status == SDVO_CMD_STATUS_SUCCESS); 915 915 } 916 916 917 917 #if 0 918 918 - static void intel_sdvo_dump_hdmi_buf(struct intel_output *output) 918 918 + static void intel_sdvo_dump_hdmi_buf(struct intel_encoder *intel_encoder) 919 919 { 920 920 int i, j; 921 921 uint8_t set_buf_index[2]; ··· 925 923 uint8_t buf[48]; 926 924 uint8_t *pos; 927 925 928 928 - intel_sdvo_write_cmd(output, SDVO_CMD_GET_HBUF_AV_SPLIT, NULL, 0); 929 929 - intel_sdvo_read_response(output, &av_split, 1); 926 926 + intel_sdvo_write_cmd(encoder, SDVO_CMD_GET_HBUF_AV_SPLIT, NULL, 0); 927 927 + intel_sdvo_read_response(encoder, &av_split, 1); 930 928 931 929 for (i = 0; i <= av_split; i++) { 932 930 set_buf_index[0] = i; set_buf_index[1] = 0; 933 933 - intel_sdvo_write_cmd(output, SDVO_CMD_SET_HBUF_INDEX, 931 931 + intel_sdvo_write_cmd(encoder, SDVO_CMD_SET_HBUF_INDEX, 934 932 set_buf_index, 2); 935 935 - intel_sdvo_write_cmd(output, SDVO_CMD_GET_HBUF_INFO, NULL, 0); 936 936 - intel_sdvo_read_response(output, &buf_size, 1); 933 933 + intel_sdvo_write_cmd(encoder, SDVO_CMD_GET_HBUF_INFO, NULL, 0); 934 934 + intel_sdvo_read_response(encoder, &buf_size, 1); 937 935 938 936 pos = buf; 939 937 for (j = 0; j <= buf_size; j += 8) { 940 940 - intel_sdvo_write_cmd(output, SDVO_CMD_GET_HBUF_DATA, 938 938 + intel_sdvo_write_cmd(encoder, SDVO_CMD_GET_HBUF_DATA, 941 939 NULL, 0); 942 942 - intel_sdvo_read_response(output, pos, 8); 940 940 + intel_sdvo_read_response(encoder, pos, 8); 943 941 pos += 8; 944 942 } 945 943 } 946 944 } 947 945 #endif 948 946 949 949 - static void intel_sdvo_set_hdmi_buf(struct intel_output *output, int index, 950 950 - uint8_t *data, int8_t size, uint8_t tx_rate) 947 947 + static void intel_sdvo_set_hdmi_buf(struct intel_encoder *intel_encoder, 948 948 + int index, 949 949 + uint8_t *data, int8_t size, uint8_t tx_rate) 951 950 { 952 951 uint8_t set_buf_index[2]; 953 952 954 953 set_buf_index[0] = index; 955 954 set_buf_index[1] = 0; 956 955 957 957 - intel_sdvo_write_cmd(output, SDVO_CMD_SET_HBUF_INDEX, set_buf_index, 2); 956 956 + intel_sdvo_write_cmd(intel_encoder, SDVO_CMD_SET_HBUF_INDEX, 957 957 + set_buf_index, 2); 958 958 959 959 for (; size > 0; size -= 8) { 960 960 - intel_sdvo_write_cmd(output, SDVO_CMD_SET_HBUF_DATA, data, 8); 960 960 + intel_sdvo_write_cmd(intel_encoder, SDVO_CMD_SET_HBUF_DATA, data, 8); 961 961 data += 8; 962 962 } 963 963 964 964 - intel_sdvo_write_cmd(output, SDVO_CMD_SET_HBUF_TXRATE, &tx_rate, 1); 964 964 + intel_sdvo_write_cmd(intel_encoder, SDVO_CMD_SET_HBUF_TXRATE, &tx_rate, 1); 965 965 } 966 966 967 967 static uint8_t intel_sdvo_calc_hbuf_csum(uint8_t *data, uint8_t size) ··· 1038 1034 } __attribute__ ((packed)) u; 1039 1035 } __attribute__((packed)); 1040 1036 1041 1041 - static void intel_sdvo_set_avi_infoframe(struct intel_output *output, 1037 1037 + static void intel_sdvo_set_avi_infoframe(struct intel_encoder *intel_encoder, 1042 1038 struct drm_display_mode * mode) 1043 1039 { 1044 1040 struct dip_infoframe avi_if = { ··· 1049 1045 1050 1046 avi_if.checksum = intel_sdvo_calc_hbuf_csum((uint8_t *)&avi_if, 1051 1047 4 + avi_if.len); 1052 1052 - intel_sdvo_set_hdmi_buf(output, 1, (uint8_t *)&avi_if, 4 + avi_if.len, 1048 1048 + intel_sdvo_set_hdmi_buf(intel_encoder, 1, (uint8_t *)&avi_if, 1049 1049 + 4 + avi_if.len, 1053 1050 SDVO_HBUF_TX_VSYNC); 1054 1051 } 1055 1052 1056 1056 - static void intel_sdvo_set_tv_format(struct intel_output *output) 1053 1053 + static void intel_sdvo_set_tv_format(struct intel_encoder *intel_encoder) 1057 1054 { 1058 1055 1059 1056 struct intel_sdvo_tv_format format; 1060 1060 - struct intel_sdvo_priv *sdvo_priv = output->dev_priv; 1057 1057 + struct intel_sdvo_priv *sdvo_priv = intel_encoder->dev_priv; 1061 1058 uint32_t format_map, i; 1062 1059 uint8_t status; 1063 1060 ··· 1071 1066 memcpy(&format, &format_map, sizeof(format_map) > sizeof(format) ? 1072 1067 sizeof(format) : sizeof(format_map)); 1073 1068 1074 1074 - intel_sdvo_write_cmd(output, SDVO_CMD_SET_TV_FORMAT, &format_map, 1069 1069 + intel_sdvo_write_cmd(intel_encoder, SDVO_CMD_SET_TV_FORMAT, &format_map, 1075 1070 sizeof(format)); 1076 1071 1077 1077 - status = intel_sdvo_read_response(output, NULL, 0); 1072 1072 + status = intel_sdvo_read_response(intel_encoder, NULL, 0); 1078 1073 if (status != SDVO_CMD_STATUS_SUCCESS) 1079 1074 DRM_DEBUG_KMS("%s: Failed to set TV format\n", 1080 1075 SDVO_NAME(sdvo_priv)); ··· 1084 1079 struct drm_display_mode *mode, 1085 1080 struct drm_display_mode *adjusted_mode) 1086 1081 { 1087 1087 - struct intel_output *output = enc_to_intel_output(encoder); 1088 1088 - struct intel_sdvo_priv *dev_priv = output->dev_priv; 1082 1082 + struct intel_encoder *intel_encoder = enc_to_intel_encoder(encoder); 1083 1083 + struct intel_sdvo_priv *dev_priv = intel_encoder->dev_priv; 1089 1084 1090 1085 if (dev_priv->is_tv) { 1091 1086 struct intel_sdvo_dtd output_dtd; ··· 1100 1095 1101 1096 /* Set output timings */ 1102 1097 intel_sdvo_get_dtd_from_mode(&output_dtd, mode); 1103 1103 - intel_sdvo_set_target_output(output, 1098 1098 + intel_sdvo_set_target_output(intel_encoder, 1104 1099 dev_priv->controlled_output); 1105 1105 - intel_sdvo_set_output_timing(output, &output_dtd); 1100 1100 + intel_sdvo_set_output_timing(intel_encoder, &output_dtd); 1106 1101 1107 1102 /* Set the input timing to the screen. Assume always input 0. */ 1108 1108 - intel_sdvo_set_target_input(output, true, false); 1103 1103 + intel_sdvo_set_target_input(intel_encoder, true, false); 1109 1104 1110 1105 1111 1111 - success = intel_sdvo_create_preferred_input_timing(output, 1106 1106 + success = intel_sdvo_create_preferred_input_timing(intel_encoder, 1112 1107 mode->clock / 10, 1113 1108 mode->hdisplay, 1114 1109 mode->vdisplay); 1115 1110 if (success) { 1116 1111 struct intel_sdvo_dtd input_dtd; 1117 1112 1118 1118 - intel_sdvo_get_preferred_input_timing(output, 1113 1113 + intel_sdvo_get_preferred_input_timing(intel_encoder, 1119 1114 &input_dtd); 1120 1115 intel_sdvo_get_mode_from_dtd(adjusted_mode, &input_dtd); 1121 1116 dev_priv->sdvo_flags = input_dtd.part2.sdvo_flags; ··· 1138 1133 intel_sdvo_get_dtd_from_mode(&output_dtd, 1139 1134 dev_priv->sdvo_lvds_fixed_mode); 1140 1135 1141 1141 - intel_sdvo_set_target_output(output, 1136 1136 + intel_sdvo_set_target_output(intel_encoder, 1142 1137 dev_priv->controlled_output); 1143 1143 - intel_sdvo_set_output_timing(output, &output_dtd); 1138 1138 + intel_sdvo_set_output_timing(intel_encoder, &output_dtd); 1144 1139 1145 1140 /* Set the input timing to the screen. Assume always input 0. */ 1146 1146 - intel_sdvo_set_target_input(output, true, false); 1141 1141 + intel_sdvo_set_target_input(intel_encoder, true, false); 1147 1142 1148 1143 1149 1144 success = intel_sdvo_create_preferred_input_timing( 1150 1150 - output, 1145 1145 + intel_encoder, 1151 1146 mode->clock / 10, 1152 1147 mode->hdisplay, 1153 1148 mode->vdisplay); ··· 1155 1150 if (success) { 1156 1151 struct intel_sdvo_dtd input_dtd; 1157 1152 1158 1158 - intel_sdvo_get_preferred_input_timing(output, 1153 1153 + intel_sdvo_get_preferred_input_timing(intel_encoder, 1159 1154 &input_dtd); 1160 1155 intel_sdvo_get_mode_from_dtd(adjusted_mode, &input_dtd); 1161 1156 dev_priv->sdvo_flags = input_dtd.part2.sdvo_flags; ··· 1187 1182 struct drm_i915_private *dev_priv = dev->dev_private; 1188 1183 struct drm_crtc *crtc = encoder->crtc; 1189 1184 struct intel_crtc *intel_crtc = to_intel_crtc(crtc); 1190 1190 - struct intel_output *output = enc_to_intel_output(encoder); 1191 1191 - struct intel_sdvo_priv *sdvo_priv = output->dev_priv; 1185 1185 + struct intel_encoder *intel_encoder = enc_to_intel_encoder(encoder); 1186 1186 + struct intel_sdvo_priv *sdvo_priv = intel_encoder->dev_priv; 1192 1187 u32 sdvox = 0; 1193 1188 int sdvo_pixel_multiply; 1194 1189 struct intel_sdvo_in_out_map in_out; ··· 1207 1202 in_out.in0 = sdvo_priv->controlled_output; 1208 1203 in_out.in1 = 0; 1209 1204 1210 1210 - intel_sdvo_write_cmd(output, SDVO_CMD_SET_IN_OUT_MAP, 1205 1205 + intel_sdvo_write_cmd(intel_encoder, SDVO_CMD_SET_IN_OUT_MAP, 1211 1206 &in_out, sizeof(in_out)); 1212 1212 - status = intel_sdvo_read_response(output, NULL, 0); 1207 1207 + status = intel_sdvo_read_response(intel_encoder, NULL, 0); 1213 1208 1214 1209 if (sdvo_priv->is_hdmi) { 1215 1215 - intel_sdvo_set_avi_infoframe(output, mode); 1210 1210 + intel_sdvo_set_avi_infoframe(intel_encoder, mode); 1216 1211 sdvox |= SDVO_AUDIO_ENABLE; 1217 1212 } 1218 1213 ··· 1229 1224 */ 1230 1225 if (!sdvo_priv->is_tv && !sdvo_priv->is_lvds) { 1231 1226 /* Set the output timing to the screen */ 1232 1232 - intel_sdvo_set_target_output(output, 1227 1227 + intel_sdvo_set_target_output(intel_encoder, 1233 1228 sdvo_priv->controlled_output); 1234 1234 - intel_sdvo_set_output_timing(output, &input_dtd); 1229 1229 + intel_sdvo_set_output_timing(intel_encoder, &input_dtd); 1235 1230 } 1236 1231 1237 1232 /* Set the input timing to the screen. Assume always input 0. */ 1238 1238 - intel_sdvo_set_target_input(output, true, false); 1233 1233 + intel_sdvo_set_target_input(intel_encoder, true, false); 1239 1234 1240 1235 if (sdvo_priv->is_tv) 1241 1241 - intel_sdvo_set_tv_format(output); 1236 1236 + intel_sdvo_set_tv_format(intel_encoder); 1242 1237 1243 1238 /* We would like to use intel_sdvo_create_preferred_input_timing() to 1244 1239 * provide the device with a timing it can support, if it supports that ··· 1246 1241 * output the preferred timing, and we don't support that currently. 1247 1242 */ 1248 1243 #if 0 1249 1249 - success = intel_sdvo_create_preferred_input_timing(output, clock, 1244 1244 + success = intel_sdvo_create_preferred_input_timing(encoder, clock, 1250 1245 width, height); 1251 1246 if (success) { 1252 1247 struct intel_sdvo_dtd *input_dtd; 1253 1248 1254 1254 - intel_sdvo_get_preferred_input_timing(output, &input_dtd); 1255 1255 - intel_sdvo_set_input_timing(output, &input_dtd); 1249 1249 + intel_sdvo_get_preferred_input_timing(encoder, &input_dtd); 1250 1250 + intel_sdvo_set_input_timing(encoder, &input_dtd); 1256 1251 } 1257 1252 #else 1258 1258 - intel_sdvo_set_input_timing(output, &input_dtd); 1253 1253 + intel_sdvo_set_input_timing(intel_encoder, &input_dtd); 1259 1254 #endif 1260 1255 1261 1256 switch (intel_sdvo_get_pixel_multiplier(mode)) { 1262 1257 case 1: 1263 1263 - intel_sdvo_set_clock_rate_mult(output, 1258 1258 + intel_sdvo_set_clock_rate_mult(intel_encoder, 1264 1259 SDVO_CLOCK_RATE_MULT_1X); 1265 1260 break; 1266 1261 case 2: 1267 1267 - intel_sdvo_set_clock_rate_mult(output, 1262 1262 + intel_sdvo_set_clock_rate_mult(intel_encoder, 1268 1263 SDVO_CLOCK_RATE_MULT_2X); 1269 1264 break; 1270 1265 case 4: 1271 1271 - intel_sdvo_set_clock_rate_mult(output, 1266 1266 + intel_sdvo_set_clock_rate_mult(intel_encoder, 1272 1267 SDVO_CLOCK_RATE_MULT_4X); 1273 1268 break; 1274 1269 } ··· 1279 1274 SDVO_VSYNC_ACTIVE_HIGH | 1280 1275 SDVO_HSYNC_ACTIVE_HIGH; 1281 1276 } else { 1282 1282 - sdvox |= I915_READ(sdvo_priv->output_device); 1283 1283 - switch (sdvo_priv->output_device) { 1277 1277 + sdvox |= I915_READ(sdvo_priv->sdvo_reg); 1278 1278 + switch (sdvo_priv->sdvo_reg) { 1284 1279 case SDVOB: 1285 1280 sdvox &= SDVOB_PRESERVE_MASK; 1286 1281 break; ··· 1304 1299 1305 1300 if (sdvo_priv->sdvo_flags & SDVO_NEED_TO_STALL) 1306 1301 sdvox |= SDVO_STALL_SELECT; 1307 1307 - intel_sdvo_write_sdvox(output, sdvox); 1302 1302 + intel_sdvo_write_sdvox(intel_encoder, sdvox); 1308 1303 } 1309 1304 1310 1305 static void intel_sdvo_dpms(struct drm_encoder *encoder, int mode) 1311 1306 { 1312 1307 struct drm_device *dev = encoder->dev; 1313 1308 struct drm_i915_private *dev_priv = dev->dev_private; 1314 1314 - struct intel_output *intel_output = enc_to_intel_output(encoder); 1315 1315 - struct intel_sdvo_priv *sdvo_priv = intel_output->dev_priv; 1309 1309 + struct intel_encoder *intel_encoder = enc_to_intel_encoder(encoder); 1310 1310 + struct intel_sdvo_priv *sdvo_priv = intel_encoder->dev_priv; 1316 1311 u32 temp; 1317 1312 1318 1313 if (mode != DRM_MODE_DPMS_ON) { 1319 1319 - intel_sdvo_set_active_outputs(intel_output, 0); 1314 1314 + intel_sdvo_set_active_outputs(intel_encoder, 0); 1320 1315 if (0) 1321 1321 - intel_sdvo_set_encoder_power_state(intel_output, mode); 1316 1316 + intel_sdvo_set_encoder_power_state(intel_encoder, mode); 1322 1317 1323 1318 if (mode == DRM_MODE_DPMS_OFF) { 1324 1324 - temp = I915_READ(sdvo_priv->output_device); 1319 1319 + temp = I915_READ(sdvo_priv->sdvo_reg); 1325 1320 if ((temp & SDVO_ENABLE) != 0) { 1326 1326 - intel_sdvo_write_sdvox(intel_output, temp & ~SDVO_ENABLE); 1321 1321 + intel_sdvo_write_sdvox(intel_encoder, temp & ~SDVO_ENABLE); 1327 1322 } 1328 1323 } 1329 1324 } else { ··· 1331 1326 int i; 1332 1327 u8 status; 1333 1328 1334 1334 - temp = I915_READ(sdvo_priv->output_device); 1329 1329 + temp = I915_READ(sdvo_priv->sdvo_reg); 1335 1330 if ((temp & SDVO_ENABLE) == 0) 1336 1336 - intel_sdvo_write_sdvox(intel_output, temp | SDVO_ENABLE); 1331 1331 + intel_sdvo_write_sdvox(intel_encoder, temp | SDVO_ENABLE); 1337 1332 for (i = 0; i < 2; i++) 1338 1333 intel_wait_for_vblank(dev); 1339 1334 1340 1340 - status = intel_sdvo_get_trained_inputs(intel_output, &input1, 1335 1335 + status = intel_sdvo_get_trained_inputs(intel_encoder, &input1, 1341 1336 &input2); 1342 1337 1343 1338 ··· 1351 1346 } 1352 1347 1353 1348 if (0) 1354 1354 - intel_sdvo_set_encoder_power_state(intel_output, mode); 1355 1355 - intel_sdvo_set_active_outputs(intel_output, sdvo_priv->controlled_output); 1349 1349 + intel_sdvo_set_encoder_power_state(intel_encoder, mode); 1350 1350 + intel_sdvo_set_active_outputs(intel_encoder, sdvo_priv->controlled_output); 1356 1351 } 1357 1352 return; 1358 1353 } ··· 1361 1356 { 1362 1357 struct drm_device *dev = connector->dev; 1363 1358 struct drm_i915_private *dev_priv = dev->dev_private; 1364 1364 - struct intel_output *intel_output = to_intel_output(connector); 1365 1365 - struct intel_sdvo_priv *sdvo_priv = intel_output->dev_priv; 1359 1359 + struct intel_encoder *intel_encoder = to_intel_encoder(connector); 1360 1360 + struct intel_sdvo_priv *sdvo_priv = intel_encoder->dev_priv; 1366 1361 int o; 1367 1362 1368 1368 - sdvo_priv->save_sdvo_mult = intel_sdvo_get_clock_rate_mult(intel_output); 1369 1369 - intel_sdvo_get_active_outputs(intel_output, &sdvo_priv->save_active_outputs); 1363 1363 + sdvo_priv->save_sdvo_mult = intel_sdvo_get_clock_rate_mult(intel_encoder); 1364 1364 + intel_sdvo_get_active_outputs(intel_encoder, &sdvo_priv->save_active_outputs); 1370 1365 1371 1366 if (sdvo_priv->caps.sdvo_inputs_mask & 0x1) { 1372 1372 - intel_sdvo_set_target_input(intel_output, true, false); 1373 1373 - intel_sdvo_get_input_timing(intel_output, 1367 1367 + intel_sdvo_set_target_input(intel_encoder, true, false); 1368 1368 + intel_sdvo_get_input_timing(intel_encoder, 1374 1369 &sdvo_priv->save_input_dtd_1); 1375 1370 } 1376 1371 1377 1372 if (sdvo_priv->caps.sdvo_inputs_mask & 0x2) { 1378 1378 - intel_sdvo_set_target_input(intel_output, false, true); 1379 1379 - intel_sdvo_get_input_timing(intel_output, 1373 1373 + intel_sdvo_set_target_input(intel_encoder, false, true); 1374 1374 + intel_sdvo_get_input_timing(intel_encoder, 1380 1375 &sdvo_priv->save_input_dtd_2); 1381 1376 } 1382 1377 ··· 1385 1380 u16 this_output = (1 << o); 1386 1381 if (sdvo_priv->caps.output_flags & this_output) 1387 1382 { 1388 1388 - intel_sdvo_set_target_output(intel_output, this_output); 1389 1389 - intel_sdvo_get_output_timing(intel_output, 1383 1383 + intel_sdvo_set_target_output(intel_encoder, this_output); 1384 1384 + intel_sdvo_get_output_timing(intel_encoder, 1390 1385 &sdvo_priv->save_output_dtd[o]); 1391 1386 } 1392 1387 } ··· 1394 1389 /* XXX: Save TV format/enhancements. */ 1395 1390 } 1396 1391 1397 1397 - sdvo_priv->save_SDVOX = I915_READ(sdvo_priv->output_device); 1392 1392 + sdvo_priv->save_SDVOX = I915_READ(sdvo_priv->sdvo_reg); 1398 1393 } 1399 1394 1400 1395 static void intel_sdvo_restore(struct drm_connector *connector) 1401 1396 { 1402 1397 struct drm_device *dev = connector->dev; 1403 1403 - struct intel_output *intel_output = to_intel_output(connector); 1404 1404 - struct intel_sdvo_priv *sdvo_priv = intel_output->dev_priv; 1398 1398 + struct intel_encoder *intel_encoder = to_intel_encoder(connector); 1399 1399 + struct intel_sdvo_priv *sdvo_priv = intel_encoder->dev_priv; 1405 1400 int o; 1406 1401 int i; 1407 1402 bool input1, input2; 1408 1403 u8 status; 1409 1404 1410 1410 - intel_sdvo_set_active_outputs(intel_output, 0); 1405 1405 + intel_sdvo_set_active_outputs(intel_encoder, 0); 1411 1406 1412 1407 for (o = SDVO_OUTPUT_FIRST; o <= SDVO_OUTPUT_LAST; o++) 1413 1408 { 1414 1409 u16 this_output = (1 << o); 1415 1410 if (sdvo_priv->caps.output_flags & this_output) { 1416 1416 - intel_sdvo_set_target_output(intel_output, this_output); 1417 1417 - intel_sdvo_set_output_timing(intel_output, &sdvo_priv->save_output_dtd[o]); 1411 1411 + intel_sdvo_set_target_output(intel_encoder, this_output); 1412 1412 + intel_sdvo_set_output_timing(intel_encoder, &sdvo_priv->save_output_dtd[o]); 1418 1413 } 1419 1414 } 1420 1415 1421 1416 if (sdvo_priv->caps.sdvo_inputs_mask & 0x1) { 1422 1422 - intel_sdvo_set_target_input(intel_output, true, false); 1423 1423 - intel_sdvo_set_input_timing(intel_output, &sdvo_priv->save_input_dtd_1); 1417 1417 + intel_sdvo_set_target_input(intel_encoder, true, false); 1418 1418 + intel_sdvo_set_input_timing(intel_encoder, &sdvo_priv->save_input_dtd_1); 1424 1419 } 1425 1420 1426 1421 if (sdvo_priv->caps.sdvo_inputs_mask & 0x2) { 1427 1427 - intel_sdvo_set_target_input(intel_output, false, true); 1428 1428 - intel_sdvo_set_input_timing(intel_output, &sdvo_priv->save_input_dtd_2); 1422 1422 + intel_sdvo_set_target_input(intel_encoder, false, true); 1423 1423 + intel_sdvo_set_input_timing(intel_encoder, &sdvo_priv->save_input_dtd_2); 1429 1424 } 1430 1425 1431 1431 - intel_sdvo_set_clock_rate_mult(intel_output, sdvo_priv->save_sdvo_mult); 1426 1426 + intel_sdvo_set_clock_rate_mult(intel_encoder, sdvo_priv->save_sdvo_mult); 1432 1427 1433 1428 if (sdvo_priv->is_tv) { 1434 1429 /* XXX: Restore TV format/enhancements. */ 1435 1430 } 1436 1431 1437 1437 - intel_sdvo_write_sdvox(intel_output, sdvo_priv->save_SDVOX); 1432 1432 + intel_sdvo_write_sdvox(intel_encoder, sdvo_priv->save_SDVOX); 1438 1433 1439 1434 if (sdvo_priv->save_SDVOX & SDVO_ENABLE) 1440 1435 { 1441 1436 for (i = 0; i < 2; i++) 1442 1437 intel_wait_for_vblank(dev); 1443 1443 - status = intel_sdvo_get_trained_inputs(intel_output, &input1, &input2); 1438 1438 + status = intel_sdvo_get_trained_inputs(intel_encoder, &input1, &input2); 1444 1439 if (status == SDVO_CMD_STATUS_SUCCESS && !input1) 1445 1440 DRM_DEBUG_KMS("First %s output reported failure to " 1446 1441 "sync\n", SDVO_NAME(sdvo_priv)); 1447 1442 } 1448 1443 1449 1449 - intel_sdvo_set_active_outputs(intel_output, sdvo_priv->save_active_outputs); 1444 1444 + intel_sdvo_set_active_outputs(intel_encoder, sdvo_priv->save_active_outputs); 1450 1445 } 1451 1446 1452 1447 static int intel_sdvo_mode_valid(struct drm_connector *connector, 1453 1448 struct drm_display_mode *mode) 1454 1449 { 1455 1455 - struct intel_output *intel_output = to_intel_output(connector); 1456 1456 - struct intel_sdvo_priv *sdvo_priv = intel_output->dev_priv; 1450 1450 + struct intel_encoder *intel_encoder = to_intel_encoder(connector); 1451 1451 + struct intel_sdvo_priv *sdvo_priv = intel_encoder->dev_priv; 1457 1452 1458 1453 if (mode->flags & DRM_MODE_FLAG_DBLSCAN) 1459 1454 return MODE_NO_DBLESCAN; ··· 1478 1473 return MODE_OK; 1479 1474 } 1480 1475 1481 1481 - static bool intel_sdvo_get_capabilities(struct intel_output *intel_output, struct intel_sdvo_caps *caps) 1476 1476 + static bool intel_sdvo_get_capabilities(struct intel_encoder *intel_encoder, struct intel_sdvo_caps *caps) 1482 1477 { 1483 1478 u8 status; 1484 1479 1485 1485 - intel_sdvo_write_cmd(intel_output, SDVO_CMD_GET_DEVICE_CAPS, NULL, 0); 1486 1486 - status = intel_sdvo_read_response(intel_output, caps, sizeof(*caps)); 1480 1480 + intel_sdvo_write_cmd(intel_encoder, SDVO_CMD_GET_DEVICE_CAPS, NULL, 0); 1481 1481 + status = intel_sdvo_read_response(intel_encoder, caps, sizeof(*caps)); 1487 1482 if (status != SDVO_CMD_STATUS_SUCCESS) 1488 1483 return false; 1489 1484 ··· 1493 1488 struct drm_connector* intel_sdvo_find(struct drm_device *dev, int sdvoB) 1494 1489 { 1495 1490 struct drm_connector *connector = NULL; 1496 1496 - struct intel_output *iout = NULL; 1491 1491 + struct intel_encoder *iout = NULL; 1497 1492 struct intel_sdvo_priv *sdvo; 1498 1493 1499 1494 /* find the sdvo connector */ 1500 1495 list_for_each_entry(connector, &dev->mode_config.connector_list, head) { 1501 1501 - iout = to_intel_output(connector); 1496 1496 + iout = to_intel_encoder(connector); 1502 1497 1503 1498 if (iout->type != INTEL_OUTPUT_SDVO) 1504 1499 continue; 1505 1500 1506 1501 sdvo = iout->dev_priv; 1507 1502 1508 1508 - if (sdvo->output_device == SDVOB && sdvoB) 1503 1503 + if (sdvo->sdvo_reg == SDVOB && sdvoB) 1509 1504 return connector; 1510 1505 1511 1511 - if (sdvo->output_device == SDVOC && !sdvoB) 1506 1506 + if (sdvo->sdvo_reg == SDVOC && !sdvoB) 1512 1507 return connector; 1513 1508 1514 1509 } ··· 1520 1515 { 1521 1516 u8 response[2]; 1522 1517 u8 status; 1523 1523 - struct intel_output *intel_output; 1518 1518 + struct intel_encoder *intel_encoder; 1524 1519 DRM_DEBUG_KMS("\n"); 1525 1520 1526 1521 if (!connector) 1527 1522 return 0; 1528 1523 1529 1529 - intel_output = to_intel_output(connector); 1524 1524 + intel_encoder = to_intel_encoder(connector); 1530 1525 1531 1531 - intel_sdvo_write_cmd(intel_output, SDVO_CMD_GET_HOT_PLUG_SUPPORT, NULL, 0); 1532 1532 - status = intel_sdvo_read_response(intel_output, &response, 2); 1526 1526 + intel_sdvo_write_cmd(intel_encoder, SDVO_CMD_GET_HOT_PLUG_SUPPORT, NULL, 0); 1527 1527 + status = intel_sdvo_read_response(intel_encoder, &response, 2); 1533 1528 1534 1529 if (response[0] !=0) 1535 1530 return 1; ··· 1541 1536 { 1542 1537 u8 response[2]; 1543 1538 u8 status; 1544 1544 - struct intel_output *intel_output = to_intel_output(connector); 1539 1539 + struct intel_encoder *intel_encoder = to_intel_encoder(connector); 1545 1540 1546 1546 - intel_sdvo_write_cmd(intel_output, SDVO_CMD_GET_ACTIVE_HOT_PLUG, NULL, 0); 1547 1547 - intel_sdvo_read_response(intel_output, &response, 2); 1541 1541 + intel_sdvo_write_cmd(intel_encoder, SDVO_CMD_GET_ACTIVE_HOT_PLUG, NULL, 0); 1542 1542 + intel_sdvo_read_response(intel_encoder, &response, 2); 1548 1543 1549 1544 if (on) { 1550 1550 - intel_sdvo_write_cmd(intel_output, SDVO_CMD_GET_HOT_PLUG_SUPPORT, NULL, 0); 1551 1551 - status = intel_sdvo_read_response(intel_output, &response, 2); 1545 1545 + intel_sdvo_write_cmd(intel_encoder, SDVO_CMD_GET_HOT_PLUG_SUPPORT, NULL, 0); 1546 1546 + status = intel_sdvo_read_response(intel_encoder, &response, 2); 1552 1547 1553 1553 - intel_sdvo_write_cmd(intel_output, SDVO_CMD_SET_ACTIVE_HOT_PLUG, &response, 2); 1548 1548 + intel_sdvo_write_cmd(intel_encoder, SDVO_CMD_SET_ACTIVE_HOT_PLUG, &response, 2); 1554 1549 } else { 1555 1550 response[0] = 0; 1556 1551 response[1] = 0; 1557 1557 - intel_sdvo_write_cmd(intel_output, SDVO_CMD_SET_ACTIVE_HOT_PLUG, &response, 2); 1552 1552 + intel_sdvo_write_cmd(intel_encoder, SDVO_CMD_SET_ACTIVE_HOT_PLUG, &response, 2); 1558 1553 } 1559 1554 1560 1560 - intel_sdvo_write_cmd(intel_output, SDVO_CMD_GET_ACTIVE_HOT_PLUG, NULL, 0); 1561 1561 - intel_sdvo_read_response(intel_output, &response, 2); 1555 1555 + intel_sdvo_write_cmd(intel_encoder, SDVO_CMD_GET_ACTIVE_HOT_PLUG, NULL, 0); 1556 1556 + intel_sdvo_read_response(intel_encoder, &response, 2); 1562 1557 } 1563 1558 1564 1559 static bool 1565 1565 - intel_sdvo_multifunc_encoder(struct intel_output *intel_output) 1560 1560 + intel_sdvo_multifunc_encoder(struct intel_encoder *intel_encoder) 1566 1561 { 1567 1567 - struct intel_sdvo_priv *sdvo_priv = intel_output->dev_priv; 1562 1562 + struct intel_sdvo_priv *sdvo_priv = intel_encoder->dev_priv; 1568 1563 int caps = 0; 1569 1564 1570 1565 if (sdvo_priv->caps.output_flags & ··· 1598 1593 intel_find_analog_connector(struct drm_device *dev) 1599 1594 { 1600 1595 struct drm_connector *connector; 1601 1601 - struct intel_output *intel_output; 1596 1596 + struct intel_encoder *intel_encoder; 1602 1597 1603 1598 list_for_each_entry(connector, &dev->mode_config.connector_list, head) { 1604 1604 - intel_output = to_intel_output(connector); 1605 1605 - if (intel_output->type == INTEL_OUTPUT_ANALOG) 1599 1599 + intel_encoder = to_intel_encoder(connector); 1600 1600 + if (intel_encoder->type == INTEL_OUTPUT_ANALOG) 1606 1601 return connector; 1607 1602 } 1608 1603 return NULL; ··· 1627 1622 enum drm_connector_status 1628 1623 intel_sdvo_hdmi_sink_detect(struct drm_connector *connector, u16 response) 1629 1624 { 1630 1630 - struct intel_output *intel_output = to_intel_output(connector); 1631 1631 - struct intel_sdvo_priv *sdvo_priv = intel_output->dev_priv; 1625 1625 + struct intel_encoder *intel_encoder = to_intel_encoder(connector); 1626 1626 + struct intel_sdvo_priv *sdvo_priv = intel_encoder->dev_priv; 1632 1627 enum drm_connector_status status = connector_status_connected; 1633 1628 struct edid *edid = NULL; 1634 1629 1635 1635 - edid = drm_get_edid(&intel_output->base, 1636 1636 - intel_output->ddc_bus); 1630 1630 + edid = drm_get_edid(&intel_encoder->base, 1631 1631 + intel_encoder->ddc_bus); 1637 1632 1638 1633 /* This is only applied to SDVO cards with multiple outputs */ 1639 1639 - if (edid == NULL && intel_sdvo_multifunc_encoder(intel_output)) { 1634 1634 + if (edid == NULL && intel_sdvo_multifunc_encoder(intel_encoder)) { 1640 1635 uint8_t saved_ddc, temp_ddc; 1641 1636 saved_ddc = sdvo_priv->ddc_bus; 1642 1637 temp_ddc = sdvo_priv->ddc_bus >> 1; ··· 1646 1641 */ 1647 1642 while(temp_ddc > 1) { 1648 1643 sdvo_priv->ddc_bus = temp_ddc; 1649 1649 - edid = drm_get_edid(&intel_output->base, 1650 1650 - intel_output->ddc_bus); 1644 1644 + edid = drm_get_edid(&intel_encoder->base, 1645 1645 + intel_encoder->ddc_bus); 1651 1646 if (edid) { 1652 1647 /* 1653 1648 * When we can get the EDID, maybe it is the ··· 1666 1661 */ 1667 1662 if (edid == NULL && 1668 1663 sdvo_priv->analog_ddc_bus && 1669 1669 - !intel_analog_is_connected(intel_output->base.dev)) 1670 1670 - edid = drm_get_edid(&intel_output->base, 1664 1664 + !intel_analog_is_connected(intel_encoder->base.dev)) 1665 1665 + edid = drm_get_edid(&intel_encoder->base, 1671 1666 sdvo_priv->analog_ddc_bus); 1672 1667 if (edid != NULL) { 1673 1668 /* Don't report the output as connected if it's a DVI-I ··· 1682 1677 } 1683 1678 1684 1679 kfree(edid); 1685 1685 - intel_output->base.display_info.raw_edid = NULL; 1680 1680 + intel_encoder->base.display_info.raw_edid = NULL; 1686 1681 1687 1682 } else if (response & (SDVO_OUTPUT_TMDS0 | SDVO_OUTPUT_TMDS1)) 1688 1683 status = connector_status_disconnected; ··· 1694 1689 { 1695 1690 uint16_t response; 1696 1691 u8 status; 1697 1697 - struct intel_output *intel_output = to_intel_output(connector); 1698 1698 - struct intel_sdvo_priv *sdvo_priv = intel_output->dev_priv; 1692 1692 + struct intel_encoder *intel_encoder = to_intel_encoder(connector); 1693 1693 + struct intel_sdvo_priv *sdvo_priv = intel_encoder->dev_priv; 1699 1694 1700 1700 - intel_sdvo_write_cmd(intel_output, 1695 1695 + intel_sdvo_write_cmd(intel_encoder, 1701 1696 SDVO_CMD_GET_ATTACHED_DISPLAYS, NULL, 0); 1702 1697 if (sdvo_priv->is_tv) { 1703 1698 /* add 30ms delay when the output type is SDVO-TV */ 1704 1699 mdelay(30); 1705 1700 } 1706 1706 - status = intel_sdvo_read_response(intel_output, &response, 2); 1701 1701 + status = intel_sdvo_read_response(intel_encoder, &response, 2); 1707 1702 1708 1703 DRM_DEBUG_KMS("SDVO response %d %d\n", response & 0xff, response >> 8); 1709 1704 ··· 1713 1708 if (response == 0) 1714 1709 return connector_status_disconnected; 1715 1710 1716 1716 - if (intel_sdvo_multifunc_encoder(intel_output) && 1711 1711 + if (intel_sdvo_multifunc_encoder(intel_encoder) && 1717 1712 sdvo_priv->attached_output != response) { 1718 1713 if (sdvo_priv->controlled_output != response && 1719 1719 - intel_sdvo_output_setup(intel_output, response) != true) 1714 1714 + intel_sdvo_output_setup(intel_encoder, response) != true) 1720 1715 return connector_status_unknown; 1721 1716 sdvo_priv->attached_output = response; 1722 1717 } ··· 1725 1720 1726 1721 static void intel_sdvo_get_ddc_modes(struct drm_connector *connector) 1727 1722 { 1728 1728 - struct intel_output *intel_output = to_intel_output(connector); 1729 1729 - struct intel_sdvo_priv *sdvo_priv = intel_output->dev_priv; 1723 1723 + struct intel_encoder *intel_encoder = to_intel_encoder(connector); 1724 1724 + struct intel_sdvo_priv *sdvo_priv = intel_encoder->dev_priv; 1730 1725 int num_modes; 1731 1726 1732 1727 /* set the bus switch and get the modes */ 1733 1733 - num_modes = intel_ddc_get_modes(intel_output); 1728 1728 + num_modes = intel_ddc_get_modes(intel_encoder); 1734 1729 1735 1730 /* 1736 1731 * Mac mini hack. On this device, the DVI-I connector shares one DDC ··· 1740 1735 */ 1741 1736 if (num_modes == 0 && 1742 1737 sdvo_priv->analog_ddc_bus && 1743 1743 - !intel_analog_is_connected(intel_output->base.dev)) { 1738 1738 + !intel_analog_is_connected(intel_encoder->base.dev)) { 1744 1739 struct i2c_adapter *digital_ddc_bus; 1745 1740 1746 1741 /* Switch to the analog ddc bus and try that 1747 1742 */ 1748 1748 - digital_ddc_bus = intel_output->ddc_bus; 1749 1749 - intel_output->ddc_bus = sdvo_priv->analog_ddc_bus; 1743 1743 + digital_ddc_bus = intel_encoder->ddc_bus; 1744 1744 + intel_encoder->ddc_bus = sdvo_priv->analog_ddc_bus; 1750 1745 1751 1751 - (void) intel_ddc_get_modes(intel_output); 1746 1746 + (void) intel_ddc_get_modes(intel_encoder); 1752 1747 1753 1753 - intel_output->ddc_bus = digital_ddc_bus; 1748 1748 + intel_encoder->ddc_bus = digital_ddc_bus; 1754 1749 } 1755 1750 } 1756 1751 ··· 1821 1816 1822 1817 static void intel_sdvo_get_tv_modes(struct drm_connector *connector) 1823 1818 { 1824 1824 - struct intel_output *output = to_intel_output(connector); 1819 1819 + struct intel_encoder *output = to_intel_encoder(connector); 1825 1820 struct intel_sdvo_priv *sdvo_priv = output->dev_priv; 1826 1821 struct intel_sdvo_sdtv_resolution_request tv_res; 1827 1822 uint32_t reply = 0, format_map = 0; ··· 1863 1858 1864 1859 static void intel_sdvo_get_lvds_modes(struct drm_connector *connector) 1865 1860 { 1866 1866 - struct intel_output *intel_output = to_intel_output(connector); 1861 1861 + struct intel_encoder *intel_encoder = to_intel_encoder(connector); 1867 1862 struct drm_i915_private *dev_priv = connector->dev->dev_private; 1868 1868 - struct intel_sdvo_priv *sdvo_priv = intel_output->dev_priv; 1863 1863 + struct intel_sdvo_priv *sdvo_priv = intel_encoder->dev_priv; 1869 1864 struct drm_display_mode *newmode; 1870 1865 1871 1866 /* ··· 1873 1868 * Assume that the preferred modes are 1874 1869 * arranged in priority order. 1875 1870 */ 1876 1876 - intel_ddc_get_modes(intel_output); 1871 1871 + intel_ddc_get_modes(intel_encoder); 1877 1872 if (list_empty(&connector->probed_modes) == false) 1878 1873 goto end; 1879 1874 ··· 1902 1897 1903 1898 static int intel_sdvo_get_modes(struct drm_connector *connector) 1904 1899 { 1905 1905 - struct intel_output *output = to_intel_output(connector); 1900 1900 + struct intel_encoder *output = to_intel_encoder(connector); 1906 1901 struct intel_sdvo_priv *sdvo_priv = output->dev_priv; 1907 1902 1908 1903 if (sdvo_priv->is_tv) ··· 1920 1915 static 1921 1916 void intel_sdvo_destroy_enhance_property(struct drm_connector *connector) 1922 1917 { 1923 1923 - struct intel_output *intel_output = to_intel_output(connector); 1924 1924 - struct intel_sdvo_priv *sdvo_priv = intel_output->dev_priv; 1918 1918 + struct intel_encoder *intel_encoder = to_intel_encoder(connector); 1919 1919 + struct intel_sdvo_priv *sdvo_priv = intel_encoder->dev_priv; 1925 1920 struct drm_device *dev = connector->dev; 1926 1921 1927 1922 if (sdvo_priv->is_tv) { ··· 1958 1953 1959 1954 static void intel_sdvo_destroy(struct drm_connector *connector) 1960 1955 { 1961 1961 - struct intel_output *intel_output = to_intel_output(connector); 1962 1962 - struct intel_sdvo_priv *sdvo_priv = intel_output->dev_priv; 1956 1956 + struct intel_encoder *intel_encoder = to_intel_encoder(connector); 1957 1957 + struct intel_sdvo_priv *sdvo_priv = intel_encoder->dev_priv; 1963 1958 1964 1964 - if (intel_output->i2c_bus) 1965 1965 - intel_i2c_destroy(intel_output->i2c_bus); 1966 1966 - if (intel_output->ddc_bus) 1967 1967 - intel_i2c_destroy(intel_output->ddc_bus); 1959 1959 + if (intel_encoder->i2c_bus) 1960 1960 + intel_i2c_destroy(intel_encoder->i2c_bus); 1961 1961 + if (intel_encoder->ddc_bus) 1962 1962 + intel_i2c_destroy(intel_encoder->ddc_bus); 1968 1963 if (sdvo_priv->analog_ddc_bus) 1969 1964 intel_i2c_destroy(sdvo_priv->analog_ddc_bus); 1970 1965 ··· 1982 1977 drm_sysfs_connector_remove(connector); 1983 1978 drm_connector_cleanup(connector); 1984 1979 1985 1985 - kfree(intel_output); 1980 1980 + kfree(intel_encoder); 1986 1981 } 1987 1982 1988 1983 static int ··· 1990 1985 struct drm_property *property, 1991 1986 uint64_t val) 1992 1987 { 1993 1993 - struct intel_output *intel_output = to_intel_output(connector); 1994 1994 - struct intel_sdvo_priv *sdvo_priv = intel_output->dev_priv; 1995 1995 - struct drm_encoder *encoder = &intel_output->enc; 1988 1988 + struct intel_encoder *intel_encoder = to_intel_encoder(connector); 1989 1989 + struct intel_sdvo_priv *sdvo_priv = intel_encoder->dev_priv; 1990 1990 + struct drm_encoder *encoder = &intel_encoder->enc; 1996 1991 struct drm_crtc *crtc = encoder->crtc; 1997 1992 int ret = 0; 1998 1993 bool changed = false; ··· 2100 2095 sdvo_priv->cur_brightness = temp_value; 2101 2096 } 2102 2097 if (cmd) { 2103 2103 - intel_sdvo_write_cmd(intel_output, cmd, &temp_value, 2); 2104 2104 - status = intel_sdvo_read_response(intel_output, 2098 2098 + intel_sdvo_write_cmd(intel_encoder, cmd, &temp_value, 2); 2099 2099 + status = intel_sdvo_read_response(intel_encoder, 2105 2100 NULL, 0); 2106 2101 if (status != SDVO_CMD_STATUS_SUCCESS) { 2107 2102 DRM_DEBUG_KMS("Incorrect SDVO command \n"); ··· 2196 2191 } 2197 2192 2198 2193 static bool 2199 2199 - intel_sdvo_get_digital_encoding_mode(struct intel_output *output) 2194 2194 + intel_sdvo_get_digital_encoding_mode(struct intel_encoder *output) 2200 2195 { 2201 2196 struct intel_sdvo_priv *sdvo_priv = output->dev_priv; 2202 2197 uint8_t status; ··· 2210 2205 return true; 2211 2206 } 2212 2207 2213 2213 - static struct intel_output * 2214 2214 - intel_sdvo_chan_to_intel_output(struct intel_i2c_chan *chan) 2208 2208 + static struct intel_encoder * 2209 2209 + intel_sdvo_chan_to_intel_encoder(struct intel_i2c_chan *chan) 2215 2210 { 2216 2211 struct drm_device *dev = chan->drm_dev; 2217 2212 struct drm_connector *connector; 2218 2218 - struct intel_output *intel_output = NULL; 2213 2213 + struct intel_encoder *intel_encoder = NULL; 2219 2214 2220 2215 list_for_each_entry(connector, 2221 2216 &dev->mode_config.connector_list, head) { 2222 2222 - if (to_intel_output(connector)->ddc_bus == &chan->adapter) { 2223 2223 - intel_output = to_intel_output(connector); 2217 2217 + if (to_intel_encoder(connector)->ddc_bus == &chan->adapter) { 2218 2218 + intel_encoder = to_intel_encoder(connector); 2224 2219 break; 2225 2220 } 2226 2221 } 2227 2227 - return intel_output; 2222 2222 + return intel_encoder; 2228 2223 } 2229 2224 2230 2225 static int intel_sdvo_master_xfer(struct i2c_adapter *i2c_adap, 2231 2226 struct i2c_msg msgs[], int num) 2232 2227 { 2233 2233 - struct intel_output *intel_output; 2228 2228 + struct intel_encoder *intel_encoder; 2234 2229 struct intel_sdvo_priv *sdvo_priv; 2235 2230 struct i2c_algo_bit_data *algo_data; 2236 2231 const struct i2c_algorithm *algo; 2237 2232 2238 2233 algo_data = (struct i2c_algo_bit_data *)i2c_adap->algo_data; 2239 2239 - intel_output = 2240 2240 - intel_sdvo_chan_to_intel_output( 2234 2234 + intel_encoder = 2235 2235 + intel_sdvo_chan_to_intel_encoder( 2241 2236 (struct intel_i2c_chan *)(algo_data->data)); 2242 2242 - if (intel_output == NULL) 2237 2237 + if (intel_encoder == NULL) 2243 2238 return -EINVAL; 2244 2239 2245 2245 - sdvo_priv = intel_output->dev_priv; 2246 2246 - algo = intel_output->i2c_bus->algo; 2240 2240 + sdvo_priv = intel_encoder->dev_priv; 2241 2241 + algo = intel_encoder->i2c_bus->algo; 2247 2242 2248 2248 - intel_sdvo_set_control_bus_switch(intel_output, sdvo_priv->ddc_bus); 2243 2243 + intel_sdvo_set_control_bus_switch(intel_encoder, sdvo_priv->ddc_bus); 2249 2244 return algo->master_xfer(i2c_adap, msgs, num); 2250 2245 } 2251 2246 ··· 2254 2249 }; 2255 2250 2256 2251 static u8 2257 2257 - intel_sdvo_get_slave_addr(struct drm_device *dev, int output_device) 2252 2252 + intel_sdvo_get_slave_addr(struct drm_device *dev, int sdvo_reg) 2258 2253 { 2259 2254 struct drm_i915_private *dev_priv = dev->dev_private; 2260 2255 struct sdvo_device_mapping *my_mapping, *other_mapping; 2261 2256 2262 2262 - if (output_device == SDVOB) { 2257 2257 + if (sdvo_reg == SDVOB) { 2263 2258 my_mapping = &dev_priv->sdvo_mappings[0]; 2264 2259 other_mapping = &dev_priv->sdvo_mappings[1]; 2265 2260 } else { ··· 2284 2279 /* No SDVO device info is found for another DVO port, 2285 2280 * so use mapping assumption we had before BIOS parsing. 2286 2281 */ 2287 2287 - if (output_device == SDVOB) 2282 2282 + if (sdvo_reg == SDVOB) 2288 2283 return 0x70; 2289 2284 else 2290 2285 return 0x72; ··· 2310 2305 }; 2311 2306 2312 2307 static bool 2313 2313 - intel_sdvo_output_setup(struct intel_output *intel_output, uint16_t flags) 2308 2308 + intel_sdvo_output_setup(struct intel_encoder *intel_encoder, uint16_t flags) 2314 2309 { 2315 2315 - struct drm_connector *connector = &intel_output->base; 2316 2316 - struct drm_encoder *encoder = &intel_output->enc; 2317 2317 - struct intel_sdvo_priv *sdvo_priv = intel_output->dev_priv; 2310 2310 + struct drm_connector *connector = &intel_encoder->base; 2311 2311 + struct drm_encoder *encoder = &intel_encoder->enc; 2312 2312 + struct intel_sdvo_priv *sdvo_priv = intel_encoder->dev_priv; 2318 2313 bool ret = true, registered = false; 2319 2314 2320 2315 sdvo_priv->is_tv = false; 2321 2321 - intel_output->needs_tv_clock = false; 2316 2316 + intel_encoder->needs_tv_clock = false; 2322 2317 sdvo_priv->is_lvds = false; 2323 2318 2324 2319 if (device_is_registered(&connector->kdev)) { ··· 2336 2331 encoder->encoder_type = DRM_MODE_ENCODER_TMDS; 2337 2332 connector->connector_type = DRM_MODE_CONNECTOR_DVID; 2338 2333 2339 2339 - if (intel_sdvo_get_supp_encode(intel_output, 2334 2334 + if (intel_sdvo_get_supp_encode(intel_encoder, 2340 2335 &sdvo_priv->encode) && 2341 2341 - intel_sdvo_get_digital_encoding_mode(intel_output) && 2336 2336 + intel_sdvo_get_digital_encoding_mode(intel_encoder) && 2342 2337 sdvo_priv->is_hdmi) { 2343 2338 /* enable hdmi encoding mode if supported */ 2344 2344 - intel_sdvo_set_encode(intel_output, SDVO_ENCODE_HDMI); 2345 2345 - intel_sdvo_set_colorimetry(intel_output, 2339 2339 + intel_sdvo_set_encode(intel_encoder, SDVO_ENCODE_HDMI); 2340 2340 + intel_sdvo_set_colorimetry(intel_encoder, 2346 2341 SDVO_COLORIMETRY_RGB256); 2347 2342 connector->connector_type = DRM_MODE_CONNECTOR_HDMIA; 2348 2348 - intel_output->clone_mask = 2343 2343 + intel_encoder->clone_mask = 2349 2344 (1 << INTEL_SDVO_NON_TV_CLONE_BIT) | 2350 2345 (1 << INTEL_ANALOG_CLONE_BIT); 2351 2346 } ··· 2356 2351 encoder->encoder_type = DRM_MODE_ENCODER_TVDAC; 2357 2352 connector->connector_type = DRM_MODE_CONNECTOR_SVIDEO; 2358 2353 sdvo_priv->is_tv = true; 2359 2359 - intel_output->needs_tv_clock = true; 2360 2360 - intel_output->clone_mask = 1 << INTEL_SDVO_TV_CLONE_BIT; 2354 2354 + intel_encoder->needs_tv_clock = true; 2355 2355 + intel_encoder->clone_mask = 1 << INTEL_SDVO_TV_CLONE_BIT; 2361 2356 } else if (flags & SDVO_OUTPUT_RGB0) { 2362 2357 2363 2358 sdvo_priv->controlled_output = SDVO_OUTPUT_RGB0; 2364 2359 encoder->encoder_type = DRM_MODE_ENCODER_DAC; 2365 2360 connector->connector_type = DRM_MODE_CONNECTOR_VGA; 2366 2366 - intel_output->clone_mask = (1 << INTEL_SDVO_NON_TV_CLONE_BIT) | 2361 2361 + intel_encoder->clone_mask = (1 << INTEL_SDVO_NON_TV_CLONE_BIT) | 2367 2362 (1 << INTEL_ANALOG_CLONE_BIT); 2368 2363 } else if (flags & SDVO_OUTPUT_RGB1) { 2369 2364 2370 2365 sdvo_priv->controlled_output = SDVO_OUTPUT_RGB1; 2371 2366 encoder->encoder_type = DRM_MODE_ENCODER_DAC; 2372 2367 connector->connector_type = DRM_MODE_CONNECTOR_VGA; 2373 2373 - intel_output->clone_mask = (1 << INTEL_SDVO_NON_TV_CLONE_BIT) | 2368 2368 + intel_encoder->clone_mask = (1 << INTEL_SDVO_NON_TV_CLONE_BIT) | 2374 2369 (1 << INTEL_ANALOG_CLONE_BIT); 2375 2370 } else if (flags & SDVO_OUTPUT_CVBS0) { 2376 2371 ··· 2378 2373 encoder->encoder_type = DRM_MODE_ENCODER_TVDAC; 2379 2374 connector->connector_type = DRM_MODE_CONNECTOR_SVIDEO; 2380 2375 sdvo_priv->is_tv = true; 2381 2381 - intel_output->needs_tv_clock = true; 2382 2382 - intel_output->clone_mask = 1 << INTEL_SDVO_TV_CLONE_BIT; 2376 2376 + intel_encoder->needs_tv_clock = true; 2377 2377 + intel_encoder->clone_mask = 1 << INTEL_SDVO_TV_CLONE_BIT; 2383 2378 } else if (flags & SDVO_OUTPUT_LVDS0) { 2384 2379 2385 2380 sdvo_priv->controlled_output = SDVO_OUTPUT_LVDS0; 2386 2381 encoder->encoder_type = DRM_MODE_ENCODER_LVDS; 2387 2382 connector->connector_type = DRM_MODE_CONNECTOR_LVDS; 2388 2383 sdvo_priv->is_lvds = true; 2389 2389 - intel_output->clone_mask = (1 << INTEL_ANALOG_CLONE_BIT) | 2384 2384 + intel_encoder->clone_mask = (1 << INTEL_ANALOG_CLONE_BIT) | 2390 2385 (1 << INTEL_SDVO_LVDS_CLONE_BIT); 2391 2386 } else if (flags & SDVO_OUTPUT_LVDS1) { 2392 2387 ··· 2394 2389 encoder->encoder_type = DRM_MODE_ENCODER_LVDS; 2395 2390 connector->connector_type = DRM_MODE_CONNECTOR_LVDS; 2396 2391 sdvo_priv->is_lvds = true; 2397 2397 - intel_output->clone_mask = (1 << INTEL_ANALOG_CLONE_BIT) | 2392 2392 + intel_encoder->clone_mask = (1 << INTEL_ANALOG_CLONE_BIT) | 2398 2393 (1 << INTEL_SDVO_LVDS_CLONE_BIT); 2399 2394 } else { 2400 2395 ··· 2407 2402 bytes[0], bytes[1]); 2408 2403 ret = false; 2409 2404 } 2410 2410 - intel_output->crtc_mask = (1 << 0) | (1 << 1); 2405 2405 + intel_encoder->crtc_mask = (1 << 0) | (1 << 1); 2411 2406 2412 2407 if (ret && registered) 2413 2408 ret = drm_sysfs_connector_add(connector) == 0 ? true : false; ··· 2419 2414 2420 2415 static void intel_sdvo_tv_create_property(struct drm_connector *connector) 2421 2416 { 2422 2422 - struct intel_output *intel_output = to_intel_output(connector); 2423 2423 - struct intel_sdvo_priv *sdvo_priv = intel_output->dev_priv; 2417 2417 + struct intel_encoder *intel_encoder = to_intel_encoder(connector); 2418 2418 + struct intel_sdvo_priv *sdvo_priv = intel_encoder->dev_priv; 2424 2419 struct intel_sdvo_tv_format format; 2425 2420 uint32_t format_map, i; 2426 2421 uint8_t status; 2427 2422 2428 2428 - intel_sdvo_set_target_output(intel_output, 2423 2423 + intel_sdvo_set_target_output(intel_encoder, 2429 2424 sdvo_priv->controlled_output); 2430 2425 2431 2431 - intel_sdvo_write_cmd(intel_output, 2426 2426 + intel_sdvo_write_cmd(intel_encoder, 2432 2427 SDVO_CMD_GET_SUPPORTED_TV_FORMATS, NULL, 0); 2433 2433 - status = intel_sdvo_read_response(intel_output, 2428 2428 + status = intel_sdvo_read_response(intel_encoder, 2434 2429 &format, sizeof(format)); 2435 2430 if (status != SDVO_CMD_STATUS_SUCCESS) 2436 2431 return; ··· 2468 2463 2469 2464 static void intel_sdvo_create_enhance_property(struct drm_connector *connector) 2470 2465 { 2471 2471 - struct intel_output *intel_output = to_intel_output(connector); 2472 2472 - struct intel_sdvo_priv *sdvo_priv = intel_output->dev_priv; 2466 2466 + struct intel_encoder *intel_encoder = to_intel_encoder(connector); 2467 2467 + struct intel_sdvo_priv *sdvo_priv = intel_encoder->dev_priv; 2473 2468 struct intel_sdvo_enhancements_reply sdvo_data; 2474 2469 struct drm_device *dev = connector->dev; 2475 2470 uint8_t status; 2476 2471 uint16_t response, data_value[2]; 2477 2472 2478 2478 - intel_sdvo_write_cmd(intel_output, SDVO_CMD_GET_SUPPORTED_ENHANCEMENTS, 2473 2473 + intel_sdvo_write_cmd(intel_encoder, SDVO_CMD_GET_SUPPORTED_ENHANCEMENTS, 2479 2474 NULL, 0); 2480 2480 - status = intel_sdvo_read_response(intel_output, &sdvo_data, 2475 2475 + status = intel_sdvo_read_response(intel_encoder, &sdvo_data, 2481 2476 sizeof(sdvo_data)); 2482 2477 if (status != SDVO_CMD_STATUS_SUCCESS) { 2483 2478 DRM_DEBUG_KMS(" incorrect response is returned\n"); ··· 2493 2488 * property 2494 2489 */ 2495 2490 if (sdvo_data.overscan_h) { 2496 2496 - intel_sdvo_write_cmd(intel_output, 2491 2491 + intel_sdvo_write_cmd(intel_encoder, 2497 2492 SDVO_CMD_GET_MAX_OVERSCAN_H, NULL, 0); 2498 2498 - status = intel_sdvo_read_response(intel_output, 2493 2493 + status = intel_sdvo_read_response(intel_encoder, 2499 2494 &data_value, 4); 2500 2495 if (status != SDVO_CMD_STATUS_SUCCESS) { 2501 2496 DRM_DEBUG_KMS("Incorrect SDVO max " 2502 2497 "h_overscan\n"); 2503 2498 return; 2504 2499 } 2505 2505 - intel_sdvo_write_cmd(intel_output, 2500 2500 + intel_sdvo_write_cmd(intel_encoder, 2506 2501 SDVO_CMD_GET_OVERSCAN_H, NULL, 0); 2507 2507 - status = intel_sdvo_read_response(intel_output, 2502 2502 + status = intel_sdvo_read_response(intel_encoder, 2508 2503 &response, 2); 2509 2504 if (status != SDVO_CMD_STATUS_SUCCESS) { 2510 2505 DRM_DEBUG_KMS("Incorrect SDVO h_overscan\n"); ··· 2534 2529 data_value[0], data_value[1], response); 2535 2530 } 2536 2531 if (sdvo_data.overscan_v) { 2537 2537 - intel_sdvo_write_cmd(intel_output, 2532 2532 + intel_sdvo_write_cmd(intel_encoder, 2538 2533 SDVO_CMD_GET_MAX_OVERSCAN_V, NULL, 0); 2539 2539 - status = intel_sdvo_read_response(intel_output, 2534 2534 + status = intel_sdvo_read_response(intel_encoder, 2540 2535 &data_value, 4); 2541 2536 if (status != SDVO_CMD_STATUS_SUCCESS) { 2542 2537 DRM_DEBUG_KMS("Incorrect SDVO max " 2543 2538 "v_overscan\n"); 2544 2539 return; 2545 2540 } 2546 2546 - intel_sdvo_write_cmd(intel_output, 2541 2541 + intel_sdvo_write_cmd(intel_encoder, 2547 2542 SDVO_CMD_GET_OVERSCAN_V, NULL, 0); 2548 2548 - status = intel_sdvo_read_response(intel_output, 2543 2543 + status = intel_sdvo_read_response(intel_encoder, 2549 2544 &response, 2); 2550 2545 if (status != SDVO_CMD_STATUS_SUCCESS) { 2551 2546 DRM_DEBUG_KMS("Incorrect SDVO v_overscan\n"); ··· 2575 2570 data_value[0], data_value[1], response); 2576 2571 } 2577 2572 if (sdvo_data.position_h) { 2578 2578 - intel_sdvo_write_cmd(intel_output, 2573 2573 + intel_sdvo_write_cmd(intel_encoder, 2579 2574 SDVO_CMD_GET_MAX_POSITION_H, NULL, 0); 2580 2580 - status = intel_sdvo_read_response(intel_output, 2575 2575 + status = intel_sdvo_read_response(intel_encoder, 2581 2576 &data_value, 4); 2582 2577 if (status != SDVO_CMD_STATUS_SUCCESS) { 2583 2578 DRM_DEBUG_KMS("Incorrect SDVO Max h_pos\n"); 2584 2579 return; 2585 2580 } 2586 2586 - intel_sdvo_write_cmd(intel_output, 2581 2581 + intel_sdvo_write_cmd(intel_encoder, 2587 2582 SDVO_CMD_GET_POSITION_H, NULL, 0); 2588 2588 - status = intel_sdvo_read_response(intel_output, 2583 2583 + status = intel_sdvo_read_response(intel_encoder, 2589 2584 &response, 2); 2590 2585 if (status != SDVO_CMD_STATUS_SUCCESS) { 2591 2586 DRM_DEBUG_KMS("Incorrect SDVO get h_postion\n"); ··· 2606 2601 data_value[0], data_value[1], response); 2607 2602 } 2608 2603 if (sdvo_data.position_v) { 2609 2609 - intel_sdvo_write_cmd(intel_output, 2604 2604 + intel_sdvo_write_cmd(intel_encoder, 2610 2605 SDVO_CMD_GET_MAX_POSITION_V, NULL, 0); 2611 2611 - status = intel_sdvo_read_response(intel_output, 2606 2606 + status = intel_sdvo_read_response(intel_encoder, 2612 2607 &data_value, 4); 2613 2608 if (status != SDVO_CMD_STATUS_SUCCESS) { 2614 2609 DRM_DEBUG_KMS("Incorrect SDVO Max v_pos\n"); 2615 2610 return; 2616 2611 } 2617 2617 - intel_sdvo_write_cmd(intel_output, 2612 2612 + intel_sdvo_write_cmd(intel_encoder, 2618 2613 SDVO_CMD_GET_POSITION_V, NULL, 0); 2619 2619 - status = intel_sdvo_read_response(intel_output, 2614 2614 + status = intel_sdvo_read_response(intel_encoder, 2620 2615 &response, 2); 2621 2616 if (status != SDVO_CMD_STATUS_SUCCESS) { 2622 2617 DRM_DEBUG_KMS("Incorrect SDVO get v_postion\n"); ··· 2639 2634 } 2640 2635 if (sdvo_priv->is_tv) { 2641 2636 if (sdvo_data.saturation) { 2642 2642 - intel_sdvo_write_cmd(intel_output, 2637 2637 + intel_sdvo_write_cmd(intel_encoder, 2643 2638 SDVO_CMD_GET_MAX_SATURATION, NULL, 0); 2644 2644 - status = intel_sdvo_read_response(intel_output, 2639 2639 + status = intel_sdvo_read_response(intel_encoder, 2645 2640 &data_value, 4); 2646 2641 if (status != SDVO_CMD_STATUS_SUCCESS) { 2647 2642 DRM_DEBUG_KMS("Incorrect SDVO Max sat\n"); 2648 2643 return; 2649 2644 } 2650 2650 - intel_sdvo_write_cmd(intel_output, 2645 2645 + intel_sdvo_write_cmd(intel_encoder, 2651 2646 SDVO_CMD_GET_SATURATION, NULL, 0); 2652 2652 - status = intel_sdvo_read_response(intel_output, 2647 2647 + status = intel_sdvo_read_response(intel_encoder, 2653 2648 &response, 2); 2654 2649 if (status != SDVO_CMD_STATUS_SUCCESS) { 2655 2650 DRM_DEBUG_KMS("Incorrect SDVO get sat\n"); ··· 2671 2666 data_value[0], data_value[1], response); 2672 2667 } 2673 2668 if (sdvo_data.contrast) { 2674 2674 - intel_sdvo_write_cmd(intel_output, 2669 2669 + intel_sdvo_write_cmd(intel_encoder, 2675 2670 SDVO_CMD_GET_MAX_CONTRAST, NULL, 0); 2676 2676 - status = intel_sdvo_read_response(intel_output, 2671 2671 + status = intel_sdvo_read_response(intel_encoder, 2677 2672 &data_value, 4); 2678 2673 if (status != SDVO_CMD_STATUS_SUCCESS) { 2679 2674 DRM_DEBUG_KMS("Incorrect SDVO Max contrast\n"); 2680 2675 return; 2681 2676 } 2682 2682 - intel_sdvo_write_cmd(intel_output, 2677 2677 + intel_sdvo_write_cmd(intel_encoder, 2683 2678 SDVO_CMD_GET_CONTRAST, NULL, 0); 2684 2684 - status = intel_sdvo_read_response(intel_output, 2679 2679 + status = intel_sdvo_read_response(intel_encoder, 2685 2680 &response, 2); 2686 2681 if (status != SDVO_CMD_STATUS_SUCCESS) { 2687 2682 DRM_DEBUG_KMS("Incorrect SDVO get contrast\n"); ··· 2702 2697 data_value[0], data_value[1], response); 2703 2698 } 2704 2699 if (sdvo_data.hue) { 2705 2705 - intel_sdvo_write_cmd(intel_output, 2700 2700 + intel_sdvo_write_cmd(intel_encoder, 2706 2701 SDVO_CMD_GET_MAX_HUE, NULL, 0); 2707 2707 - status = intel_sdvo_read_response(intel_output, 2702 2702 + status = intel_sdvo_read_response(intel_encoder, 2708 2703 &data_value, 4); 2709 2704 if (status != SDVO_CMD_STATUS_SUCCESS) { 2710 2705 DRM_DEBUG_KMS("Incorrect SDVO Max hue\n"); 2711 2706 return; 2712 2707 } 2713 2713 - intel_sdvo_write_cmd(intel_output, 2708 2708 + intel_sdvo_write_cmd(intel_encoder, 2714 2709 SDVO_CMD_GET_HUE, NULL, 0); 2715 2715 - status = intel_sdvo_read_response(intel_output, 2710 2710 + status = intel_sdvo_read_response(intel_encoder, 2716 2711 &response, 2); 2717 2712 if (status != SDVO_CMD_STATUS_SUCCESS) { 2718 2713 DRM_DEBUG_KMS("Incorrect SDVO get hue\n"); ··· 2735 2730 } 2736 2731 if (sdvo_priv->is_tv || sdvo_priv->is_lvds) { 2737 2732 if (sdvo_data.brightness) { 2738 2738 - intel_sdvo_write_cmd(intel_output, 2733 2733 + intel_sdvo_write_cmd(intel_encoder, 2739 2734 SDVO_CMD_GET_MAX_BRIGHTNESS, NULL, 0); 2740 2740 - status = intel_sdvo_read_response(intel_output, 2735 2735 + status = intel_sdvo_read_response(intel_encoder, 2741 2736 &data_value, 4); 2742 2737 if (status != SDVO_CMD_STATUS_SUCCESS) { 2743 2738 DRM_DEBUG_KMS("Incorrect SDVO Max bright\n"); 2744 2739 return; 2745 2740 } 2746 2746 - intel_sdvo_write_cmd(intel_output, 2741 2741 + intel_sdvo_write_cmd(intel_encoder, 2747 2742 SDVO_CMD_GET_BRIGHTNESS, NULL, 0); 2748 2748 - status = intel_sdvo_read_response(intel_output, 2743 2743 + status = intel_sdvo_read_response(intel_encoder, 2749 2744 &response, 2); 2750 2745 if (status != SDVO_CMD_STATUS_SUCCESS) { 2751 2746 DRM_DEBUG_KMS("Incorrect SDVO get brigh\n"); ··· 2770 2765 return; 2771 2766 } 2772 2767 2773 2773 - bool intel_sdvo_init(struct drm_device *dev, int output_device) 2768 2768 + bool intel_sdvo_init(struct drm_device *dev, int sdvo_reg) 2774 2769 { 2775 2770 struct drm_i915_private *dev_priv = dev->dev_private; 2776 2771 struct drm_connector *connector; 2777 2777 - struct intel_output *intel_output; 2772 2772 + struct intel_encoder *intel_encoder; 2778 2773 struct intel_sdvo_priv *sdvo_priv; 2779 2774 2780 2775 u8 ch[0x40]; 2781 2776 int i; 2782 2777 2783 2783 - intel_output = kcalloc(sizeof(struct intel_output)+sizeof(struct intel_sdvo_priv), 1, GFP_KERNEL); 2784 2784 - if (!intel_output) { 2778 2778 + intel_encoder = kcalloc(sizeof(struct intel_encoder)+sizeof(struct intel_sdvo_priv), 1, GFP_KERNEL); 2779 2779 + if (!intel_encoder) { 2785 2780 return false; 2786 2781 } 2787 2782 2788 2788 - sdvo_priv = (struct intel_sdvo_priv *)(intel_output + 1); 2789 2789 - sdvo_priv->output_device = output_device; 2783 2783 + sdvo_priv = (struct intel_sdvo_priv *)(intel_encoder + 1); 2784 2784 + sdvo_priv->sdvo_reg = sdvo_reg; 2790 2785 2791 2791 - intel_output->dev_priv = sdvo_priv; 2792 2792 - intel_output->type = INTEL_OUTPUT_SDVO; 2786 2786 + intel_encoder->dev_priv = sdvo_priv; 2787 2787 + intel_encoder->type = INTEL_OUTPUT_SDVO; 2793 2788 2794 2789 /* setup the DDC bus. */ 2795 2795 - if (output_device == SDVOB) 2796 2796 - intel_output->i2c_bus = intel_i2c_create(dev, GPIOE, "SDVOCTRL_E for SDVOB"); 2790 2790 + if (sdvo_reg == SDVOB) 2791 2791 + intel_encoder->i2c_bus = intel_i2c_create(dev, GPIOE, "SDVOCTRL_E for SDVOB"); 2797 2792 else 2798 2798 - intel_output->i2c_bus = intel_i2c_create(dev, GPIOE, "SDVOCTRL_E for SDVOC"); 2793 2793 + intel_encoder->i2c_bus = intel_i2c_create(dev, GPIOE, "SDVOCTRL_E for SDVOC"); 2799 2794 2800 2800 - if (!intel_output->i2c_bus) 2795 2795 + if (!intel_encoder->i2c_bus) 2801 2796 goto err_inteloutput; 2802 2797 2803 2803 - sdvo_priv->slave_addr = intel_sdvo_get_slave_addr(dev, output_device); 2798 2798 + sdvo_priv->slave_addr = intel_sdvo_get_slave_addr(dev, sdvo_reg); 2804 2799 2805 2800 /* Save the bit-banging i2c functionality for use by the DDC wrapper */ 2806 2806 - intel_sdvo_i2c_bit_algo.functionality = intel_output->i2c_bus->algo->functionality; 2801 2801 + intel_sdvo_i2c_bit_algo.functionality = intel_encoder->i2c_bus->algo->functionality; 2807 2802 2808 2803 /* Read the regs to test if we can talk to the device */ 2809 2804 for (i = 0; i < 0x40; i++) { 2810 2810 - if (!intel_sdvo_read_byte(intel_output, i, &ch[i])) { 2805 2805 + if (!intel_sdvo_read_byte(intel_encoder, i, &ch[i])) { 2811 2806 DRM_DEBUG_KMS("No SDVO device found on SDVO%c\n", 2812 2812 - output_device == SDVOB ? 'B' : 'C'); 2807 2807 + sdvo_reg == SDVOB ? 'B' : 'C'); 2813 2808 goto err_i2c; 2814 2809 } 2815 2810 } 2816 2811 2817 2812 /* setup the DDC bus. */ 2818 2818 - if (output_device == SDVOB) { 2819 2819 - intel_output->ddc_bus = intel_i2c_create(dev, GPIOE, "SDVOB DDC BUS"); 2813 2813 + if (sdvo_reg == SDVOB) { 2814 2814 + intel_encoder->ddc_bus = intel_i2c_create(dev, GPIOE, "SDVOB DDC BUS"); 2820 2815 sdvo_priv->analog_ddc_bus = intel_i2c_create(dev, GPIOA, 2821 2816 "SDVOB/VGA DDC BUS"); 2822 2817 dev_priv->hotplug_supported_mask |= SDVOB_HOTPLUG_INT_STATUS; 2823 2818 } else { 2824 2824 - intel_output->ddc_bus = intel_i2c_create(dev, GPIOE, "SDVOC DDC BUS"); 2819 2819 + intel_encoder->ddc_bus = intel_i2c_create(dev, GPIOE, "SDVOC DDC BUS"); 2825 2820 sdvo_priv->analog_ddc_bus = intel_i2c_create(dev, GPIOA, 2826 2821 "SDVOC/VGA DDC BUS"); 2827 2822 dev_priv->hotplug_supported_mask |= SDVOC_HOTPLUG_INT_STATUS; 2828 2823 } 2829 2824 2830 2830 - if (intel_output->ddc_bus == NULL) 2825 2825 + if (intel_encoder->ddc_bus == NULL) 2831 2826 goto err_i2c; 2832 2827 2833 2828 /* Wrap with our custom algo which switches to DDC mode */ 2834 2834 - intel_output->ddc_bus->algo = &intel_sdvo_i2c_bit_algo; 2829 2829 + intel_encoder->ddc_bus->algo = &intel_sdvo_i2c_bit_algo; 2835 2830 2836 2831 /* In default case sdvo lvds is false */ 2837 2837 - intel_sdvo_get_capabilities(intel_output, &sdvo_priv->caps); 2832 2832 + intel_sdvo_get_capabilities(intel_encoder, &sdvo_priv->caps); 2838 2833 2839 2839 - if (intel_sdvo_output_setup(intel_output, 2834 2834 + if (intel_sdvo_output_setup(intel_encoder, 2840 2835 sdvo_priv->caps.output_flags) != true) { 2841 2836 DRM_DEBUG_KMS("SDVO output failed to setup on SDVO%c\n", 2842 2842 - output_device == SDVOB ? 'B' : 'C'); 2837 2837 + sdvo_reg == SDVOB ? 'B' : 'C'); 2843 2838 goto err_i2c; 2844 2839 } 2845 2840 2846 2841 2847 2847 - connector = &intel_output->base; 2842 2842 + connector = &intel_encoder->base; 2848 2843 drm_connector_init(dev, connector, &intel_sdvo_connector_funcs, 2849 2844 connector->connector_type); 2850 2845 ··· 2853 2848 connector->doublescan_allowed = 0; 2854 2849 connector->display_info.subpixel_order = SubPixelHorizontalRGB; 2855 2850 2856 2856 - drm_encoder_init(dev, &intel_output->enc, 2857 2857 - &intel_sdvo_enc_funcs, intel_output->enc.encoder_type); 2851 2851 + drm_encoder_init(dev, &intel_encoder->enc, 2852 2852 + &intel_sdvo_enc_funcs, intel_encoder->enc.encoder_type); 2858 2853 2859 2859 - drm_encoder_helper_add(&intel_output->enc, &intel_sdvo_helper_funcs); 2854 2854 + drm_encoder_helper_add(&intel_encoder->enc, &intel_sdvo_helper_funcs); 2860 2855 2861 2861 - drm_mode_connector_attach_encoder(&intel_output->base, &intel_output->enc); 2856 2856 + drm_mode_connector_attach_encoder(&intel_encoder->base, &intel_encoder->enc); 2862 2857 if (sdvo_priv->is_tv) 2863 2858 intel_sdvo_tv_create_property(connector); 2864 2859 ··· 2870 2865 intel_sdvo_select_ddc_bus(sdvo_priv); 2871 2866 2872 2867 /* Set the input timing to the screen. Assume always input 0. */ 2873 2873 - intel_sdvo_set_target_input(intel_output, true, false); 2868 2868 + intel_sdvo_set_target_input(intel_encoder, true, false); 2874 2869 2875 2875 - intel_sdvo_get_input_pixel_clock_range(intel_output, 2870 2870 + intel_sdvo_get_input_pixel_clock_range(intel_encoder, 2876 2871 &sdvo_priv->pixel_clock_min, 2877 2872 &sdvo_priv->pixel_clock_max); 2878 2873 ··· 2899 2894 err_i2c: 2900 2895 if (sdvo_priv->analog_ddc_bus != NULL) 2901 2896 intel_i2c_destroy(sdvo_priv->analog_ddc_bus); 2902 2902 - if (intel_output->ddc_bus != NULL) 2903 2903 - intel_i2c_destroy(intel_output->ddc_bus); 2904 2904 - if (intel_output->i2c_bus != NULL) 2905 2905 - intel_i2c_destroy(intel_output->i2c_bus); 2897 2897 + if (intel_encoder->ddc_bus != NULL) 2898 2898 + intel_i2c_destroy(intel_encoder->ddc_bus); 2899 2899 + if (intel_encoder->i2c_bus != NULL) 2900 2900 + intel_i2c_destroy(intel_encoder->i2c_bus); 2906 2901 err_inteloutput: 2907 2907 - kfree(intel_output); 2902 2902 + kfree(intel_encoder); 2908 2903 2909 2904 return false; 2910 2905 }

+48 -48

drivers/gpu/drm/i915/intel_tv.c

reviewed

··· 921 921 { 922 922 struct drm_device *dev = connector->dev; 923 923 struct drm_i915_private *dev_priv = dev->dev_private; 924 924 - struct intel_output *intel_output = to_intel_output(connector); 925 925 - struct intel_tv_priv *tv_priv = intel_output->dev_priv; 924 924 + struct intel_encoder *intel_encoder = to_intel_encoder(connector); 925 925 + struct intel_tv_priv *tv_priv = intel_encoder->dev_priv; 926 926 int i; 927 927 928 928 tv_priv->save_TV_H_CTL_1 = I915_READ(TV_H_CTL_1); ··· 971 971 { 972 972 struct drm_device *dev = connector->dev; 973 973 struct drm_i915_private *dev_priv = dev->dev_private; 974 974 - struct intel_output *intel_output = to_intel_output(connector); 975 975 - struct intel_tv_priv *tv_priv = intel_output->dev_priv; 974 974 + struct intel_encoder *intel_encoder = to_intel_encoder(connector); 975 975 + struct intel_tv_priv *tv_priv = intel_encoder->dev_priv; 976 976 struct drm_crtc *crtc = connector->encoder->crtc; 977 977 struct intel_crtc *intel_crtc; 978 978 int i; ··· 1068 1068 } 1069 1069 1070 1070 static const struct tv_mode * 1071 1071 - intel_tv_mode_find (struct intel_output *intel_output) 1071 1071 + intel_tv_mode_find (struct intel_encoder *intel_encoder) 1072 1072 { 1073 1073 - struct intel_tv_priv *tv_priv = intel_output->dev_priv; 1073 1073 + struct intel_tv_priv *tv_priv = intel_encoder->dev_priv; 1074 1074 1075 1075 return intel_tv_mode_lookup(tv_priv->tv_format); 1076 1076 } ··· 1078 1078 static enum drm_mode_status 1079 1079 intel_tv_mode_valid(struct drm_connector *connector, struct drm_display_mode *mode) 1080 1080 { 1081 1081 - struct intel_output *intel_output = to_intel_output(connector); 1082 1082 - const struct tv_mode *tv_mode = intel_tv_mode_find(intel_output); 1081 1081 + struct intel_encoder *intel_encoder = to_intel_encoder(connector); 1082 1082 + const struct tv_mode *tv_mode = intel_tv_mode_find(intel_encoder); 1083 1083 1084 1084 /* Ensure TV refresh is close to desired refresh */ 1085 1085 if (tv_mode && abs(tv_mode->refresh - drm_mode_vrefresh(mode) * 1000) ··· 1095 1095 { 1096 1096 struct drm_device *dev = encoder->dev; 1097 1097 struct drm_mode_config *drm_config = &dev->mode_config; 1098 1098 - struct intel_output *intel_output = enc_to_intel_output(encoder); 1099 1099 - const struct tv_mode *tv_mode = intel_tv_mode_find (intel_output); 1098 1098 + struct intel_encoder *intel_encoder = enc_to_intel_encoder(encoder); 1099 1099 + const struct tv_mode *tv_mode = intel_tv_mode_find (intel_encoder); 1100 1100 struct drm_encoder *other_encoder; 1101 1101 1102 1102 if (!tv_mode) ··· 1121 1121 struct drm_i915_private *dev_priv = dev->dev_private; 1122 1122 struct drm_crtc *crtc = encoder->crtc; 1123 1123 struct intel_crtc *intel_crtc = to_intel_crtc(crtc); 1124 1124 - struct intel_output *intel_output = enc_to_intel_output(encoder); 1125 1125 - struct intel_tv_priv *tv_priv = intel_output->dev_priv; 1126 1126 - const struct tv_mode *tv_mode = intel_tv_mode_find(intel_output); 1124 1124 + struct intel_encoder *intel_encoder = enc_to_intel_encoder(encoder); 1125 1125 + struct intel_tv_priv *tv_priv = intel_encoder->dev_priv; 1126 1126 + const struct tv_mode *tv_mode = intel_tv_mode_find(intel_encoder); 1127 1127 u32 tv_ctl; 1128 1128 u32 hctl1, hctl2, hctl3; 1129 1129 u32 vctl1, vctl2, vctl3, vctl4, vctl5, vctl6, vctl7; ··· 1360 1360 * \return false if TV is disconnected. 1361 1361 */ 1362 1362 static int 1363 1363 - intel_tv_detect_type (struct drm_crtc *crtc, struct intel_output *intel_output) 1363 1363 + intel_tv_detect_type (struct drm_crtc *crtc, struct intel_encoder *intel_encoder) 1364 1364 { 1365 1365 - struct drm_encoder *encoder = &intel_output->enc; 1365 1365 + struct drm_encoder *encoder = &intel_encoder->enc; 1366 1366 struct drm_device *dev = encoder->dev; 1367 1367 struct drm_i915_private *dev_priv = dev->dev_private; 1368 1368 unsigned long irqflags; ··· 1441 1441 */ 1442 1442 static void intel_tv_find_better_format(struct drm_connector *connector) 1443 1443 { 1444 1444 - struct intel_output *intel_output = to_intel_output(connector); 1445 1445 - struct intel_tv_priv *tv_priv = intel_output->dev_priv; 1446 1446 - const struct tv_mode *tv_mode = intel_tv_mode_find(intel_output); 1444 1444 + struct intel_encoder *intel_encoder = to_intel_encoder(connector); 1445 1445 + struct intel_tv_priv *tv_priv = intel_encoder->dev_priv; 1446 1446 + const struct tv_mode *tv_mode = intel_tv_mode_find(intel_encoder); 1447 1447 int i; 1448 1448 1449 1449 if ((tv_priv->type == DRM_MODE_CONNECTOR_Component) == ··· 1475 1475 { 1476 1476 struct drm_crtc *crtc; 1477 1477 struct drm_display_mode mode; 1478 1478 - struct intel_output *intel_output = to_intel_output(connector); 1479 1479 - struct intel_tv_priv *tv_priv = intel_output->dev_priv; 1480 1480 - struct drm_encoder *encoder = &intel_output->enc; 1478 1478 + struct intel_encoder *intel_encoder = to_intel_encoder(connector); 1479 1479 + struct intel_tv_priv *tv_priv = intel_encoder->dev_priv; 1480 1480 + struct drm_encoder *encoder = &intel_encoder->enc; 1481 1481 int dpms_mode; 1482 1482 int type = tv_priv->type; 1483 1483 ··· 1485 1485 drm_mode_set_crtcinfo(&mode, CRTC_INTERLACE_HALVE_V); 1486 1486 1487 1487 if (encoder->crtc && encoder->crtc->enabled) { 1488 1488 - type = intel_tv_detect_type(encoder->crtc, intel_output); 1488 1488 + type = intel_tv_detect_type(encoder->crtc, intel_encoder); 1489 1489 } else { 1490 1490 - crtc = intel_get_load_detect_pipe(intel_output, &mode, &dpms_mode); 1490 1490 + crtc = intel_get_load_detect_pipe(intel_encoder, &mode, &dpms_mode); 1491 1491 if (crtc) { 1492 1492 - type = intel_tv_detect_type(crtc, intel_output); 1493 1493 - intel_release_load_detect_pipe(intel_output, dpms_mode); 1492 1492 + type = intel_tv_detect_type(crtc, intel_encoder); 1493 1493 + intel_release_load_detect_pipe(intel_encoder, dpms_mode); 1494 1494 } else 1495 1495 type = -1; 1496 1496 } ··· 1525 1525 intel_tv_chose_preferred_modes(struct drm_connector *connector, 1526 1526 struct drm_display_mode *mode_ptr) 1527 1527 { 1528 1528 - struct intel_output *intel_output = to_intel_output(connector); 1529 1529 - const struct tv_mode *tv_mode = intel_tv_mode_find(intel_output); 1528 1528 + struct intel_encoder *intel_encoder = to_intel_encoder(connector); 1529 1529 + const struct tv_mode *tv_mode = intel_tv_mode_find(intel_encoder); 1530 1530 1531 1531 if (tv_mode->nbr_end < 480 && mode_ptr->vdisplay == 480) 1532 1532 mode_ptr->type |= DRM_MODE_TYPE_PREFERRED; ··· 1550 1550 intel_tv_get_modes(struct drm_connector *connector) 1551 1551 { 1552 1552 struct drm_display_mode *mode_ptr; 1553 1553 - struct intel_output *intel_output = to_intel_output(connector); 1554 1554 - const struct tv_mode *tv_mode = intel_tv_mode_find(intel_output); 1553 1553 + struct intel_encoder *intel_encoder = to_intel_encoder(connector); 1554 1554 + const struct tv_mode *tv_mode = intel_tv_mode_find(intel_encoder); 1555 1555 int j, count = 0; 1556 1556 u64 tmp; 1557 1557 ··· 1604 1604 static void 1605 1605 intel_tv_destroy (struct drm_connector *connector) 1606 1606 { 1607 1607 - struct intel_output *intel_output = to_intel_output(connector); 1607 1607 + struct intel_encoder *intel_encoder = to_intel_encoder(connector); 1608 1608 1609 1609 drm_sysfs_connector_remove(connector); 1610 1610 drm_connector_cleanup(connector); 1611 1611 - kfree(intel_output); 1611 1611 + kfree(intel_encoder); 1612 1612 } 1613 1613 1614 1614 ··· 1617 1617 uint64_t val) 1618 1618 { 1619 1619 struct drm_device *dev = connector->dev; 1620 1620 - struct intel_output *intel_output = to_intel_output(connector); 1621 1621 - struct intel_tv_priv *tv_priv = intel_output->dev_priv; 1622 1622 - struct drm_encoder *encoder = &intel_output->enc; 1620 1620 + struct intel_encoder *intel_encoder = to_intel_encoder(connector); 1621 1621 + struct intel_tv_priv *tv_priv = intel_encoder->dev_priv; 1622 1622 + struct drm_encoder *encoder = &intel_encoder->enc; 1623 1623 struct drm_crtc *crtc = encoder->crtc; 1624 1624 int ret = 0; 1625 1625 bool changed = false; ··· 1740 1740 { 1741 1741 struct drm_i915_private *dev_priv = dev->dev_private; 1742 1742 struct drm_connector *connector; 1743 1743 - struct intel_output *intel_output; 1743 1743 + struct intel_encoder *intel_encoder; 1744 1744 struct intel_tv_priv *tv_priv; 1745 1745 u32 tv_dac_on, tv_dac_off, save_tv_dac; 1746 1746 char **tv_format_names; ··· 1780 1780 (tv_dac_off & TVDAC_STATE_CHG_EN) != 0) 1781 1781 return; 1782 1782 1783 1783 - intel_output = kzalloc(sizeof(struct intel_output) + 1783 1783 + intel_encoder = kzalloc(sizeof(struct intel_encoder) + 1784 1784 sizeof(struct intel_tv_priv), GFP_KERNEL); 1785 1785 - if (!intel_output) { 1785 1785 + if (!intel_encoder) { 1786 1786 return; 1787 1787 } 1788 1788 1789 1789 - connector = &intel_output->base; 1789 1789 + connector = &intel_encoder->base; 1790 1790 1791 1791 drm_connector_init(dev, connector, &intel_tv_connector_funcs, 1792 1792 DRM_MODE_CONNECTOR_SVIDEO); 1793 1793 1794 1794 - drm_encoder_init(dev, &intel_output->enc, &intel_tv_enc_funcs, 1794 1794 + drm_encoder_init(dev, &intel_encoder->enc, &intel_tv_enc_funcs, 1795 1795 DRM_MODE_ENCODER_TVDAC); 1796 1796 1797 1797 - drm_mode_connector_attach_encoder(&intel_output->base, &intel_output->enc); 1798 1798 - tv_priv = (struct intel_tv_priv *)(intel_output + 1); 1799 1799 - intel_output->type = INTEL_OUTPUT_TVOUT; 1800 1800 - intel_output->crtc_mask = (1 << 0) | (1 << 1); 1801 1801 - intel_output->clone_mask = (1 << INTEL_TV_CLONE_BIT); 1802 1802 - intel_output->enc.possible_crtcs = ((1 << 0) | (1 << 1)); 1803 1803 - intel_output->enc.possible_clones = (1 << INTEL_OUTPUT_TVOUT); 1804 1804 - intel_output->dev_priv = tv_priv; 1797 1797 + drm_mode_connector_attach_encoder(&intel_encoder->base, &intel_encoder->enc); 1798 1798 + tv_priv = (struct intel_tv_priv *)(intel_encoder + 1); 1799 1799 + intel_encoder->type = INTEL_OUTPUT_TVOUT; 1800 1800 + intel_encoder->crtc_mask = (1 << 0) | (1 << 1); 1801 1801 + intel_encoder->clone_mask = (1 << INTEL_TV_CLONE_BIT); 1802 1802 + intel_encoder->enc.possible_crtcs = ((1 << 0) | (1 << 1)); 1803 1803 + intel_encoder->enc.possible_clones = (1 << INTEL_OUTPUT_TVOUT); 1804 1804 + intel_encoder->dev_priv = tv_priv; 1805 1805 tv_priv->type = DRM_MODE_CONNECTOR_Unknown; 1806 1806 1807 1807 /* BIOS margin values */ ··· 1812 1812 1813 1813 tv_priv->tv_format = kstrdup(tv_modes[initial_mode].name, GFP_KERNEL); 1814 1814 1815 1815 - drm_encoder_helper_add(&intel_output->enc, &intel_tv_helper_funcs); 1815 1815 + drm_encoder_helper_add(&intel_encoder->enc, &intel_tv_helper_funcs); 1816 1816 drm_connector_helper_add(connector, &intel_tv_connector_helper_funcs); 1817 1817 connector->interlace_allowed = false; 1818 1818 connector->doublescan_allowed = false;