diff options
28 files changed, 1118 insertions, 92 deletions
diff --git a/drivers/gpu/drm/nouveau/Kconfig b/drivers/gpu/drm/nouveau/Kconfig index d823e6319516..b1bc1ea182b8 100644 --- a/drivers/gpu/drm/nouveau/Kconfig +++ b/drivers/gpu/drm/nouveau/Kconfig | |||
@@ -30,11 +30,12 @@ config DRM_NOUVEAU_DEBUG | |||
30 | via debugfs. | 30 | via debugfs. |
31 | 31 | ||
32 | menu "I2C encoder or helper chips" | 32 | menu "I2C encoder or helper chips" |
33 | depends on DRM | 33 | depends on DRM && I2C |
34 | 34 | ||
35 | config DRM_I2C_CH7006 | 35 | config DRM_I2C_CH7006 |
36 | tristate "Chrontel ch7006 TV encoder" | 36 | tristate "Chrontel ch7006 TV encoder" |
37 | default m if DRM_NOUVEAU | 37 | depends on DRM_NOUVEAU |
38 | default m | ||
38 | help | 39 | help |
39 | Support for Chrontel ch7006 and similar TV encoders, found | 40 | Support for Chrontel ch7006 and similar TV encoders, found |
40 | on some nVidia video cards. | 41 | on some nVidia video cards. |
diff --git a/drivers/gpu/drm/nouveau/nouveau_bo.c b/drivers/gpu/drm/nouveau/nouveau_bo.c index 320a14bceb99..aa2dfbc3e351 100644 --- a/drivers/gpu/drm/nouveau/nouveau_bo.c +++ b/drivers/gpu/drm/nouveau/nouveau_bo.c | |||
@@ -311,8 +311,10 @@ nouveau_bo_create_ttm_backend_entry(struct ttm_bo_device *bdev) | |||
311 | struct drm_device *dev = dev_priv->dev; | 311 | struct drm_device *dev = dev_priv->dev; |
312 | 312 | ||
313 | switch (dev_priv->gart_info.type) { | 313 | switch (dev_priv->gart_info.type) { |
314 | #if __OS_HAS_AGP | ||
314 | case NOUVEAU_GART_AGP: | 315 | case NOUVEAU_GART_AGP: |
315 | return ttm_agp_backend_init(bdev, dev->agp->bridge); | 316 | return ttm_agp_backend_init(bdev, dev->agp->bridge); |
317 | #endif | ||
316 | case NOUVEAU_GART_SGDMA: | 318 | case NOUVEAU_GART_SGDMA: |
317 | return nouveau_sgdma_init_ttm(dev); | 319 | return nouveau_sgdma_init_ttm(dev); |
318 | default: | 320 | default: |
diff --git a/drivers/gpu/drm/nouveau/nouveau_fence.c b/drivers/gpu/drm/nouveau/nouveau_fence.c index 0cff7eb3690a..dacac9a0842a 100644 --- a/drivers/gpu/drm/nouveau/nouveau_fence.c +++ b/drivers/gpu/drm/nouveau/nouveau_fence.c | |||
@@ -205,7 +205,7 @@ nouveau_fence_wait(void *sync_obj, void *sync_arg, bool lazy, bool intr) | |||
205 | schedule_timeout(1); | 205 | schedule_timeout(1); |
206 | 206 | ||
207 | if (intr && signal_pending(current)) { | 207 | if (intr && signal_pending(current)) { |
208 | ret = -ERESTART; | 208 | ret = -ERESTARTSYS; |
209 | break; | 209 | break; |
210 | } | 210 | } |
211 | } | 211 | } |
diff --git a/drivers/gpu/drm/nouveau/nouveau_gem.c b/drivers/gpu/drm/nouveau/nouveau_gem.c index 11f831f0ddc5..18fd8ac9fca7 100644 --- a/drivers/gpu/drm/nouveau/nouveau_gem.c +++ b/drivers/gpu/drm/nouveau/nouveau_gem.c | |||
@@ -342,8 +342,6 @@ retry: | |||
342 | } | 342 | } |
343 | 343 | ||
344 | ret = ttm_bo_wait_cpu(&nvbo->bo, false); | 344 | ret = ttm_bo_wait_cpu(&nvbo->bo, false); |
345 | if (ret == -ERESTART) | ||
346 | ret = -EAGAIN; | ||
347 | if (ret) | 345 | if (ret) |
348 | return ret; | 346 | return ret; |
349 | goto retry; | 347 | goto retry; |
@@ -915,8 +913,6 @@ nouveau_gem_ioctl_cpu_prep(struct drm_device *dev, void *data, | |||
915 | goto out; | 913 | goto out; |
916 | 914 | ||
917 | ret = ttm_bo_wait_cpu(&nvbo->bo, no_wait); | 915 | ret = ttm_bo_wait_cpu(&nvbo->bo, no_wait); |
918 | if (ret == -ERESTART) | ||
919 | ret = -EAGAIN; | ||
920 | if (ret) | 916 | if (ret) |
921 | goto out; | 917 | goto out; |
922 | } | 918 | } |
@@ -925,9 +921,6 @@ nouveau_gem_ioctl_cpu_prep(struct drm_device *dev, void *data, | |||
925 | ret = ttm_bo_wait(&nvbo->bo, false, false, no_wait); | 921 | ret = ttm_bo_wait(&nvbo->bo, false, false, no_wait); |
926 | } else { | 922 | } else { |
927 | ret = ttm_bo_synccpu_write_grab(&nvbo->bo, no_wait); | 923 | ret = ttm_bo_synccpu_write_grab(&nvbo->bo, no_wait); |
928 | if (ret == -ERESTART) | ||
929 | ret = -EAGAIN; | ||
930 | else | ||
931 | if (ret == 0) | 924 | if (ret == 0) |
932 | nvbo->cpu_filp = file_priv; | 925 | nvbo->cpu_filp = file_priv; |
933 | } | 926 | } |
diff --git a/drivers/gpu/drm/nouveau/nouveau_mem.c b/drivers/gpu/drm/nouveau/nouveau_mem.c index 02755712ed3d..5158a12f7844 100644 --- a/drivers/gpu/drm/nouveau/nouveau_mem.c +++ b/drivers/gpu/drm/nouveau/nouveau_mem.c | |||
@@ -407,6 +407,7 @@ uint64_t nouveau_mem_fb_amount(struct drm_device *dev) | |||
407 | return 0; | 407 | return 0; |
408 | } | 408 | } |
409 | 409 | ||
410 | #if __OS_HAS_AGP | ||
410 | static void nouveau_mem_reset_agp(struct drm_device *dev) | 411 | static void nouveau_mem_reset_agp(struct drm_device *dev) |
411 | { | 412 | { |
412 | uint32_t saved_pci_nv_1, saved_pci_nv_19, pmc_enable; | 413 | uint32_t saved_pci_nv_1, saved_pci_nv_19, pmc_enable; |
@@ -432,10 +433,12 @@ static void nouveau_mem_reset_agp(struct drm_device *dev) | |||
432 | nv_wr32(dev, NV04_PBUS_PCI_NV_19, saved_pci_nv_19); | 433 | nv_wr32(dev, NV04_PBUS_PCI_NV_19, saved_pci_nv_19); |
433 | nv_wr32(dev, NV04_PBUS_PCI_NV_1, saved_pci_nv_1); | 434 | nv_wr32(dev, NV04_PBUS_PCI_NV_1, saved_pci_nv_1); |
434 | } | 435 | } |
436 | #endif | ||
435 | 437 | ||
436 | int | 438 | int |
437 | nouveau_mem_init_agp(struct drm_device *dev) | 439 | nouveau_mem_init_agp(struct drm_device *dev) |
438 | { | 440 | { |
441 | #if __OS_HAS_AGP | ||
439 | struct drm_nouveau_private *dev_priv = dev->dev_private; | 442 | struct drm_nouveau_private *dev_priv = dev->dev_private; |
440 | struct drm_agp_info info; | 443 | struct drm_agp_info info; |
441 | struct drm_agp_mode mode; | 444 | struct drm_agp_mode mode; |
@@ -471,6 +474,7 @@ nouveau_mem_init_agp(struct drm_device *dev) | |||
471 | dev_priv->gart_info.type = NOUVEAU_GART_AGP; | 474 | dev_priv->gart_info.type = NOUVEAU_GART_AGP; |
472 | dev_priv->gart_info.aper_base = info.aperture_base; | 475 | dev_priv->gart_info.aper_base = info.aperture_base; |
473 | dev_priv->gart_info.aper_size = info.aperture_size; | 476 | dev_priv->gart_info.aper_size = info.aperture_size; |
477 | #endif | ||
474 | return 0; | 478 | return 0; |
475 | } | 479 | } |
476 | 480 | ||
diff --git a/drivers/gpu/drm/nouveau/nv40_graph.c b/drivers/gpu/drm/nouveau/nv40_graph.c index d3e0a2a6acf8..7e8547cb5833 100644 --- a/drivers/gpu/drm/nouveau/nv40_graph.c +++ b/drivers/gpu/drm/nouveau/nv40_graph.c | |||
@@ -252,8 +252,9 @@ nv40_grctx_init(struct drm_device *dev) | |||
252 | memcpy(pgraph->ctxprog, fw->data, fw->size); | 252 | memcpy(pgraph->ctxprog, fw->data, fw->size); |
253 | 253 | ||
254 | cp = pgraph->ctxprog; | 254 | cp = pgraph->ctxprog; |
255 | if (cp->signature != 0x5043564e || cp->version != 0 || | 255 | if (le32_to_cpu(cp->signature) != 0x5043564e || |
256 | cp->length != ((fw->size - 7) / 4)) { | 256 | cp->version != 0 || |
257 | le16_to_cpu(cp->length) != ((fw->size - 7) / 4)) { | ||
257 | NV_ERROR(dev, "ctxprog invalid\n"); | 258 | NV_ERROR(dev, "ctxprog invalid\n"); |
258 | release_firmware(fw); | 259 | release_firmware(fw); |
259 | nv40_grctx_fini(dev); | 260 | nv40_grctx_fini(dev); |
@@ -281,8 +282,9 @@ nv40_grctx_init(struct drm_device *dev) | |||
281 | memcpy(pgraph->ctxvals, fw->data, fw->size); | 282 | memcpy(pgraph->ctxvals, fw->data, fw->size); |
282 | 283 | ||
283 | cv = (void *)pgraph->ctxvals; | 284 | cv = (void *)pgraph->ctxvals; |
284 | if (cv->signature != 0x5643564e || cv->version != 0 || | 285 | if (le32_to_cpu(cv->signature) != 0x5643564e || |
285 | cv->length != ((fw->size - 9) / 8)) { | 286 | cv->version != 0 || |
287 | le32_to_cpu(cv->length) != ((fw->size - 9) / 8)) { | ||
286 | NV_ERROR(dev, "ctxvals invalid\n"); | 288 | NV_ERROR(dev, "ctxvals invalid\n"); |
287 | release_firmware(fw); | 289 | release_firmware(fw); |
288 | nv40_grctx_fini(dev); | 290 | nv40_grctx_fini(dev); |
@@ -294,8 +296,9 @@ nv40_grctx_init(struct drm_device *dev) | |||
294 | cp = pgraph->ctxprog; | 296 | cp = pgraph->ctxprog; |
295 | 297 | ||
296 | nv_wr32(dev, NV40_PGRAPH_CTXCTL_UCODE_INDEX, 0); | 298 | nv_wr32(dev, NV40_PGRAPH_CTXCTL_UCODE_INDEX, 0); |
297 | for (i = 0; i < cp->length; i++) | 299 | for (i = 0; i < le16_to_cpu(cp->length); i++) |
298 | nv_wr32(dev, NV40_PGRAPH_CTXCTL_UCODE_DATA, cp->data[i]); | 300 | nv_wr32(dev, NV40_PGRAPH_CTXCTL_UCODE_DATA, |
301 | le32_to_cpu(cp->data[i])); | ||
299 | 302 | ||
300 | pgraph->accel_blocked = false; | 303 | pgraph->accel_blocked = false; |
301 | return 0; | 304 | return 0; |
@@ -329,8 +332,9 @@ nv40_grctx_vals_load(struct drm_device *dev, struct nouveau_gpuobj *ctx) | |||
329 | if (!cv) | 332 | if (!cv) |
330 | return; | 333 | return; |
331 | 334 | ||
332 | for (i = 0; i < cv->length; i++) | 335 | for (i = 0; i < le32_to_cpu(cv->length); i++) |
333 | nv_wo32(dev, ctx, cv->data[i].offset, cv->data[i].value); | 336 | nv_wo32(dev, ctx, le32_to_cpu(cv->data[i].offset), |
337 | le32_to_cpu(cv->data[i].value)); | ||
334 | } | 338 | } |
335 | 339 | ||
336 | /* | 340 | /* |
diff --git a/drivers/gpu/drm/radeon/Makefile b/drivers/gpu/drm/radeon/Makefile index feb52eee4314..b5f5fe75e6af 100644 --- a/drivers/gpu/drm/radeon/Makefile +++ b/drivers/gpu/drm/radeon/Makefile | |||
@@ -49,7 +49,7 @@ radeon-y += radeon_device.o radeon_kms.o \ | |||
49 | radeon_cs.o radeon_bios.o radeon_benchmark.o r100.o r300.o r420.o \ | 49 | radeon_cs.o radeon_bios.o radeon_benchmark.o r100.o r300.o r420.o \ |
50 | rs400.o rs600.o rs690.o rv515.o r520.o r600.o rv770.o radeon_test.o \ | 50 | rs400.o rs600.o rs690.o rv515.o r520.o r600.o rv770.o radeon_test.o \ |
51 | r200.o radeon_legacy_tv.o r600_cs.o r600_blit.o r600_blit_shaders.o \ | 51 | r200.o radeon_legacy_tv.o r600_cs.o r600_blit.o r600_blit_shaders.o \ |
52 | r600_blit_kms.o radeon_pm.o atombios_dp.o | 52 | r600_blit_kms.o radeon_pm.o atombios_dp.o r600_audio.o r600_hdmi.o |
53 | 53 | ||
54 | radeon-$(CONFIG_COMPAT) += radeon_ioc32.o | 54 | radeon-$(CONFIG_COMPAT) += radeon_ioc32.o |
55 | 55 | ||
diff --git a/drivers/gpu/drm/radeon/r100.c b/drivers/gpu/drm/radeon/r100.c index 824cc6480a06..84e5df766d3f 100644 --- a/drivers/gpu/drm/radeon/r100.c +++ b/drivers/gpu/drm/radeon/r100.c | |||
@@ -1374,7 +1374,6 @@ static int r100_packet0_check(struct radeon_cs_parser *p, | |||
1374 | case RADEON_TXFORMAT_ARGB4444: | 1374 | case RADEON_TXFORMAT_ARGB4444: |
1375 | case RADEON_TXFORMAT_VYUY422: | 1375 | case RADEON_TXFORMAT_VYUY422: |
1376 | case RADEON_TXFORMAT_YVYU422: | 1376 | case RADEON_TXFORMAT_YVYU422: |
1377 | case RADEON_TXFORMAT_DXT1: | ||
1378 | case RADEON_TXFORMAT_SHADOW16: | 1377 | case RADEON_TXFORMAT_SHADOW16: |
1379 | case RADEON_TXFORMAT_LDUDV655: | 1378 | case RADEON_TXFORMAT_LDUDV655: |
1380 | case RADEON_TXFORMAT_DUDV88: | 1379 | case RADEON_TXFORMAT_DUDV88: |
@@ -1382,12 +1381,19 @@ static int r100_packet0_check(struct radeon_cs_parser *p, | |||
1382 | break; | 1381 | break; |
1383 | case RADEON_TXFORMAT_ARGB8888: | 1382 | case RADEON_TXFORMAT_ARGB8888: |
1384 | case RADEON_TXFORMAT_RGBA8888: | 1383 | case RADEON_TXFORMAT_RGBA8888: |
1385 | case RADEON_TXFORMAT_DXT23: | ||
1386 | case RADEON_TXFORMAT_DXT45: | ||
1387 | case RADEON_TXFORMAT_SHADOW32: | 1384 | case RADEON_TXFORMAT_SHADOW32: |
1388 | case RADEON_TXFORMAT_LDUDUV8888: | 1385 | case RADEON_TXFORMAT_LDUDUV8888: |
1389 | track->textures[i].cpp = 4; | 1386 | track->textures[i].cpp = 4; |
1390 | break; | 1387 | break; |
1388 | case RADEON_TXFORMAT_DXT1: | ||
1389 | track->textures[i].cpp = 1; | ||
1390 | track->textures[i].compress_format = R100_TRACK_COMP_DXT1; | ||
1391 | break; | ||
1392 | case RADEON_TXFORMAT_DXT23: | ||
1393 | case RADEON_TXFORMAT_DXT45: | ||
1394 | track->textures[i].cpp = 1; | ||
1395 | track->textures[i].compress_format = R100_TRACK_COMP_DXT35; | ||
1396 | break; | ||
1391 | } | 1397 | } |
1392 | track->textures[i].cube_info[4].width = 1 << ((idx_value >> 16) & 0xf); | 1398 | track->textures[i].cube_info[4].width = 1 << ((idx_value >> 16) & 0xf); |
1393 | track->textures[i].cube_info[4].height = 1 << ((idx_value >> 20) & 0xf); | 1399 | track->textures[i].cube_info[4].height = 1 << ((idx_value >> 20) & 0xf); |
@@ -2731,6 +2737,7 @@ static inline void r100_cs_track_texture_print(struct r100_cs_track_texture *t) | |||
2731 | DRM_ERROR("coordinate type %d\n", t->tex_coord_type); | 2737 | DRM_ERROR("coordinate type %d\n", t->tex_coord_type); |
2732 | DRM_ERROR("width round to power of 2 %d\n", t->roundup_w); | 2738 | DRM_ERROR("width round to power of 2 %d\n", t->roundup_w); |
2733 | DRM_ERROR("height round to power of 2 %d\n", t->roundup_h); | 2739 | DRM_ERROR("height round to power of 2 %d\n", t->roundup_h); |
2740 | DRM_ERROR("compress format %d\n", t->compress_format); | ||
2734 | } | 2741 | } |
2735 | 2742 | ||
2736 | static int r100_cs_track_cube(struct radeon_device *rdev, | 2743 | static int r100_cs_track_cube(struct radeon_device *rdev, |
@@ -2760,6 +2767,36 @@ static int r100_cs_track_cube(struct radeon_device *rdev, | |||
2760 | return 0; | 2767 | return 0; |
2761 | } | 2768 | } |
2762 | 2769 | ||
2770 | static int r100_track_compress_size(int compress_format, int w, int h) | ||
2771 | { | ||
2772 | int block_width, block_height, block_bytes; | ||
2773 | int wblocks, hblocks; | ||
2774 | int min_wblocks; | ||
2775 | int sz; | ||
2776 | |||
2777 | block_width = 4; | ||
2778 | block_height = 4; | ||
2779 | |||
2780 | switch (compress_format) { | ||
2781 | case R100_TRACK_COMP_DXT1: | ||
2782 | block_bytes = 8; | ||
2783 | min_wblocks = 4; | ||
2784 | break; | ||
2785 | default: | ||
2786 | case R100_TRACK_COMP_DXT35: | ||
2787 | block_bytes = 16; | ||
2788 | min_wblocks = 2; | ||
2789 | break; | ||
2790 | } | ||
2791 | |||
2792 | hblocks = (h + block_height - 1) / block_height; | ||
2793 | wblocks = (w + block_width - 1) / block_width; | ||
2794 | if (wblocks < min_wblocks) | ||
2795 | wblocks = min_wblocks; | ||
2796 | sz = wblocks * hblocks * block_bytes; | ||
2797 | return sz; | ||
2798 | } | ||
2799 | |||
2763 | static int r100_cs_track_texture_check(struct radeon_device *rdev, | 2800 | static int r100_cs_track_texture_check(struct radeon_device *rdev, |
2764 | struct r100_cs_track *track) | 2801 | struct r100_cs_track *track) |
2765 | { | 2802 | { |
@@ -2797,9 +2834,15 @@ static int r100_cs_track_texture_check(struct radeon_device *rdev, | |||
2797 | h = h / (1 << i); | 2834 | h = h / (1 << i); |
2798 | if (track->textures[u].roundup_h) | 2835 | if (track->textures[u].roundup_h) |
2799 | h = roundup_pow_of_two(h); | 2836 | h = roundup_pow_of_two(h); |
2800 | size += w * h; | 2837 | if (track->textures[u].compress_format) { |
2838 | |||
2839 | size += r100_track_compress_size(track->textures[u].compress_format, w, h); | ||
2840 | /* compressed textures are block based */ | ||
2841 | } else | ||
2842 | size += w * h; | ||
2801 | } | 2843 | } |
2802 | size *= track->textures[u].cpp; | 2844 | size *= track->textures[u].cpp; |
2845 | |||
2803 | switch (track->textures[u].tex_coord_type) { | 2846 | switch (track->textures[u].tex_coord_type) { |
2804 | case 0: | 2847 | case 0: |
2805 | break; | 2848 | break; |
@@ -2967,6 +3010,7 @@ void r100_cs_track_clear(struct radeon_device *rdev, struct r100_cs_track *track | |||
2967 | track->arrays[i].esize = 0x7F; | 3010 | track->arrays[i].esize = 0x7F; |
2968 | } | 3011 | } |
2969 | for (i = 0; i < track->num_texture; i++) { | 3012 | for (i = 0; i < track->num_texture; i++) { |
3013 | track->textures[i].compress_format = R100_TRACK_COMP_NONE; | ||
2970 | track->textures[i].pitch = 16536; | 3014 | track->textures[i].pitch = 16536; |
2971 | track->textures[i].width = 16536; | 3015 | track->textures[i].width = 16536; |
2972 | track->textures[i].height = 16536; | 3016 | track->textures[i].height = 16536; |
@@ -3399,6 +3443,8 @@ int r100_init(struct radeon_device *rdev) | |||
3399 | r100_errata(rdev); | 3443 | r100_errata(rdev); |
3400 | /* Initialize clocks */ | 3444 | /* Initialize clocks */ |
3401 | radeon_get_clock_info(rdev->ddev); | 3445 | radeon_get_clock_info(rdev->ddev); |
3446 | /* Initialize power management */ | ||
3447 | radeon_pm_init(rdev); | ||
3402 | /* Get vram informations */ | 3448 | /* Get vram informations */ |
3403 | r100_vram_info(rdev); | 3449 | r100_vram_info(rdev); |
3404 | /* Initialize memory controller (also test AGP) */ | 3450 | /* Initialize memory controller (also test AGP) */ |
diff --git a/drivers/gpu/drm/radeon/r100_track.h b/drivers/gpu/drm/radeon/r100_track.h index ca50903dd2bb..7188c3778ee2 100644 --- a/drivers/gpu/drm/radeon/r100_track.h +++ b/drivers/gpu/drm/radeon/r100_track.h | |||
@@ -28,6 +28,10 @@ struct r100_cs_cube_info { | |||
28 | unsigned height; | 28 | unsigned height; |
29 | }; | 29 | }; |
30 | 30 | ||
31 | #define R100_TRACK_COMP_NONE 0 | ||
32 | #define R100_TRACK_COMP_DXT1 1 | ||
33 | #define R100_TRACK_COMP_DXT35 2 | ||
34 | |||
31 | struct r100_cs_track_texture { | 35 | struct r100_cs_track_texture { |
32 | struct radeon_bo *robj; | 36 | struct radeon_bo *robj; |
33 | struct r100_cs_cube_info cube_info[5]; /* info for 5 non-primary faces */ | 37 | struct r100_cs_cube_info cube_info[5]; /* info for 5 non-primary faces */ |
@@ -44,6 +48,7 @@ struct r100_cs_track_texture { | |||
44 | bool enabled; | 48 | bool enabled; |
45 | bool roundup_w; | 49 | bool roundup_w; |
46 | bool roundup_h; | 50 | bool roundup_h; |
51 | unsigned compress_format; | ||
47 | }; | 52 | }; |
48 | 53 | ||
49 | struct r100_cs_track_limits { | 54 | struct r100_cs_track_limits { |
diff --git a/drivers/gpu/drm/radeon/r200.c b/drivers/gpu/drm/radeon/r200.c index eb740fc3549f..20942127c46b 100644 --- a/drivers/gpu/drm/radeon/r200.c +++ b/drivers/gpu/drm/radeon/r200.c | |||
@@ -401,7 +401,6 @@ int r200_packet0_check(struct radeon_cs_parser *p, | |||
401 | case R200_TXFORMAT_Y8: | 401 | case R200_TXFORMAT_Y8: |
402 | track->textures[i].cpp = 1; | 402 | track->textures[i].cpp = 1; |
403 | break; | 403 | break; |
404 | case R200_TXFORMAT_DXT1: | ||
405 | case R200_TXFORMAT_AI88: | 404 | case R200_TXFORMAT_AI88: |
406 | case R200_TXFORMAT_ARGB1555: | 405 | case R200_TXFORMAT_ARGB1555: |
407 | case R200_TXFORMAT_RGB565: | 406 | case R200_TXFORMAT_RGB565: |
@@ -418,9 +417,16 @@ int r200_packet0_check(struct radeon_cs_parser *p, | |||
418 | case R200_TXFORMAT_ABGR8888: | 417 | case R200_TXFORMAT_ABGR8888: |
419 | case R200_TXFORMAT_BGR111110: | 418 | case R200_TXFORMAT_BGR111110: |
420 | case R200_TXFORMAT_LDVDU8888: | 419 | case R200_TXFORMAT_LDVDU8888: |
420 | track->textures[i].cpp = 4; | ||
421 | break; | ||
422 | case R200_TXFORMAT_DXT1: | ||
423 | track->textures[i].cpp = 1; | ||
424 | track->textures[i].compress_format = R100_TRACK_COMP_DXT1; | ||
425 | break; | ||
421 | case R200_TXFORMAT_DXT23: | 426 | case R200_TXFORMAT_DXT23: |
422 | case R200_TXFORMAT_DXT45: | 427 | case R200_TXFORMAT_DXT45: |
423 | track->textures[i].cpp = 4; | 428 | track->textures[i].cpp = 1; |
429 | track->textures[i].compress_format = R100_TRACK_COMP_DXT1; | ||
424 | break; | 430 | break; |
425 | } | 431 | } |
426 | track->textures[i].cube_info[4].width = 1 << ((idx_value >> 16) & 0xf); | 432 | track->textures[i].cube_info[4].width = 1 << ((idx_value >> 16) & 0xf); |
diff --git a/drivers/gpu/drm/radeon/r300.c b/drivers/gpu/drm/radeon/r300.c index 83378c39d0e3..83490c2b5061 100644 --- a/drivers/gpu/drm/radeon/r300.c +++ b/drivers/gpu/drm/radeon/r300.c | |||
@@ -686,7 +686,15 @@ static int r300_packet0_check(struct radeon_cs_parser *p, | |||
686 | r100_cs_dump_packet(p, pkt); | 686 | r100_cs_dump_packet(p, pkt); |
687 | return r; | 687 | return r; |
688 | } | 688 | } |
689 | ib[idx] = idx_value + ((u32)reloc->lobj.gpu_offset); | 689 | |
690 | if (reloc->lobj.tiling_flags & RADEON_TILING_MACRO) | ||
691 | tile_flags |= R300_TXO_MACRO_TILE; | ||
692 | if (reloc->lobj.tiling_flags & RADEON_TILING_MICRO) | ||
693 | tile_flags |= R300_TXO_MICRO_TILE; | ||
694 | |||
695 | tmp = idx_value + ((u32)reloc->lobj.gpu_offset); | ||
696 | tmp |= tile_flags; | ||
697 | ib[idx] = tmp; | ||
690 | track->textures[i].robj = reloc->robj; | 698 | track->textures[i].robj = reloc->robj; |
691 | break; | 699 | break; |
692 | /* Tracked registers */ | 700 | /* Tracked registers */ |
@@ -852,7 +860,6 @@ static int r300_packet0_check(struct radeon_cs_parser *p, | |||
852 | case R300_TX_FORMAT_Z6Y5X5: | 860 | case R300_TX_FORMAT_Z6Y5X5: |
853 | case R300_TX_FORMAT_W4Z4Y4X4: | 861 | case R300_TX_FORMAT_W4Z4Y4X4: |
854 | case R300_TX_FORMAT_W1Z5Y5X5: | 862 | case R300_TX_FORMAT_W1Z5Y5X5: |
855 | case R300_TX_FORMAT_DXT1: | ||
856 | case R300_TX_FORMAT_D3DMFT_CxV8U8: | 863 | case R300_TX_FORMAT_D3DMFT_CxV8U8: |
857 | case R300_TX_FORMAT_B8G8_B8G8: | 864 | case R300_TX_FORMAT_B8G8_B8G8: |
858 | case R300_TX_FORMAT_G8R8_G8B8: | 865 | case R300_TX_FORMAT_G8R8_G8B8: |
@@ -866,8 +873,6 @@ static int r300_packet0_check(struct radeon_cs_parser *p, | |||
866 | case 0x17: | 873 | case 0x17: |
867 | case R300_TX_FORMAT_FL_I32: | 874 | case R300_TX_FORMAT_FL_I32: |
868 | case 0x1e: | 875 | case 0x1e: |
869 | case R300_TX_FORMAT_DXT3: | ||
870 | case R300_TX_FORMAT_DXT5: | ||
871 | track->textures[i].cpp = 4; | 876 | track->textures[i].cpp = 4; |
872 | break; | 877 | break; |
873 | case R300_TX_FORMAT_W16Z16Y16X16: | 878 | case R300_TX_FORMAT_W16Z16Y16X16: |
@@ -878,6 +883,15 @@ static int r300_packet0_check(struct radeon_cs_parser *p, | |||
878 | case R300_TX_FORMAT_FL_R32G32B32A32: | 883 | case R300_TX_FORMAT_FL_R32G32B32A32: |
879 | track->textures[i].cpp = 16; | 884 | track->textures[i].cpp = 16; |
880 | break; | 885 | break; |
886 | case R300_TX_FORMAT_DXT1: | ||
887 | track->textures[i].cpp = 1; | ||
888 | track->textures[i].compress_format = R100_TRACK_COMP_DXT1; | ||
889 | break; | ||
890 | case R300_TX_FORMAT_DXT3: | ||
891 | case R300_TX_FORMAT_DXT5: | ||
892 | track->textures[i].cpp = 1; | ||
893 | track->textures[i].compress_format = R100_TRACK_COMP_DXT35; | ||
894 | break; | ||
881 | default: | 895 | default: |
882 | DRM_ERROR("Invalid texture format %u\n", | 896 | DRM_ERROR("Invalid texture format %u\n", |
883 | (idx_value & 0x1F)); | 897 | (idx_value & 0x1F)); |
@@ -1324,6 +1338,8 @@ int r300_init(struct radeon_device *rdev) | |||
1324 | r300_errata(rdev); | 1338 | r300_errata(rdev); |
1325 | /* Initialize clocks */ | 1339 | /* Initialize clocks */ |
1326 | radeon_get_clock_info(rdev->ddev); | 1340 | radeon_get_clock_info(rdev->ddev); |
1341 | /* Initialize power management */ | ||
1342 | radeon_pm_init(rdev); | ||
1327 | /* Get vram informations */ | 1343 | /* Get vram informations */ |
1328 | r300_vram_info(rdev); | 1344 | r300_vram_info(rdev); |
1329 | /* Initialize memory controller (also test AGP) */ | 1345 | /* Initialize memory controller (also test AGP) */ |
diff --git a/drivers/gpu/drm/radeon/r600.c b/drivers/gpu/drm/radeon/r600.c index 36656bd110bf..a0ac3c134b1b 100644 --- a/drivers/gpu/drm/radeon/r600.c +++ b/drivers/gpu/drm/radeon/r600.c | |||
@@ -1863,6 +1863,14 @@ int r600_startup(struct radeon_device *rdev) | |||
1863 | } | 1863 | } |
1864 | r600_gpu_init(rdev); | 1864 | r600_gpu_init(rdev); |
1865 | 1865 | ||
1866 | if (!rdev->r600_blit.shader_obj) { | ||
1867 | r = r600_blit_init(rdev); | ||
1868 | if (r) { | ||
1869 | DRM_ERROR("radeon: failed blitter (%d).\n", r); | ||
1870 | return r; | ||
1871 | } | ||
1872 | } | ||
1873 | |||
1866 | r = radeon_bo_reserve(rdev->r600_blit.shader_obj, false); | 1874 | r = radeon_bo_reserve(rdev->r600_blit.shader_obj, false); |
1867 | if (unlikely(r != 0)) | 1875 | if (unlikely(r != 0)) |
1868 | return r; | 1876 | return r; |
@@ -2038,12 +2046,6 @@ int r600_init(struct radeon_device *rdev) | |||
2038 | if (r) | 2046 | if (r) |
2039 | return r; | 2047 | return r; |
2040 | 2048 | ||
2041 | r = r600_blit_init(rdev); | ||
2042 | if (r) { | ||
2043 | DRM_ERROR("radeon: failed blitter (%d).\n", r); | ||
2044 | return r; | ||
2045 | } | ||
2046 | |||
2047 | rdev->accel_working = true; | 2049 | rdev->accel_working = true; |
2048 | r = r600_startup(rdev); | 2050 | r = r600_startup(rdev); |
2049 | if (r) { | 2051 | if (r) { |
@@ -2065,6 +2067,10 @@ int r600_init(struct radeon_device *rdev) | |||
2065 | rdev->accel_working = false; | 2067 | rdev->accel_working = false; |
2066 | } | 2068 | } |
2067 | } | 2069 | } |
2070 | |||
2071 | r = r600_audio_init(rdev); | ||
2072 | if (r) | ||
2073 | return r; /* TODO error handling */ | ||
2068 | return 0; | 2074 | return 0; |
2069 | } | 2075 | } |
2070 | 2076 | ||
@@ -2073,6 +2079,7 @@ void r600_fini(struct radeon_device *rdev) | |||
2073 | /* Suspend operations */ | 2079 | /* Suspend operations */ |
2074 | r600_suspend(rdev); | 2080 | r600_suspend(rdev); |
2075 | 2081 | ||
2082 | r600_audio_fini(rdev); | ||
2076 | r600_blit_fini(rdev); | 2083 | r600_blit_fini(rdev); |
2077 | r600_irq_fini(rdev); | 2084 | r600_irq_fini(rdev); |
2078 | radeon_irq_kms_fini(rdev); | 2085 | radeon_irq_kms_fini(rdev); |
diff --git a/drivers/gpu/drm/radeon/r600_audio.c b/drivers/gpu/drm/radeon/r600_audio.c new file mode 100644 index 000000000000..99e2c3891a7d --- /dev/null +++ b/drivers/gpu/drm/radeon/r600_audio.c | |||
@@ -0,0 +1,267 @@ | |||
1 | /* | ||
2 | * Copyright 2008 Advanced Micro Devices, Inc. | ||
3 | * Copyright 2008 Red Hat Inc. | ||
4 | * Copyright 2009 Christian König. | ||
5 | * | ||
6 | * Permission is hereby granted, free of charge, to any person obtaining a | ||
7 | * copy of this software and associated documentation files (the "Software"), | ||
8 | * to deal in the Software without restriction, including without limitation | ||
9 | * the rights to use, copy, modify, merge, publish, distribute, sublicense, | ||
10 | * and/or sell copies of the Software, and to permit persons to whom the | ||
11 | * Software is furnished to do so, subject to the following conditions: | ||
12 | * | ||
13 | * The above copyright notice and this permission notice shall be included in | ||
14 | * all copies or substantial portions of the Software. | ||
15 | * | ||
16 | * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR | ||
17 | * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, | ||
18 | * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL | ||
19 | * THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR | ||
20 | * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, | ||
21 | * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR | ||
22 | * OTHER DEALINGS IN THE SOFTWARE. | ||
23 | * | ||
24 | * Authors: Christian König | ||
25 | */ | ||
26 | #include "drmP.h" | ||
27 | #include "radeon.h" | ||
28 | #include "radeon_reg.h" | ||
29 | #include "atom.h" | ||
30 | |||
31 | #define AUDIO_TIMER_INTERVALL 100 /* 1/10 sekund should be enough */ | ||
32 | |||
33 | /* | ||
34 | * check if the chipset is supported | ||
35 | */ | ||
36 | static int r600_audio_chipset_supported(struct radeon_device *rdev) | ||
37 | { | ||
38 | return rdev->family >= CHIP_R600 | ||
39 | || rdev->family == CHIP_RS600 | ||
40 | || rdev->family == CHIP_RS690 | ||
41 | || rdev->family == CHIP_RS740; | ||
42 | } | ||
43 | |||
44 | /* | ||
45 | * current number of channels | ||
46 | */ | ||
47 | static int r600_audio_channels(struct radeon_device *rdev) | ||
48 | { | ||
49 | return (RREG32(R600_AUDIO_RATE_BPS_CHANNEL) & 0x7) + 1; | ||
50 | } | ||
51 | |||
52 | /* | ||
53 | * current bits per sample | ||
54 | */ | ||
55 | static int r600_audio_bits_per_sample(struct radeon_device *rdev) | ||
56 | { | ||
57 | uint32_t value = (RREG32(R600_AUDIO_RATE_BPS_CHANNEL) & 0xF0) >> 4; | ||
58 | switch (value) { | ||
59 | case 0x0: return 8; | ||
60 | case 0x1: return 16; | ||
61 | case 0x2: return 20; | ||
62 | case 0x3: return 24; | ||
63 | case 0x4: return 32; | ||
64 | } | ||
65 | |||
66 | DRM_ERROR("Unknown bits per sample 0x%x using 16 instead.\n", (int)value); | ||
67 | |||
68 | return 16; | ||
69 | } | ||
70 | |||
71 | /* | ||
72 | * current sampling rate in HZ | ||
73 | */ | ||
74 | static int r600_audio_rate(struct radeon_device *rdev) | ||
75 | { | ||
76 | uint32_t value = RREG32(R600_AUDIO_RATE_BPS_CHANNEL); | ||
77 | uint32_t result; | ||
78 | |||
79 | if (value & 0x4000) | ||
80 | result = 44100; | ||
81 | else | ||
82 | result = 48000; | ||
83 | |||
84 | result *= ((value >> 11) & 0x7) + 1; | ||
85 | result /= ((value >> 8) & 0x7) + 1; | ||
86 | |||
87 | return result; | ||
88 | } | ||
89 | |||
90 | /* | ||
91 | * iec 60958 status bits | ||
92 | */ | ||
93 | static uint8_t r600_audio_status_bits(struct radeon_device *rdev) | ||
94 | { | ||
95 | return RREG32(R600_AUDIO_STATUS_BITS) & 0xff; | ||
96 | } | ||
97 | |||
98 | /* | ||
99 | * iec 60958 category code | ||
100 | */ | ||
101 | static uint8_t r600_audio_category_code(struct radeon_device *rdev) | ||
102 | { | ||
103 | return (RREG32(R600_AUDIO_STATUS_BITS) >> 8) & 0xff; | ||
104 | } | ||
105 | |||
106 | /* | ||
107 | * update all hdmi interfaces with current audio parameters | ||
108 | */ | ||
109 | static void r600_audio_update_hdmi(unsigned long param) | ||
110 | { | ||
111 | struct radeon_device *rdev = (struct radeon_device *)param; | ||
112 | struct drm_device *dev = rdev->ddev; | ||
113 | |||
114 | int channels = r600_audio_channels(rdev); | ||
115 | int rate = r600_audio_rate(rdev); | ||
116 | int bps = r600_audio_bits_per_sample(rdev); | ||
117 | uint8_t status_bits = r600_audio_status_bits(rdev); | ||
118 | uint8_t category_code = r600_audio_category_code(rdev); | ||
119 | |||
120 | struct drm_encoder *encoder; | ||
121 | int changes = 0; | ||
122 | |||
123 | changes |= channels != rdev->audio_channels; | ||
124 | changes |= rate != rdev->audio_rate; | ||
125 | changes |= bps != rdev->audio_bits_per_sample; | ||
126 | changes |= status_bits != rdev->audio_status_bits; | ||
127 | changes |= category_code != rdev->audio_category_code; | ||
128 | |||
129 | if (changes) { | ||
130 | rdev->audio_channels = channels; | ||
131 | rdev->audio_rate = rate; | ||
132 | rdev->audio_bits_per_sample = bps; | ||
133 | rdev->audio_status_bits = status_bits; | ||
134 | rdev->audio_category_code = category_code; | ||
135 | } | ||
136 | |||
137 | list_for_each_entry(encoder, &dev->mode_config.encoder_list, head) { | ||
138 | if (changes || r600_hdmi_buffer_status_changed(encoder)) | ||
139 | r600_hdmi_update_audio_settings( | ||
140 | encoder, channels, | ||
141 | rate, bps, status_bits, | ||
142 | category_code); | ||
143 | } | ||
144 | |||
145 | mod_timer(&rdev->audio_timer, | ||
146 | jiffies + msecs_to_jiffies(AUDIO_TIMER_INTERVALL)); | ||
147 | } | ||
148 | |||
149 | /* | ||
150 | * initialize the audio vars and register the update timer | ||
151 | */ | ||
152 | int r600_audio_init(struct radeon_device *rdev) | ||
153 | { | ||
154 | if (!r600_audio_chipset_supported(rdev)) | ||
155 | return 0; | ||
156 | |||
157 | DRM_INFO("%s audio support", radeon_audio ? "Enabling" : "Disabling"); | ||
158 | WREG32_P(R600_AUDIO_ENABLE, radeon_audio ? 0x81000000 : 0x0, ~0x81000000); | ||
159 | |||
160 | rdev->audio_channels = -1; | ||
161 | rdev->audio_rate = -1; | ||
162 | rdev->audio_bits_per_sample = -1; | ||
163 | rdev->audio_status_bits = 0; | ||
164 | rdev->audio_category_code = 0; | ||
165 | |||
166 | setup_timer( | ||
167 | &rdev->audio_timer, | ||
168 | r600_audio_update_hdmi, | ||
169 | (unsigned long)rdev); | ||
170 | |||
171 | mod_timer(&rdev->audio_timer, jiffies + 1); | ||
172 | |||
173 | return 0; | ||
174 | } | ||
175 | |||
176 | /* | ||
177 | * determin how the encoders and audio interface is wired together | ||
178 | */ | ||
179 | int r600_audio_tmds_index(struct drm_encoder *encoder) | ||
180 | { | ||
181 | struct drm_device *dev = encoder->dev; | ||
182 | struct radeon_encoder *radeon_encoder = to_radeon_encoder(encoder); | ||
183 | struct drm_encoder *other; | ||
184 | |||
185 | switch (radeon_encoder->encoder_id) { | ||
186 | case ENCODER_OBJECT_ID_INTERNAL_KLDSCP_TMDS1: | ||
187 | case ENCODER_OBJECT_ID_INTERNAL_UNIPHY: | ||
188 | case ENCODER_OBJECT_ID_INTERNAL_UNIPHY1: | ||
189 | return 0; | ||
190 | |||
191 | case ENCODER_OBJECT_ID_INTERNAL_LVTM1: | ||
192 | /* special case check if an TMDS1 is present */ | ||
193 | list_for_each_entry(other, &dev->mode_config.encoder_list, head) { | ||
194 | if (to_radeon_encoder(other)->encoder_id == | ||
195 | ENCODER_OBJECT_ID_INTERNAL_TMDS1) | ||
196 | return 1; | ||
197 | } | ||
198 | return 0; | ||
199 | |||
200 | case ENCODER_OBJECT_ID_INTERNAL_UNIPHY2: | ||
201 | case ENCODER_OBJECT_ID_INTERNAL_KLDSCP_LVTMA: | ||
202 | return 1; | ||
203 | |||
204 | default: | ||
205 | DRM_ERROR("Unsupported encoder type 0x%02X\n", | ||
206 | radeon_encoder->encoder_id); | ||
207 | return -1; | ||
208 | } | ||
209 | } | ||
210 | |||
211 | /* | ||
212 | * atach the audio codec to the clock source of the encoder | ||
213 | */ | ||
214 | void r600_audio_set_clock(struct drm_encoder *encoder, int clock) | ||
215 | { | ||
216 | struct drm_device *dev = encoder->dev; | ||
217 | struct radeon_device *rdev = dev->dev_private; | ||
218 | struct radeon_encoder *radeon_encoder = to_radeon_encoder(encoder); | ||
219 | int base_rate = 48000; | ||
220 | |||
221 | switch (radeon_encoder->encoder_id) { | ||
222 | case ENCODER_OBJECT_ID_INTERNAL_KLDSCP_TMDS1: | ||
223 | case ENCODER_OBJECT_ID_INTERNAL_LVTM1: | ||
224 | WREG32_P(R600_AUDIO_TIMING, 0, ~0x301); | ||
225 | break; | ||
226 | |||
227 | case ENCODER_OBJECT_ID_INTERNAL_UNIPHY: | ||
228 | case ENCODER_OBJECT_ID_INTERNAL_UNIPHY1: | ||
229 | case ENCODER_OBJECT_ID_INTERNAL_UNIPHY2: | ||
230 | case ENCODER_OBJECT_ID_INTERNAL_KLDSCP_LVTMA: | ||
231 | WREG32_P(R600_AUDIO_TIMING, 0x100, ~0x301); | ||
232 | break; | ||
233 | |||
234 | default: | ||
235 | DRM_ERROR("Unsupported encoder type 0x%02X\n", | ||
236 | radeon_encoder->encoder_id); | ||
237 | return; | ||
238 | } | ||
239 | |||
240 | switch (r600_audio_tmds_index(encoder)) { | ||
241 | case 0: | ||
242 | WREG32(R600_AUDIO_PLL1_MUL, base_rate*50); | ||
243 | WREG32(R600_AUDIO_PLL1_DIV, clock*100); | ||
244 | WREG32(R600_AUDIO_CLK_SRCSEL, 0); | ||
245 | break; | ||
246 | |||
247 | case 1: | ||
248 | WREG32(R600_AUDIO_PLL2_MUL, base_rate*50); | ||
249 | WREG32(R600_AUDIO_PLL2_DIV, clock*100); | ||
250 | WREG32(R600_AUDIO_CLK_SRCSEL, 1); | ||
251 | break; | ||
252 | } | ||
253 | } | ||
254 | |||
255 | /* | ||
256 | * release the audio timer | ||
257 | * TODO: How to do this correctly on SMP systems? | ||
258 | */ | ||
259 | void r600_audio_fini(struct radeon_device *rdev) | ||
260 | { | ||
261 | if (!r600_audio_chipset_supported(rdev)) | ||
262 | return; | ||
263 | |||
264 | WREG32_P(R600_AUDIO_ENABLE, 0x0, ~0x81000000); | ||
265 | |||
266 | del_timer(&rdev->audio_timer); | ||
267 | } | ||
diff --git a/drivers/gpu/drm/radeon/r600_hdmi.c b/drivers/gpu/drm/radeon/r600_hdmi.c new file mode 100644 index 000000000000..fcc949df0e5d --- /dev/null +++ b/drivers/gpu/drm/radeon/r600_hdmi.c | |||
@@ -0,0 +1,506 @@ | |||
1 | /* | ||
2 | * Copyright 2008 Advanced Micro Devices, Inc. | ||
3 | * Copyright 2008 Red Hat Inc. | ||
4 | * Copyright 2009 Christian König. | ||
5 | * | ||
6 | * Permission is hereby granted, free of charge, to any person obtaining a | ||
7 | * copy of this software and associated documentation files (the "Software"), | ||
8 | * to deal in the Software without restriction, including without limitation | ||
9 | * the rights to use, copy, modify, merge, publish, distribute, sublicense, | ||
10 | * and/or sell copies of the Software, and to permit persons to whom the | ||
11 | * Software is furnished to do so, subject to the following conditions: | ||
12 | * | ||
13 | * The above copyright notice and this permission notice shall be included in | ||
14 | * all copies or substantial portions of the Software. | ||
15 | * | ||
16 | * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR | ||
17 | * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, | ||
18 | * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL | ||
19 | * THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR | ||
20 | * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, | ||
21 | * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR | ||
22 | * OTHER DEALINGS IN THE SOFTWARE. | ||
23 | * | ||
24 | * Authors: Christian König | ||
25 | */ | ||
26 | #include "drmP.h" | ||
27 | #include "radeon_drm.h" | ||
28 | #include "radeon.h" | ||
29 | #include "atom.h" | ||
30 | |||
31 | /* | ||
32 | * HDMI color format | ||
33 | */ | ||
34 | enum r600_hdmi_color_format { | ||
35 | RGB = 0, | ||
36 | YCC_422 = 1, | ||
37 | YCC_444 = 2 | ||
38 | }; | ||
39 | |||
40 | /* | ||
41 | * IEC60958 status bits | ||
42 | */ | ||
43 | enum r600_hdmi_iec_status_bits { | ||
44 | AUDIO_STATUS_DIG_ENABLE = 0x01, | ||
45 | AUDIO_STATUS_V = 0x02, | ||
46 | AUDIO_STATUS_VCFG = 0x04, | ||
47 | AUDIO_STATUS_EMPHASIS = 0x08, | ||
48 | AUDIO_STATUS_COPYRIGHT = 0x10, | ||
49 | AUDIO_STATUS_NONAUDIO = 0x20, | ||
50 | AUDIO_STATUS_PROFESSIONAL = 0x40, | ||
51 | AUDIO_STATUS_LEVEL = 0x80 | ||
52 | }; | ||
53 | |||
54 | struct { | ||
55 | uint32_t Clock; | ||
56 | |||
57 | int N_32kHz; | ||
58 | int CTS_32kHz; | ||
59 | |||
60 | int N_44_1kHz; | ||
61 | int CTS_44_1kHz; | ||
62 | |||
63 | int N_48kHz; | ||
64 | int CTS_48kHz; | ||
65 | |||
66 | } r600_hdmi_ACR[] = { | ||
67 | /* 32kHz 44.1kHz 48kHz */ | ||
68 | /* Clock N CTS N CTS N CTS */ | ||
69 | { 25174, 4576, 28125, 7007, 31250, 6864, 28125 }, /* 25,20/1.001 MHz */ | ||
70 | { 25200, 4096, 25200, 6272, 28000, 6144, 25200 }, /* 25.20 MHz */ | ||
71 | { 27000, 4096, 27000, 6272, 30000, 6144, 27000 }, /* 27.00 MHz */ | ||
72 | { 27027, 4096, 27027, 6272, 30030, 6144, 27027 }, /* 27.00*1.001 MHz */ | ||
73 | { 54000, 4096, 54000, 6272, 60000, 6144, 54000 }, /* 54.00 MHz */ | ||
74 | { 54054, 4096, 54054, 6272, 60060, 6144, 54054 }, /* 54.00*1.001 MHz */ | ||
75 | { 74175, 11648, 210937, 17836, 234375, 11648, 140625 }, /* 74.25/1.001 MHz */ | ||
76 | { 74250, 4096, 74250, 6272, 82500, 6144, 74250 }, /* 74.25 MHz */ | ||
77 | { 148351, 11648, 421875, 8918, 234375, 5824, 140625 }, /* 148.50/1.001 MHz */ | ||
78 | { 148500, 4096, 148500, 6272, 165000, 6144, 148500 }, /* 148.50 MHz */ | ||
79 | { 0, 4096, 0, 6272, 0, 6144, 0 } /* Other */ | ||
80 | }; | ||
81 | |||
82 | /* | ||
83 | * calculate CTS value if it's not found in the table | ||
84 | */ | ||
85 | static void r600_hdmi_calc_CTS(uint32_t clock, int *CTS, int N, int freq) | ||
86 | { | ||
87 | if (*CTS == 0) | ||
88 | *CTS = clock*N/(128*freq)*1000; | ||
89 | DRM_DEBUG("Using ACR timing N=%d CTS=%d for frequency %d\n", | ||
90 | N, *CTS, freq); | ||
91 | } | ||
92 | |||
93 | /* | ||
94 | * update the N and CTS parameters for a given pixel clock rate | ||
95 | */ | ||
96 | static void r600_hdmi_update_ACR(struct drm_encoder *encoder, uint32_t clock) | ||
97 | { | ||
98 | struct drm_device *dev = encoder->dev; | ||
99 | struct radeon_device *rdev = dev->dev_private; | ||
100 | uint32_t offset = to_radeon_encoder(encoder)->hdmi_offset; | ||
101 | int CTS; | ||
102 | int N; | ||
103 | int i; | ||
104 | |||
105 | for (i = 0; r600_hdmi_ACR[i].Clock != clock && r600_hdmi_ACR[i].Clock != 0; i++); | ||
106 | |||
107 | CTS = r600_hdmi_ACR[i].CTS_32kHz; | ||
108 | N = r600_hdmi_ACR[i].N_32kHz; | ||
109 | r600_hdmi_calc_CTS(clock, &CTS, N, 32000); | ||
110 | WREG32(offset+R600_HDMI_32kHz_CTS, CTS << 12); | ||
111 | WREG32(offset+R600_HDMI_32kHz_N, N); | ||
112 | |||
113 | CTS = r600_hdmi_ACR[i].CTS_44_1kHz; | ||
114 | N = r600_hdmi_ACR[i].N_44_1kHz; | ||
115 | r600_hdmi_calc_CTS(clock, &CTS, N, 44100); | ||
116 | WREG32(offset+R600_HDMI_44_1kHz_CTS, CTS << 12); | ||
117 | WREG32(offset+R600_HDMI_44_1kHz_N, N); | ||
118 | |||
119 | CTS = r600_hdmi_ACR[i].CTS_48kHz; | ||
120 | N = r600_hdmi_ACR[i].N_48kHz; | ||
121 | r600_hdmi_calc_CTS(clock, &CTS, N, 48000); | ||
122 | WREG32(offset+R600_HDMI_48kHz_CTS, CTS << 12); | ||
123 | WREG32(offset+R600_HDMI_48kHz_N, N); | ||
124 | } | ||
125 | |||
126 | /* | ||
127 | * calculate the crc for a given info frame | ||
128 | */ | ||
129 | static void r600_hdmi_infoframe_checksum(uint8_t packetType, | ||
130 | uint8_t versionNumber, | ||
131 | uint8_t length, | ||
132 | uint8_t *frame) | ||
133 | { | ||
134 | int i; | ||
135 | frame[0] = packetType + versionNumber + length; | ||
136 | for (i = 1; i <= length; i++) | ||
137 | frame[0] += frame[i]; | ||
138 | frame[0] = 0x100 - frame[0]; | ||
139 | } | ||
140 | |||
141 | /* | ||
142 | * build a HDMI Video Info Frame | ||
143 | */ | ||
144 | static void r600_hdmi_videoinfoframe( | ||
145 | struct drm_encoder *encoder, | ||
146 | enum r600_hdmi_color_format color_format, | ||
147 | int active_information_present, | ||
148 | uint8_t active_format_aspect_ratio, | ||
149 | uint8_t scan_information, | ||
150 | uint8_t colorimetry, | ||
151 | uint8_t ex_colorimetry, | ||
152 | uint8_t quantization, | ||
153 | int ITC, | ||
154 | uint8_t picture_aspect_ratio, | ||
155 | uint8_t video_format_identification, | ||
156 | uint8_t pixel_repetition, | ||
157 | uint8_t non_uniform_picture_scaling, | ||
158 | uint8_t bar_info_data_valid, | ||
159 | uint16_t top_bar, | ||
160 | uint16_t bottom_bar, | ||
161 | uint16_t left_bar, | ||
162 | uint16_t right_bar | ||
163 | ) | ||
164 | { | ||
165 | struct drm_device *dev = encoder->dev; | ||
166 | struct radeon_device *rdev = dev->dev_private; | ||
167 | uint32_t offset = to_radeon_encoder(encoder)->hdmi_offset; | ||
168 | |||
169 | uint8_t frame[14]; | ||
170 | |||
171 | frame[0x0] = 0; | ||
172 | frame[0x1] = | ||
173 | (scan_information & 0x3) | | ||
174 | ((bar_info_data_valid & 0x3) << 2) | | ||
175 | ((active_information_present & 0x1) << 4) | | ||
176 | ((color_format & 0x3) << 5); | ||
177 | frame[0x2] = | ||
178 | (active_format_aspect_ratio & 0xF) | | ||
179 | ((picture_aspect_ratio & 0x3) << 4) | | ||
180 | ((colorimetry & 0x3) << 6); | ||
181 | frame[0x3] = | ||
182 | (non_uniform_picture_scaling & 0x3) | | ||
183 | ((quantization & 0x3) << 2) | | ||
184 | ((ex_colorimetry & 0x7) << 4) | | ||
185 | ((ITC & 0x1) << 7); | ||
186 | frame[0x4] = (video_format_identification & 0x7F); | ||
187 | frame[0x5] = (pixel_repetition & 0xF); | ||
188 | frame[0x6] = (top_bar & 0xFF); | ||
189 | frame[0x7] = (top_bar >> 8); | ||
190 | frame[0x8] = (bottom_bar & 0xFF); | ||
191 | frame[0x9] = (bottom_bar >> 8); | ||
192 | frame[0xA] = (left_bar & 0xFF); | ||
193 | frame[0xB] = (left_bar >> 8); | ||
194 | frame[0xC] = (right_bar & 0xFF); | ||
195 | frame[0xD] = (right_bar >> 8); | ||
196 | |||
197 | r600_hdmi_infoframe_checksum(0x82, 0x02, 0x0D, frame); | ||
198 | |||
199 | WREG32(offset+R600_HDMI_VIDEOINFOFRAME_0, | ||
200 | frame[0x0] | (frame[0x1] << 8) | (frame[0x2] << 16) | (frame[0x3] << 24)); | ||
201 | WREG32(offset+R600_HDMI_VIDEOINFOFRAME_1, | ||
202 | frame[0x4] | (frame[0x5] << 8) | (frame[0x6] << 16) | (frame[0x7] << 24)); | ||
203 | WREG32(offset+R600_HDMI_VIDEOINFOFRAME_2, | ||
204 | frame[0x8] | (frame[0x9] << 8) | (frame[0xA] << 16) | (frame[0xB] << 24)); | ||
205 | WREG32(offset+R600_HDMI_VIDEOINFOFRAME_3, | ||
206 | frame[0xC] | (frame[0xD] << 8)); | ||
207 | } | ||
208 | |||
209 | /* | ||
210 | * build a Audio Info Frame | ||
211 | */ | ||
212 | static void r600_hdmi_audioinfoframe( | ||
213 | struct drm_encoder *encoder, | ||
214 | uint8_t channel_count, | ||
215 | uint8_t coding_type, | ||
216 | uint8_t sample_size, | ||
217 | uint8_t sample_frequency, | ||
218 | uint8_t format, | ||
219 | uint8_t channel_allocation, | ||
220 | uint8_t level_shift, | ||
221 | int downmix_inhibit | ||
222 | ) | ||
223 | { | ||
224 | struct drm_device *dev = encoder->dev; | ||
225 | struct radeon_device *rdev = dev->dev_private; | ||
226 | uint32_t offset = to_radeon_encoder(encoder)->hdmi_offset; | ||
227 | |||
228 | uint8_t frame[11]; | ||
229 | |||
230 | frame[0x0] = 0; | ||
231 | frame[0x1] = (channel_count & 0x7) | ((coding_type & 0xF) << 4); | ||
232 | frame[0x2] = (sample_size & 0x3) | ((sample_frequency & 0x7) << 2); | ||
233 | frame[0x3] = format; | ||
234 | frame[0x4] = channel_allocation; | ||
235 | frame[0x5] = ((level_shift & 0xF) << 3) | ((downmix_inhibit & 0x1) << 7); | ||
236 | frame[0x6] = 0; | ||
237 | frame[0x7] = 0; | ||
238 | frame[0x8] = 0; | ||
239 | frame[0x9] = 0; | ||
240 | frame[0xA] = 0; | ||
241 | |||
242 | r600_hdmi_infoframe_checksum(0x84, 0x01, 0x0A, frame); | ||
243 | |||
244 | WREG32(offset+R600_HDMI_AUDIOINFOFRAME_0, | ||
245 | frame[0x0] | (frame[0x1] << 8) | (frame[0x2] << 16) | (frame[0x3] << 24)); | ||
246 | WREG32(offset+R600_HDMI_AUDIOINFOFRAME_1, | ||
247 | frame[0x4] | (frame[0x5] << 8) | (frame[0x6] << 16) | (frame[0x8] << 24)); | ||
248 | } | ||
249 | |||
250 | /* | ||
251 | * test if audio buffer is filled enough to start playing | ||
252 | */ | ||
253 | static int r600_hdmi_is_audio_buffer_filled(struct drm_encoder *encoder) | ||
254 | { | ||
255 | struct drm_device *dev = encoder->dev; | ||
256 | struct radeon_device *rdev = dev->dev_private; | ||
257 | uint32_t offset = to_radeon_encoder(encoder)->hdmi_offset; | ||
258 | |||
259 | return (RREG32(offset+R600_HDMI_STATUS) & 0x10) != 0; | ||
260 | } | ||
261 | |||
262 | /* | ||
263 | * have buffer status changed since last call? | ||
264 | */ | ||
265 | int r600_hdmi_buffer_status_changed(struct drm_encoder *encoder) | ||
266 | { | ||
267 | struct radeon_encoder *radeon_encoder = to_radeon_encoder(encoder); | ||
268 | int status, result; | ||
269 | |||
270 | if (!radeon_encoder->hdmi_offset) | ||
271 | return 0; | ||
272 | |||
273 | status = r600_hdmi_is_audio_buffer_filled(encoder); | ||
274 | result = radeon_encoder->hdmi_buffer_status != status; | ||
275 | radeon_encoder->hdmi_buffer_status = status; | ||
276 | |||
277 | return result; | ||
278 | } | ||
279 | |||
280 | /* | ||
281 | * write the audio workaround status to the hardware | ||
282 | */ | ||
283 | void r600_hdmi_audio_workaround(struct drm_encoder *encoder) | ||
284 | { | ||
285 | struct drm_device *dev = encoder->dev; | ||
286 | struct radeon_device *rdev = dev->dev_private; | ||
287 | struct radeon_encoder *radeon_encoder = to_radeon_encoder(encoder); | ||
288 | uint32_t offset = radeon_encoder->hdmi_offset; | ||
289 | |||
290 | if (!offset) | ||
291 | return; | ||
292 | |||
293 | if (r600_hdmi_is_audio_buffer_filled(encoder)) { | ||
294 | /* disable audio workaround and start delivering of audio frames */ | ||
295 | WREG32_P(offset+R600_HDMI_CNTL, 0x00000001, ~0x00001001); | ||
296 | |||
297 | } else if (radeon_encoder->hdmi_audio_workaround) { | ||
298 | /* enable audio workaround and start delivering of audio frames */ | ||
299 | WREG32_P(offset+R600_HDMI_CNTL, 0x00001001, ~0x00001001); | ||
300 | |||
301 | } else { | ||
302 | /* disable audio workaround and stop delivering of audio frames */ | ||
303 | WREG32_P(offset+R600_HDMI_CNTL, 0x00000000, ~0x00001001); | ||
304 | } | ||
305 | } | ||
306 | |||
307 | |||
308 | /* | ||
309 | * update the info frames with the data from the current display mode | ||
310 | */ | ||
311 | void r600_hdmi_setmode(struct drm_encoder *encoder, struct drm_display_mode *mode) | ||
312 | { | ||
313 | struct drm_device *dev = encoder->dev; | ||
314 | struct radeon_device *rdev = dev->dev_private; | ||
315 | uint32_t offset = to_radeon_encoder(encoder)->hdmi_offset; | ||
316 | |||
317 | if (!offset) | ||
318 | return; | ||
319 | |||
320 | r600_audio_set_clock(encoder, mode->clock); | ||
321 | |||
322 | WREG32(offset+R600_HDMI_UNKNOWN_0, 0x1000); | ||
323 | WREG32(offset+R600_HDMI_UNKNOWN_1, 0x0); | ||
324 | WREG32(offset+R600_HDMI_UNKNOWN_2, 0x1000); | ||
325 | |||
326 | r600_hdmi_update_ACR(encoder, mode->clock); | ||
327 | |||
328 | WREG32(offset+R600_HDMI_VIDEOCNTL, 0x13); | ||
329 | |||
330 | WREG32(offset+R600_HDMI_VERSION, 0x202); | ||
331 | |||
332 | r600_hdmi_videoinfoframe(encoder, RGB, 0, 0, 0, 0, | ||
333 | 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0); | ||
334 | |||
335 | /* it's unknown what these bits do excatly, but it's indeed quite usefull for debugging */ | ||
336 | WREG32(offset+R600_HDMI_AUDIO_DEBUG_0, 0x00FFFFFF); | ||
337 | WREG32(offset+R600_HDMI_AUDIO_DEBUG_1, 0x007FFFFF); | ||
338 | WREG32(offset+R600_HDMI_AUDIO_DEBUG_2, 0x00000001); | ||
339 | WREG32(offset+R600_HDMI_AUDIO_DEBUG_3, 0x00000001); | ||
340 | |||
341 | r600_hdmi_audio_workaround(encoder); | ||
342 | |||
343 | /* audio packets per line, does anyone know how to calc this ? */ | ||
344 | WREG32_P(offset+R600_HDMI_CNTL, 0x00040000, ~0x001F0000); | ||
345 | |||
346 | /* update? reset? don't realy know */ | ||
347 | WREG32_P(offset+R600_HDMI_CNTL, 0x14000000, ~0x14000000); | ||
348 | } | ||
349 | |||
350 | /* | ||
351 | * update settings with current parameters from audio engine | ||
352 | */ | ||
353 | void r600_hdmi_update_audio_settings(struct drm_encoder *encoder, | ||
354 | int channels, | ||
355 | int rate, | ||
356 | int bps, | ||
357 | uint8_t status_bits, | ||
358 | uint8_t category_code) | ||
359 | { | ||
360 | struct drm_device *dev = encoder->dev; | ||
361 | struct radeon_device *rdev = dev->dev_private; | ||
362 | uint32_t offset = to_radeon_encoder(encoder)->hdmi_offset; | ||
363 | |||
364 | uint32_t iec; | ||
365 | |||
366 | if (!offset) | ||
367 | return; | ||
368 | |||
369 | DRM_DEBUG("%s with %d channels, %d Hz sampling rate, %d bits per sample,\n", | ||
370 | r600_hdmi_is_audio_buffer_filled(encoder) ? "playing" : "stopped", | ||
371 | channels, rate, bps); | ||
372 | DRM_DEBUG("0x%02X IEC60958 status bits and 0x%02X category code\n", | ||
373 | (int)status_bits, (int)category_code); | ||
374 | |||
375 | iec = 0; | ||
376 | if (status_bits & AUDIO_STATUS_PROFESSIONAL) | ||
377 | iec |= 1 << 0; | ||
378 | if (status_bits & AUDIO_STATUS_NONAUDIO) | ||
379 | iec |= 1 << 1; | ||
380 | if (status_bits & AUDIO_STATUS_COPYRIGHT) | ||
381 | iec |= 1 << 2; | ||
382 | if (status_bits & AUDIO_STATUS_EMPHASIS) | ||
383 | iec |= 1 << 3; | ||
384 | |||
385 | iec |= category_code << 8; | ||
386 | |||
387 | switch (rate) { | ||
388 | case 32000: iec |= 0x3 << 24; break; | ||
389 | case 44100: iec |= 0x0 << 24; break; | ||
390 | case 88200: iec |= 0x8 << 24; break; | ||
391 | case 176400: iec |= 0xc << 24; break; | ||
392 | case 48000: iec |= 0x2 << 24; break; | ||
393 | case 96000: iec |= 0xa << 24; break; | ||
394 | case 192000: iec |= 0xe << 24; break; | ||
395 | } | ||
396 | |||
397 | WREG32(offset+R600_HDMI_IEC60958_1, iec); | ||
398 | |||
399 | iec = 0; | ||
400 | switch (bps) { | ||
401 | case 16: iec |= 0x2; break; | ||
402 | case 20: iec |= 0x3; break; | ||
403 | case 24: iec |= 0xb; break; | ||
404 | } | ||
405 | if (status_bits & AUDIO_STATUS_V) | ||
406 | iec |= 0x5 << 16; | ||
407 | |||
408 | WREG32_P(offset+R600_HDMI_IEC60958_2, iec, ~0x5000f); | ||
409 | |||
410 | /* 0x021 or 0x031 sets the audio frame length */ | ||
411 | WREG32(offset+R600_HDMI_AUDIOCNTL, 0x31); | ||
412 | r600_hdmi_audioinfoframe(encoder, channels-1, 0, 0, 0, 0, 0, 0, 0); | ||
413 | |||
414 | r600_hdmi_audio_workaround(encoder); | ||
415 | |||
416 | /* update? reset? don't realy know */ | ||
417 | WREG32_P(offset+R600_HDMI_CNTL, 0x04000000, ~0x04000000); | ||
418 | } | ||
419 | |||
420 | /* | ||
421 | * enable/disable the HDMI engine | ||
422 | */ | ||
423 | void r600_hdmi_enable(struct drm_encoder *encoder, int enable) | ||
424 | { | ||
425 | struct drm_device *dev = encoder->dev; | ||
426 | struct radeon_device *rdev = dev->dev_private; | ||
427 | struct radeon_encoder *radeon_encoder = to_radeon_encoder(encoder); | ||
428 | uint32_t offset = to_radeon_encoder(encoder)->hdmi_offset; | ||
429 | |||
430 | if (!offset) | ||
431 | return; | ||
432 | |||
433 | DRM_DEBUG("%s HDMI interface @ 0x%04X\n", enable ? "Enabling" : "Disabling", offset); | ||
434 | |||
435 | /* some version of atombios ignore the enable HDMI flag | ||
436 | * so enabling/disabling HDMI was moved here for TMDS1+2 */ | ||
437 | switch (radeon_encoder->encoder_id) { | ||
438 | case ENCODER_OBJECT_ID_INTERNAL_KLDSCP_TMDS1: | ||
439 | WREG32_P(AVIVO_TMDSA_CNTL, enable ? 0x4 : 0x0, ~0x4); | ||
440 | WREG32(offset+R600_HDMI_ENABLE, enable ? 0x101 : 0x0); | ||
441 | break; | ||
442 | |||
443 | case ENCODER_OBJECT_ID_INTERNAL_LVTM1: | ||
444 | WREG32_P(AVIVO_LVTMA_CNTL, enable ? 0x4 : 0x0, ~0x4); | ||
445 | WREG32(offset+R600_HDMI_ENABLE, enable ? 0x105 : 0x0); | ||
446 | break; | ||
447 | |||
448 | case ENCODER_OBJECT_ID_INTERNAL_UNIPHY: | ||
449 | case ENCODER_OBJECT_ID_INTERNAL_UNIPHY1: | ||
450 | case ENCODER_OBJECT_ID_INTERNAL_UNIPHY2: | ||
451 | case ENCODER_OBJECT_ID_INTERNAL_KLDSCP_LVTMA: | ||
452 | /* This part is doubtfull in my opinion */ | ||
453 | WREG32(offset+R600_HDMI_ENABLE, enable ? 0x110 : 0x0); | ||
454 | break; | ||
455 | |||
456 | default: | ||
457 | DRM_ERROR("unknown HDMI output type\n"); | ||
458 | break; | ||
459 | } | ||
460 | } | ||
461 | |||
462 | /* | ||
463 | * determin at which register offset the HDMI encoder is | ||
464 | */ | ||
465 | void r600_hdmi_init(struct drm_encoder *encoder) | ||
466 | { | ||
467 | struct radeon_encoder *radeon_encoder = to_radeon_encoder(encoder); | ||
468 | |||
469 | switch (radeon_encoder->encoder_id) { | ||
470 | case ENCODER_OBJECT_ID_INTERNAL_KLDSCP_TMDS1: | ||
471 | case ENCODER_OBJECT_ID_INTERNAL_UNIPHY: | ||
472 | case ENCODER_OBJECT_ID_INTERNAL_UNIPHY1: | ||
473 | radeon_encoder->hdmi_offset = R600_HDMI_TMDS1; | ||
474 | break; | ||
475 | |||
476 | case ENCODER_OBJECT_ID_INTERNAL_LVTM1: | ||
477 | switch (r600_audio_tmds_index(encoder)) { | ||
478 | case 0: | ||
479 | radeon_encoder->hdmi_offset = R600_HDMI_TMDS1; | ||
480 | break; | ||
481 | case 1: | ||
482 | radeon_encoder->hdmi_offset = R600_HDMI_TMDS2; | ||
483 | break; | ||
484 | default: | ||
485 | radeon_encoder->hdmi_offset = 0; | ||
486 | break; | ||
487 | } | ||
488 | case ENCODER_OBJECT_ID_INTERNAL_UNIPHY2: | ||
489 | radeon_encoder->hdmi_offset = R600_HDMI_TMDS2; | ||
490 | break; | ||
491 | |||
492 | case ENCODER_OBJECT_ID_INTERNAL_KLDSCP_LVTMA: | ||
493 | radeon_encoder->hdmi_offset = R600_HDMI_DIG; | ||
494 | break; | ||
495 | |||
496 | default: | ||
497 | radeon_encoder->hdmi_offset = 0; | ||
498 | break; | ||
499 | } | ||
500 | |||
501 | DRM_DEBUG("using HDMI engine at offset 0x%04X for encoder 0x%x\n", | ||
502 | radeon_encoder->hdmi_offset, radeon_encoder->encoder_id); | ||
503 | |||
504 | /* TODO: make this configureable */ | ||
505 | radeon_encoder->hdmi_audio_workaround = 0; | ||
506 | } | ||
diff --git a/drivers/gpu/drm/radeon/r600_reg.h b/drivers/gpu/drm/radeon/r600_reg.h index e2d1f5f33f7e..d0e28ffdeda9 100644 --- a/drivers/gpu/drm/radeon/r600_reg.h +++ b/drivers/gpu/drm/radeon/r600_reg.h | |||
@@ -110,5 +110,79 @@ | |||
110 | #define R600_BIOS_6_SCRATCH 0x173c | 110 | #define R600_BIOS_6_SCRATCH 0x173c |
111 | #define R600_BIOS_7_SCRATCH 0x1740 | 111 | #define R600_BIOS_7_SCRATCH 0x1740 |
112 | 112 | ||
113 | /* Audio, these regs were reverse enginered, | ||
114 | * so the chance is high that the naming is wrong | ||
115 | * R6xx+ ??? */ | ||
116 | |||
117 | /* Audio clocks */ | ||
118 | #define R600_AUDIO_PLL1_MUL 0x0514 | ||
119 | #define R600_AUDIO_PLL1_DIV 0x0518 | ||
120 | #define R600_AUDIO_PLL2_MUL 0x0524 | ||
121 | #define R600_AUDIO_PLL2_DIV 0x0528 | ||
122 | #define R600_AUDIO_CLK_SRCSEL 0x0534 | ||
123 | |||
124 | /* Audio general */ | ||
125 | #define R600_AUDIO_ENABLE 0x7300 | ||
126 | #define R600_AUDIO_TIMING 0x7344 | ||
127 | |||
128 | /* Audio params */ | ||
129 | #define R600_AUDIO_VENDOR_ID 0x7380 | ||
130 | #define R600_AUDIO_REVISION_ID 0x7384 | ||
131 | #define R600_AUDIO_ROOT_NODE_COUNT 0x7388 | ||
132 | #define R600_AUDIO_NID1_NODE_COUNT 0x738c | ||
133 | #define R600_AUDIO_NID1_TYPE 0x7390 | ||
134 | #define R600_AUDIO_SUPPORTED_SIZE_RATE 0x7394 | ||
135 | #define R600_AUDIO_SUPPORTED_CODEC 0x7398 | ||
136 | #define R600_AUDIO_SUPPORTED_POWER_STATES 0x739c | ||
137 | #define R600_AUDIO_NID2_CAPS 0x73a0 | ||
138 | #define R600_AUDIO_NID3_CAPS 0x73a4 | ||
139 | #define R600_AUDIO_NID3_PIN_CAPS 0x73a8 | ||
140 | |||
141 | /* Audio conn list */ | ||
142 | #define R600_AUDIO_CONN_LIST_LEN 0x73ac | ||
143 | #define R600_AUDIO_CONN_LIST 0x73b0 | ||
144 | |||
145 | /* Audio verbs */ | ||
146 | #define R600_AUDIO_RATE_BPS_CHANNEL 0x73c0 | ||
147 | #define R600_AUDIO_PLAYING 0x73c4 | ||
148 | #define R600_AUDIO_IMPLEMENTATION_ID 0x73c8 | ||
149 | #define R600_AUDIO_CONFIG_DEFAULT 0x73cc | ||
150 | #define R600_AUDIO_PIN_SENSE 0x73d0 | ||
151 | #define R600_AUDIO_PIN_WIDGET_CNTL 0x73d4 | ||
152 | #define R600_AUDIO_STATUS_BITS 0x73d8 | ||
153 | |||
154 | /* HDMI base register addresses */ | ||
155 | #define R600_HDMI_TMDS1 0x7400 | ||
156 | #define R600_HDMI_TMDS2 0x7700 | ||
157 | #define R600_HDMI_DIG 0x7800 | ||
158 | |||
159 | /* HDMI registers */ | ||
160 | #define R600_HDMI_ENABLE 0x00 | ||
161 | #define R600_HDMI_STATUS 0x04 | ||
162 | #define R600_HDMI_CNTL 0x08 | ||
163 | #define R600_HDMI_UNKNOWN_0 0x0C | ||
164 | #define R600_HDMI_AUDIOCNTL 0x10 | ||
165 | #define R600_HDMI_VIDEOCNTL 0x14 | ||
166 | #define R600_HDMI_VERSION 0x18 | ||
167 | #define R600_HDMI_UNKNOWN_1 0x28 | ||
168 | #define R600_HDMI_VIDEOINFOFRAME_0 0x54 | ||
169 | #define R600_HDMI_VIDEOINFOFRAME_1 0x58 | ||
170 | #define R600_HDMI_VIDEOINFOFRAME_2 0x5c | ||
171 | #define R600_HDMI_VIDEOINFOFRAME_3 0x60 | ||
172 | #define R600_HDMI_32kHz_CTS 0xac | ||
173 | #define R600_HDMI_32kHz_N 0xb0 | ||
174 | #define R600_HDMI_44_1kHz_CTS 0xb4 | ||
175 | #define R600_HDMI_44_1kHz_N 0xb8 | ||
176 | #define R600_HDMI_48kHz_CTS 0xbc | ||
177 | #define R600_HDMI_48kHz_N 0xc0 | ||
178 | #define R600_HDMI_AUDIOINFOFRAME_0 0xcc | ||
179 | #define R600_HDMI_AUDIOINFOFRAME_1 0xd0 | ||
180 | #define R600_HDMI_IEC60958_1 0xd4 | ||
181 | #define R600_HDMI_IEC60958_2 0xd8 | ||
182 | #define R600_HDMI_UNKNOWN_2 0xdc | ||
183 | #define R600_HDMI_AUDIO_DEBUG_0 0xe0 | ||
184 | #define R600_HDMI_AUDIO_DEBUG_1 0xe4 | ||
185 | #define R600_HDMI_AUDIO_DEBUG_2 0xe8 | ||
186 | #define R600_HDMI_AUDIO_DEBUG_3 0xec | ||
113 | 187 | ||
114 | #endif | 188 | #endif |
diff --git a/drivers/gpu/drm/radeon/radeon.h b/drivers/gpu/drm/radeon/radeon.h index c938bb54123c..cd650fd3964e 100644 --- a/drivers/gpu/drm/radeon/radeon.h +++ b/drivers/gpu/drm/radeon/radeon.h | |||
@@ -89,6 +89,7 @@ extern int radeon_testing; | |||
89 | extern int radeon_connector_table; | 89 | extern int radeon_connector_table; |
90 | extern int radeon_tv; | 90 | extern int radeon_tv; |
91 | extern int radeon_new_pll; | 91 | extern int radeon_new_pll; |
92 | extern int radeon_audio; | ||
92 | 93 | ||
93 | /* | 94 | /* |
94 | * Copy from radeon_drv.h so we don't have to include both and have conflicting | 95 | * Copy from radeon_drv.h so we don't have to include both and have conflicting |
@@ -814,6 +815,14 @@ struct radeon_device { | |||
814 | struct r600_ih ih; /* r6/700 interrupt ring */ | 815 | struct r600_ih ih; /* r6/700 interrupt ring */ |
815 | struct workqueue_struct *wq; | 816 | struct workqueue_struct *wq; |
816 | struct work_struct hotplug_work; | 817 | struct work_struct hotplug_work; |
818 | |||
819 | /* audio stuff */ | ||
820 | struct timer_list audio_timer; | ||
821 | int audio_channels; | ||
822 | int audio_rate; | ||
823 | int audio_bits_per_sample; | ||
824 | uint8_t audio_status_bits; | ||
825 | uint8_t audio_category_code; | ||
817 | }; | 826 | }; |
818 | 827 | ||
819 | int radeon_device_init(struct radeon_device *rdev, | 828 | int radeon_device_init(struct radeon_device *rdev, |
@@ -1016,6 +1025,7 @@ extern int radeon_cs_parser_init(struct radeon_cs_parser *p, void *data); | |||
1016 | extern void radeon_legacy_set_clock_gating(struct radeon_device *rdev, int enable); | 1025 | extern void radeon_legacy_set_clock_gating(struct radeon_device *rdev, int enable); |
1017 | extern void radeon_atom_set_clock_gating(struct radeon_device *rdev, int enable); | 1026 | extern void radeon_atom_set_clock_gating(struct radeon_device *rdev, int enable); |
1018 | extern void radeon_ttm_placement_from_domain(struct radeon_bo *rbo, u32 domain); | 1027 | extern void radeon_ttm_placement_from_domain(struct radeon_bo *rbo, u32 domain); |
1028 | extern bool radeon_ttm_bo_is_radeon_bo(struct ttm_buffer_object *bo); | ||
1019 | 1029 | ||
1020 | /* r100,rv100,rs100,rv200,rs200,r200,rv250,rs300,rv280 */ | 1030 | /* r100,rv100,rs100,rv200,rs200,r200,rv250,rs300,rv280 */ |
1021 | struct r100_mc_save { | 1031 | struct r100_mc_save { |
@@ -1146,6 +1156,21 @@ extern void r600_irq_fini(struct radeon_device *rdev); | |||
1146 | extern void r600_ih_ring_init(struct radeon_device *rdev, unsigned ring_size); | 1156 | extern void r600_ih_ring_init(struct radeon_device *rdev, unsigned ring_size); |
1147 | extern int r600_irq_set(struct radeon_device *rdev); | 1157 | extern int r600_irq_set(struct radeon_device *rdev); |
1148 | 1158 | ||
1159 | extern int r600_audio_init(struct radeon_device *rdev); | ||
1160 | extern int r600_audio_tmds_index(struct drm_encoder *encoder); | ||
1161 | extern void r600_audio_set_clock(struct drm_encoder *encoder, int clock); | ||
1162 | extern void r600_audio_fini(struct radeon_device *rdev); | ||
1163 | extern void r600_hdmi_init(struct drm_encoder *encoder); | ||
1164 | extern void r600_hdmi_enable(struct drm_encoder *encoder, int enable); | ||
1165 | extern void r600_hdmi_setmode(struct drm_encoder *encoder, struct drm_display_mode *mode); | ||
1166 | extern int r600_hdmi_buffer_status_changed(struct drm_encoder *encoder); | ||
1167 | extern void r600_hdmi_update_audio_settings(struct drm_encoder *encoder, | ||
1168 | int channels, | ||
1169 | int rate, | ||
1170 | int bps, | ||
1171 | uint8_t status_bits, | ||
1172 | uint8_t category_code); | ||
1173 | |||
1149 | #include "radeon_object.h" | 1174 | #include "radeon_object.h" |
1150 | 1175 | ||
1151 | #endif | 1176 | #endif |
diff --git a/drivers/gpu/drm/radeon/radeon_drv.c b/drivers/gpu/drm/radeon/radeon_drv.c index c5c45e626d74..dbd56ef82f9c 100644 --- a/drivers/gpu/drm/radeon/radeon_drv.c +++ b/drivers/gpu/drm/radeon/radeon_drv.c | |||
@@ -87,6 +87,7 @@ int radeon_testing = 0; | |||
87 | int radeon_connector_table = 0; | 87 | int radeon_connector_table = 0; |
88 | int radeon_tv = 1; | 88 | int radeon_tv = 1; |
89 | int radeon_new_pll = 1; | 89 | int radeon_new_pll = 1; |
90 | int radeon_audio = 1; | ||
90 | 91 | ||
91 | MODULE_PARM_DESC(no_wb, "Disable AGP writeback for scratch registers"); | 92 | MODULE_PARM_DESC(no_wb, "Disable AGP writeback for scratch registers"); |
92 | module_param_named(no_wb, radeon_no_wb, int, 0444); | 93 | module_param_named(no_wb, radeon_no_wb, int, 0444); |
@@ -124,6 +125,9 @@ module_param_named(tv, radeon_tv, int, 0444); | |||
124 | MODULE_PARM_DESC(new_pll, "Select new PLL code for AVIVO chips"); | 125 | MODULE_PARM_DESC(new_pll, "Select new PLL code for AVIVO chips"); |
125 | module_param_named(new_pll, radeon_new_pll, int, 0444); | 126 | module_param_named(new_pll, radeon_new_pll, int, 0444); |
126 | 127 | ||
128 | MODULE_PARM_DESC(audio, "Audio enable (0 = disable)"); | ||
129 | module_param_named(audio, radeon_audio, int, 0444); | ||
130 | |||
127 | static int radeon_suspend(struct drm_device *dev, pm_message_t state) | 131 | static int radeon_suspend(struct drm_device *dev, pm_message_t state) |
128 | { | 132 | { |
129 | drm_radeon_private_t *dev_priv = dev->dev_private; | 133 | drm_radeon_private_t *dev_priv = dev->dev_private; |
diff --git a/drivers/gpu/drm/radeon/radeon_encoders.c b/drivers/gpu/drm/radeon/radeon_encoders.c index b4f23ec93201..0d1d908e5225 100644 --- a/drivers/gpu/drm/radeon/radeon_encoders.c +++ b/drivers/gpu/drm/radeon/radeon_encoders.c | |||
@@ -438,6 +438,7 @@ atombios_digital_setup(struct drm_encoder *encoder, int action) | |||
438 | struct radeon_encoder *radeon_encoder = to_radeon_encoder(encoder); | 438 | struct radeon_encoder *radeon_encoder = to_radeon_encoder(encoder); |
439 | union lvds_encoder_control args; | 439 | union lvds_encoder_control args; |
440 | int index = 0; | 440 | int index = 0; |
441 | int hdmi_detected = 0; | ||
441 | uint8_t frev, crev; | 442 | uint8_t frev, crev; |
442 | struct radeon_encoder_atom_dig *dig; | 443 | struct radeon_encoder_atom_dig *dig; |
443 | struct drm_connector *connector; | 444 | struct drm_connector *connector; |
@@ -458,6 +459,9 @@ atombios_digital_setup(struct drm_encoder *encoder, int action) | |||
458 | if (!radeon_connector->con_priv) | 459 | if (!radeon_connector->con_priv) |
459 | return; | 460 | return; |
460 | 461 | ||
462 | if (drm_detect_hdmi_monitor(radeon_connector->edid)) | ||
463 | hdmi_detected = 1; | ||
464 | |||
461 | dig_connector = radeon_connector->con_priv; | 465 | dig_connector = radeon_connector->con_priv; |
462 | 466 | ||
463 | memset(&args, 0, sizeof(args)); | 467 | memset(&args, 0, sizeof(args)); |
@@ -487,7 +491,7 @@ atombios_digital_setup(struct drm_encoder *encoder, int action) | |||
487 | case 1: | 491 | case 1: |
488 | args.v1.ucMisc = 0; | 492 | args.v1.ucMisc = 0; |
489 | args.v1.ucAction = action; | 493 | args.v1.ucAction = action; |
490 | if (drm_detect_hdmi_monitor(radeon_connector->edid)) | 494 | if (hdmi_detected) |
491 | args.v1.ucMisc |= PANEL_ENCODER_MISC_HDMI_TYPE; | 495 | args.v1.ucMisc |= PANEL_ENCODER_MISC_HDMI_TYPE; |
492 | args.v1.usPixelClock = cpu_to_le16(radeon_encoder->pixel_clock / 10); | 496 | args.v1.usPixelClock = cpu_to_le16(radeon_encoder->pixel_clock / 10); |
493 | if (radeon_encoder->devices & (ATOM_DEVICE_LCD_SUPPORT)) { | 497 | if (radeon_encoder->devices & (ATOM_DEVICE_LCD_SUPPORT)) { |
@@ -512,7 +516,7 @@ atombios_digital_setup(struct drm_encoder *encoder, int action) | |||
512 | if (dig->coherent_mode) | 516 | if (dig->coherent_mode) |
513 | args.v2.ucMisc |= PANEL_ENCODER_MISC_COHERENT; | 517 | args.v2.ucMisc |= PANEL_ENCODER_MISC_COHERENT; |
514 | } | 518 | } |
515 | if (drm_detect_hdmi_monitor(radeon_connector->edid)) | 519 | if (hdmi_detected) |
516 | args.v2.ucMisc |= PANEL_ENCODER_MISC_HDMI_TYPE; | 520 | args.v2.ucMisc |= PANEL_ENCODER_MISC_HDMI_TYPE; |
517 | args.v2.usPixelClock = cpu_to_le16(radeon_encoder->pixel_clock / 10); | 521 | args.v2.usPixelClock = cpu_to_le16(radeon_encoder->pixel_clock / 10); |
518 | args.v2.ucTruncate = 0; | 522 | args.v2.ucTruncate = 0; |
@@ -552,7 +556,7 @@ atombios_digital_setup(struct drm_encoder *encoder, int action) | |||
552 | } | 556 | } |
553 | 557 | ||
554 | atom_execute_table(rdev->mode_info.atom_context, index, (uint32_t *)&args); | 558 | atom_execute_table(rdev->mode_info.atom_context, index, (uint32_t *)&args); |
555 | 559 | r600_hdmi_enable(encoder, hdmi_detected); | |
556 | } | 560 | } |
557 | 561 | ||
558 | int | 562 | int |
@@ -893,7 +897,6 @@ atombios_dig_transmitter_setup(struct drm_encoder *encoder, int action, uint8_t | |||
893 | } | 897 | } |
894 | 898 | ||
895 | atom_execute_table(rdev->mode_info.atom_context, index, (uint32_t *)&args); | 899 | atom_execute_table(rdev->mode_info.atom_context, index, (uint32_t *)&args); |
896 | |||
897 | } | 900 | } |
898 | 901 | ||
899 | static void | 902 | static void |
@@ -1162,7 +1165,6 @@ atombios_set_encoder_crtc_source(struct drm_encoder *encoder) | |||
1162 | } | 1165 | } |
1163 | 1166 | ||
1164 | atom_execute_table(rdev->mode_info.atom_context, index, (uint32_t *)&args); | 1167 | atom_execute_table(rdev->mode_info.atom_context, index, (uint32_t *)&args); |
1165 | |||
1166 | } | 1168 | } |
1167 | 1169 | ||
1168 | static void | 1170 | static void |
@@ -1265,6 +1267,8 @@ radeon_atom_encoder_mode_set(struct drm_encoder *encoder, | |||
1265 | break; | 1267 | break; |
1266 | } | 1268 | } |
1267 | atombios_apply_encoder_quirks(encoder, adjusted_mode); | 1269 | atombios_apply_encoder_quirks(encoder, adjusted_mode); |
1270 | |||
1271 | r600_hdmi_setmode(encoder, adjusted_mode); | ||
1268 | } | 1272 | } |
1269 | 1273 | ||
1270 | static bool | 1274 | static bool |
@@ -1510,4 +1514,6 @@ radeon_add_atom_encoder(struct drm_device *dev, uint32_t encoder_id, uint32_t su | |||
1510 | drm_encoder_helper_add(encoder, &radeon_atom_dig_helper_funcs); | 1514 | drm_encoder_helper_add(encoder, &radeon_atom_dig_helper_funcs); |
1511 | break; | 1515 | break; |
1512 | } | 1516 | } |
1517 | |||
1518 | r600_hdmi_init(encoder); | ||
1513 | } | 1519 | } |
diff --git a/drivers/gpu/drm/radeon/radeon_gem.c b/drivers/gpu/drm/radeon/radeon_gem.c index 2944486871b0..60df2d7e7e4c 100644 --- a/drivers/gpu/drm/radeon/radeon_gem.c +++ b/drivers/gpu/drm/radeon/radeon_gem.c | |||
@@ -66,8 +66,9 @@ int radeon_gem_object_create(struct radeon_device *rdev, int size, | |||
66 | } | 66 | } |
67 | r = radeon_bo_create(rdev, gobj, size, kernel, initial_domain, &robj); | 67 | r = radeon_bo_create(rdev, gobj, size, kernel, initial_domain, &robj); |
68 | if (r) { | 68 | if (r) { |
69 | DRM_ERROR("Failed to allocate GEM object (%d, %d, %u)\n", | 69 | if (r != -ERESTARTSYS) |
70 | size, initial_domain, alignment); | 70 | DRM_ERROR("Failed to allocate GEM object (%d, %d, %u, %d)\n", |
71 | size, initial_domain, alignment, r); | ||
71 | mutex_lock(&rdev->ddev->struct_mutex); | 72 | mutex_lock(&rdev->ddev->struct_mutex); |
72 | drm_gem_object_unreference(gobj); | 73 | drm_gem_object_unreference(gobj); |
73 | mutex_unlock(&rdev->ddev->struct_mutex); | 74 | mutex_unlock(&rdev->ddev->struct_mutex); |
@@ -350,9 +351,10 @@ int radeon_gem_get_tiling_ioctl(struct drm_device *dev, void *data, | |||
350 | rbo = gobj->driver_private; | 351 | rbo = gobj->driver_private; |
351 | r = radeon_bo_reserve(rbo, false); | 352 | r = radeon_bo_reserve(rbo, false); |
352 | if (unlikely(r != 0)) | 353 | if (unlikely(r != 0)) |
353 | return r; | 354 | goto out; |
354 | radeon_bo_get_tiling_flags(rbo, &args->tiling_flags, &args->pitch); | 355 | radeon_bo_get_tiling_flags(rbo, &args->tiling_flags, &args->pitch); |
355 | radeon_bo_unreserve(rbo); | 356 | radeon_bo_unreserve(rbo); |
357 | out: | ||
356 | mutex_lock(&dev->struct_mutex); | 358 | mutex_lock(&dev->struct_mutex); |
357 | drm_gem_object_unreference(gobj); | 359 | drm_gem_object_unreference(gobj); |
358 | mutex_unlock(&dev->struct_mutex); | 360 | mutex_unlock(&dev->struct_mutex); |
diff --git a/drivers/gpu/drm/radeon/radeon_mode.h b/drivers/gpu/drm/radeon/radeon_mode.h index 44d4b652ea12..3dcbe130c422 100644 --- a/drivers/gpu/drm/radeon/radeon_mode.h +++ b/drivers/gpu/drm/radeon/radeon_mode.h | |||
@@ -334,6 +334,9 @@ struct radeon_encoder { | |||
334 | enum radeon_rmx_type rmx_type; | 334 | enum radeon_rmx_type rmx_type; |
335 | struct drm_display_mode native_mode; | 335 | struct drm_display_mode native_mode; |
336 | void *enc_priv; | 336 | void *enc_priv; |
337 | int hdmi_offset; | ||
338 | int hdmi_audio_workaround; | ||
339 | int hdmi_buffer_status; | ||
337 | }; | 340 | }; |
338 | 341 | ||
339 | struct radeon_connector_atom_dig { | 342 | struct radeon_connector_atom_dig { |
diff --git a/drivers/gpu/drm/radeon/radeon_object.c b/drivers/gpu/drm/radeon/radeon_object.c index 544e18ffaf22..d9ffe1f56e8f 100644 --- a/drivers/gpu/drm/radeon/radeon_object.c +++ b/drivers/gpu/drm/radeon/radeon_object.c | |||
@@ -56,6 +56,13 @@ static void radeon_ttm_bo_destroy(struct ttm_buffer_object *tbo) | |||
56 | kfree(bo); | 56 | kfree(bo); |
57 | } | 57 | } |
58 | 58 | ||
59 | bool radeon_ttm_bo_is_radeon_bo(struct ttm_buffer_object *bo) | ||
60 | { | ||
61 | if (bo->destroy == &radeon_ttm_bo_destroy) | ||
62 | return true; | ||
63 | return false; | ||
64 | } | ||
65 | |||
59 | void radeon_ttm_placement_from_domain(struct radeon_bo *rbo, u32 domain) | 66 | void radeon_ttm_placement_from_domain(struct radeon_bo *rbo, u32 domain) |
60 | { | 67 | { |
61 | u32 c = 0; | 68 | u32 c = 0; |
@@ -71,6 +78,8 @@ void radeon_ttm_placement_from_domain(struct radeon_bo *rbo, u32 domain) | |||
71 | rbo->placements[c++] = TTM_PL_MASK_CACHING | TTM_PL_FLAG_TT; | 78 | rbo->placements[c++] = TTM_PL_MASK_CACHING | TTM_PL_FLAG_TT; |
72 | if (domain & RADEON_GEM_DOMAIN_CPU) | 79 | if (domain & RADEON_GEM_DOMAIN_CPU) |
73 | rbo->placements[c++] = TTM_PL_MASK_CACHING | TTM_PL_FLAG_SYSTEM; | 80 | rbo->placements[c++] = TTM_PL_MASK_CACHING | TTM_PL_FLAG_SYSTEM; |
81 | if (!c) | ||
82 | rbo->placements[c++] = TTM_PL_MASK_CACHING | TTM_PL_FLAG_SYSTEM; | ||
74 | rbo->placement.num_placement = c; | 83 | rbo->placement.num_placement = c; |
75 | rbo->placement.num_busy_placement = c; | 84 | rbo->placement.num_busy_placement = c; |
76 | } | 85 | } |
@@ -481,14 +490,20 @@ int radeon_bo_check_tiling(struct radeon_bo *bo, bool has_moved, | |||
481 | } | 490 | } |
482 | 491 | ||
483 | void radeon_bo_move_notify(struct ttm_buffer_object *bo, | 492 | void radeon_bo_move_notify(struct ttm_buffer_object *bo, |
484 | struct ttm_mem_reg *mem) | 493 | struct ttm_mem_reg *mem) |
485 | { | 494 | { |
486 | struct radeon_bo *rbo = container_of(bo, struct radeon_bo, tbo); | 495 | struct radeon_bo *rbo; |
496 | if (!radeon_ttm_bo_is_radeon_bo(bo)) | ||
497 | return; | ||
498 | rbo = container_of(bo, struct radeon_bo, tbo); | ||
487 | radeon_bo_check_tiling(rbo, 0, 1); | 499 | radeon_bo_check_tiling(rbo, 0, 1); |
488 | } | 500 | } |
489 | 501 | ||
490 | void radeon_bo_fault_reserve_notify(struct ttm_buffer_object *bo) | 502 | void radeon_bo_fault_reserve_notify(struct ttm_buffer_object *bo) |
491 | { | 503 | { |
492 | struct radeon_bo *rbo = container_of(bo, struct radeon_bo, tbo); | 504 | struct radeon_bo *rbo; |
505 | if (!radeon_ttm_bo_is_radeon_bo(bo)) | ||
506 | return; | ||
507 | rbo = container_of(bo, struct radeon_bo, tbo); | ||
493 | radeon_bo_check_tiling(rbo, 0, 0); | 508 | radeon_bo_check_tiling(rbo, 0, 0); |
494 | } | 509 | } |
diff --git a/drivers/gpu/drm/radeon/radeon_object.h b/drivers/gpu/drm/radeon/radeon_object.h index f6b69c2c0d00..a02f18011ad1 100644 --- a/drivers/gpu/drm/radeon/radeon_object.h +++ b/drivers/gpu/drm/radeon/radeon_object.h | |||
@@ -59,19 +59,17 @@ static inline unsigned radeon_mem_type_to_domain(u32 mem_type) | |||
59 | * | 59 | * |
60 | * Returns: | 60 | * Returns: |
61 | * -EBUSY: buffer is busy and @no_wait is true | 61 | * -EBUSY: buffer is busy and @no_wait is true |
62 | * -ERESTART: A wait for the buffer to become unreserved was interrupted by | 62 | * -ERESTARTSYS: A wait for the buffer to become unreserved was interrupted by |
63 | * a signal. Release all buffer reservations and return to user-space. | 63 | * a signal. Release all buffer reservations and return to user-space. |
64 | */ | 64 | */ |
65 | static inline int radeon_bo_reserve(struct radeon_bo *bo, bool no_wait) | 65 | static inline int radeon_bo_reserve(struct radeon_bo *bo, bool no_wait) |
66 | { | 66 | { |
67 | int r; | 67 | int r; |
68 | 68 | ||
69 | retry: | ||
70 | r = ttm_bo_reserve(&bo->tbo, true, no_wait, false, 0); | 69 | r = ttm_bo_reserve(&bo->tbo, true, no_wait, false, 0); |
71 | if (unlikely(r != 0)) { | 70 | if (unlikely(r != 0)) { |
72 | if (r == -ERESTART) | 71 | if (r != -ERESTARTSYS) |
73 | goto retry; | 72 | dev_err(bo->rdev->dev, "%p reserve failed\n", bo); |
74 | dev_err(bo->rdev->dev, "%p reserve failed\n", bo); | ||
75 | return r; | 73 | return r; |
76 | } | 74 | } |
77 | return 0; | 75 | return 0; |
@@ -125,12 +123,10 @@ static inline int radeon_bo_wait(struct radeon_bo *bo, u32 *mem_type, | |||
125 | { | 123 | { |
126 | int r; | 124 | int r; |
127 | 125 | ||
128 | retry: | ||
129 | r = ttm_bo_reserve(&bo->tbo, true, no_wait, false, 0); | 126 | r = ttm_bo_reserve(&bo->tbo, true, no_wait, false, 0); |
130 | if (unlikely(r != 0)) { | 127 | if (unlikely(r != 0)) { |
131 | if (r == -ERESTART) | 128 | if (r != -ERESTARTSYS) |
132 | goto retry; | 129 | dev_err(bo->rdev->dev, "%p reserve failed for wait\n", bo); |
133 | dev_err(bo->rdev->dev, "%p reserve failed for wait\n", bo); | ||
134 | return r; | 130 | return r; |
135 | } | 131 | } |
136 | spin_lock(&bo->tbo.lock); | 132 | spin_lock(&bo->tbo.lock); |
@@ -140,8 +136,6 @@ retry: | |||
140 | r = ttm_bo_wait(&bo->tbo, true, true, no_wait); | 136 | r = ttm_bo_wait(&bo->tbo, true, true, no_wait); |
141 | spin_unlock(&bo->tbo.lock); | 137 | spin_unlock(&bo->tbo.lock); |
142 | ttm_bo_unreserve(&bo->tbo); | 138 | ttm_bo_unreserve(&bo->tbo); |
143 | if (unlikely(r == -ERESTART)) | ||
144 | goto retry; | ||
145 | return r; | 139 | return r; |
146 | } | 140 | } |
147 | 141 | ||
diff --git a/drivers/gpu/drm/radeon/radeon_pm.c b/drivers/gpu/drm/radeon/radeon_pm.c index 34b08d307c81..8bce64cdc320 100644 --- a/drivers/gpu/drm/radeon/radeon_pm.c +++ b/drivers/gpu/drm/radeon/radeon_pm.c | |||
@@ -44,8 +44,11 @@ static int radeon_debugfs_pm_info(struct seq_file *m, void *data) | |||
44 | struct drm_device *dev = node->minor->dev; | 44 | struct drm_device *dev = node->minor->dev; |
45 | struct radeon_device *rdev = dev->dev_private; | 45 | struct radeon_device *rdev = dev->dev_private; |
46 | 46 | ||
47 | seq_printf(m, "engine clock: %u0 kHz\n", radeon_get_engine_clock(rdev)); | 47 | seq_printf(m, "default engine clock: %u0 kHz\n", rdev->clock.default_sclk); |
48 | seq_printf(m, "memory clock: %u0 kHz\n", radeon_get_memory_clock(rdev)); | 48 | seq_printf(m, "current engine clock: %u0 kHz\n", radeon_get_engine_clock(rdev)); |
49 | seq_printf(m, "default memory clock: %u0 kHz\n", rdev->clock.default_mclk); | ||
50 | if (rdev->asic->get_memory_clock) | ||
51 | seq_printf(m, "current memory clock: %u0 kHz\n", radeon_get_memory_clock(rdev)); | ||
49 | 52 | ||
50 | return 0; | 53 | return 0; |
51 | } | 54 | } |
diff --git a/drivers/gpu/drm/radeon/radeon_ttm.c b/drivers/gpu/drm/radeon/radeon_ttm.c index 5a19d529d1c0..d7fd160cc671 100644 --- a/drivers/gpu/drm/radeon/radeon_ttm.c +++ b/drivers/gpu/drm/radeon/radeon_ttm.c | |||
@@ -200,7 +200,19 @@ static int radeon_init_mem_type(struct ttm_bo_device *bdev, uint32_t type, | |||
200 | static void radeon_evict_flags(struct ttm_buffer_object *bo, | 200 | static void radeon_evict_flags(struct ttm_buffer_object *bo, |
201 | struct ttm_placement *placement) | 201 | struct ttm_placement *placement) |
202 | { | 202 | { |
203 | struct radeon_bo *rbo = container_of(bo, struct radeon_bo, tbo); | 203 | struct radeon_bo *rbo; |
204 | static u32 placements = TTM_PL_MASK_CACHING | TTM_PL_FLAG_SYSTEM; | ||
205 | |||
206 | if (!radeon_ttm_bo_is_radeon_bo(bo)) { | ||
207 | placement->fpfn = 0; | ||
208 | placement->lpfn = 0; | ||
209 | placement->placement = &placements; | ||
210 | placement->busy_placement = &placements; | ||
211 | placement->num_placement = 1; | ||
212 | placement->num_busy_placement = 1; | ||
213 | return; | ||
214 | } | ||
215 | rbo = container_of(bo, struct radeon_bo, tbo); | ||
204 | switch (bo->mem.mem_type) { | 216 | switch (bo->mem.mem_type) { |
205 | case TTM_PL_VRAM: | 217 | case TTM_PL_VRAM: |
206 | radeon_ttm_placement_from_domain(rbo, RADEON_GEM_DOMAIN_GTT); | 218 | radeon_ttm_placement_from_domain(rbo, RADEON_GEM_DOMAIN_GTT); |
diff --git a/drivers/gpu/drm/radeon/rs400.c b/drivers/gpu/drm/radeon/rs400.c index c1fcdddb6be6..368415df5f3a 100644 --- a/drivers/gpu/drm/radeon/rs400.c +++ b/drivers/gpu/drm/radeon/rs400.c | |||
@@ -497,6 +497,8 @@ int rs400_init(struct radeon_device *rdev) | |||
497 | 497 | ||
498 | /* Initialize clocks */ | 498 | /* Initialize clocks */ |
499 | radeon_get_clock_info(rdev->ddev); | 499 | radeon_get_clock_info(rdev->ddev); |
500 | /* Initialize power management */ | ||
501 | radeon_pm_init(rdev); | ||
500 | /* Get vram informations */ | 502 | /* Get vram informations */ |
501 | rs400_vram_info(rdev); | 503 | rs400_vram_info(rdev); |
502 | /* Initialize memory controller (also test AGP) */ | 504 | /* Initialize memory controller (also test AGP) */ |
diff --git a/drivers/gpu/drm/radeon/rv770.c b/drivers/gpu/drm/radeon/rv770.c index fbb0357f1ec3..3bcb66e52786 100644 --- a/drivers/gpu/drm/radeon/rv770.c +++ b/drivers/gpu/drm/radeon/rv770.c | |||
@@ -892,6 +892,14 @@ static int rv770_startup(struct radeon_device *rdev) | |||
892 | } | 892 | } |
893 | rv770_gpu_init(rdev); | 893 | rv770_gpu_init(rdev); |
894 | 894 | ||
895 | if (!rdev->r600_blit.shader_obj) { | ||
896 | r = r600_blit_init(rdev); | ||
897 | if (r) { | ||
898 | DRM_ERROR("radeon: failed blitter (%d).\n", r); | ||
899 | return r; | ||
900 | } | ||
901 | } | ||
902 | |||
895 | r = radeon_bo_reserve(rdev->r600_blit.shader_obj, false); | 903 | r = radeon_bo_reserve(rdev->r600_blit.shader_obj, false); |
896 | if (unlikely(r != 0)) | 904 | if (unlikely(r != 0)) |
897 | return r; | 905 | return r; |
@@ -1051,12 +1059,6 @@ int rv770_init(struct radeon_device *rdev) | |||
1051 | if (r) | 1059 | if (r) |
1052 | return r; | 1060 | return r; |
1053 | 1061 | ||
1054 | r = r600_blit_init(rdev); | ||
1055 | if (r) { | ||
1056 | DRM_ERROR("radeon: failed blitter (%d).\n", r); | ||
1057 | return r; | ||
1058 | } | ||
1059 | |||
1060 | rdev->accel_working = true; | 1062 | rdev->accel_working = true; |
1061 | r = rv770_startup(rdev); | 1063 | r = rv770_startup(rdev); |
1062 | if (r) { | 1064 | if (r) { |
diff --git a/drivers/gpu/drm/ttm/ttm_bo.c b/drivers/gpu/drm/ttm/ttm_bo.c index 1fbb2eea5e88..2920f9a279e1 100644 --- a/drivers/gpu/drm/ttm/ttm_bo.c +++ b/drivers/gpu/drm/ttm/ttm_bo.c | |||
@@ -71,34 +71,34 @@ static inline int ttm_mem_type_from_flags(uint32_t flags, uint32_t *mem_type) | |||
71 | return -EINVAL; | 71 | return -EINVAL; |
72 | } | 72 | } |
73 | 73 | ||
74 | static void ttm_mem_type_manager_debug(struct ttm_bo_global *glob, | 74 | static void ttm_mem_type_debug(struct ttm_bo_device *bdev, int mem_type) |
75 | struct ttm_mem_type_manager *man) | ||
76 | { | 75 | { |
76 | struct ttm_mem_type_manager *man = &bdev->man[mem_type]; | ||
77 | |||
77 | printk(KERN_ERR TTM_PFX " has_type: %d\n", man->has_type); | 78 | printk(KERN_ERR TTM_PFX " has_type: %d\n", man->has_type); |
78 | printk(KERN_ERR TTM_PFX " use_type: %d\n", man->use_type); | 79 | printk(KERN_ERR TTM_PFX " use_type: %d\n", man->use_type); |
79 | printk(KERN_ERR TTM_PFX " flags: 0x%08X\n", man->flags); | 80 | printk(KERN_ERR TTM_PFX " flags: 0x%08X\n", man->flags); |
80 | printk(KERN_ERR TTM_PFX " gpu_offset: 0x%08lX\n", man->gpu_offset); | 81 | printk(KERN_ERR TTM_PFX " gpu_offset: 0x%08lX\n", man->gpu_offset); |
81 | printk(KERN_ERR TTM_PFX " io_offset: 0x%08lX\n", man->io_offset); | 82 | printk(KERN_ERR TTM_PFX " io_offset: 0x%08lX\n", man->io_offset); |
82 | printk(KERN_ERR TTM_PFX " io_size: %ld\n", man->io_size); | 83 | printk(KERN_ERR TTM_PFX " io_size: %ld\n", man->io_size); |
83 | printk(KERN_ERR TTM_PFX " size: %ld\n", (unsigned long)man->size); | 84 | printk(KERN_ERR TTM_PFX " size: %llu\n", man->size); |
84 | printk(KERN_ERR TTM_PFX " available_caching: 0x%08X\n", | 85 | printk(KERN_ERR TTM_PFX " available_caching: 0x%08X\n", |
85 | man->available_caching); | 86 | man->available_caching); |
86 | printk(KERN_ERR TTM_PFX " default_caching: 0x%08X\n", | 87 | printk(KERN_ERR TTM_PFX " default_caching: 0x%08X\n", |
87 | man->default_caching); | 88 | man->default_caching); |
88 | spin_lock(&glob->lru_lock); | 89 | if (mem_type != TTM_PL_SYSTEM) { |
89 | drm_mm_debug_table(&man->manager, TTM_PFX); | 90 | spin_lock(&bdev->glob->lru_lock); |
90 | spin_unlock(&glob->lru_lock); | 91 | drm_mm_debug_table(&man->manager, TTM_PFX); |
92 | spin_unlock(&bdev->glob->lru_lock); | ||
93 | } | ||
91 | } | 94 | } |
92 | 95 | ||
93 | static void ttm_bo_mem_space_debug(struct ttm_buffer_object *bo, | 96 | static void ttm_bo_mem_space_debug(struct ttm_buffer_object *bo, |
94 | struct ttm_placement *placement) | 97 | struct ttm_placement *placement) |
95 | { | 98 | { |
96 | struct ttm_bo_device *bdev = bo->bdev; | ||
97 | struct ttm_bo_global *glob = bo->glob; | ||
98 | struct ttm_mem_type_manager *man; | ||
99 | int i, ret, mem_type; | 99 | int i, ret, mem_type; |
100 | 100 | ||
101 | printk(KERN_ERR TTM_PFX "No space for %p (%ld pages, %ldK, %ldM)\n", | 101 | printk(KERN_ERR TTM_PFX "No space for %p (%lu pages, %luK, %luM)\n", |
102 | bo, bo->mem.num_pages, bo->mem.size >> 10, | 102 | bo, bo->mem.num_pages, bo->mem.size >> 10, |
103 | bo->mem.size >> 20); | 103 | bo->mem.size >> 20); |
104 | for (i = 0; i < placement->num_placement; i++) { | 104 | for (i = 0; i < placement->num_placement; i++) { |
@@ -106,10 +106,9 @@ static void ttm_bo_mem_space_debug(struct ttm_buffer_object *bo, | |||
106 | &mem_type); | 106 | &mem_type); |
107 | if (ret) | 107 | if (ret) |
108 | return; | 108 | return; |
109 | man = &bdev->man[mem_type]; | ||
110 | printk(KERN_ERR TTM_PFX " placement[%d]=0x%08X (%d)\n", | 109 | printk(KERN_ERR TTM_PFX " placement[%d]=0x%08X (%d)\n", |
111 | i, placement->placement[i], mem_type); | 110 | i, placement->placement[i], mem_type); |
112 | ttm_mem_type_manager_debug(glob, man); | 111 | ttm_mem_type_debug(bo->bdev, mem_type); |
113 | } | 112 | } |
114 | } | 113 | } |
115 | 114 | ||
@@ -465,6 +464,8 @@ static int ttm_bo_cleanup_refs(struct ttm_buffer_object *bo, bool remove_all) | |||
465 | spin_unlock(&bo->lock); | 464 | spin_unlock(&bo->lock); |
466 | 465 | ||
467 | spin_lock(&glob->lru_lock); | 466 | spin_lock(&glob->lru_lock); |
467 | put_count = ttm_bo_del_from_lru(bo); | ||
468 | |||
468 | ret = ttm_bo_reserve_locked(bo, false, false, false, 0); | 469 | ret = ttm_bo_reserve_locked(bo, false, false, false, 0); |
469 | BUG_ON(ret); | 470 | BUG_ON(ret); |
470 | if (bo->ttm) | 471 | if (bo->ttm) |
@@ -472,20 +473,19 @@ static int ttm_bo_cleanup_refs(struct ttm_buffer_object *bo, bool remove_all) | |||
472 | 473 | ||
473 | if (!list_empty(&bo->ddestroy)) { | 474 | if (!list_empty(&bo->ddestroy)) { |
474 | list_del_init(&bo->ddestroy); | 475 | list_del_init(&bo->ddestroy); |
475 | kref_put(&bo->list_kref, ttm_bo_ref_bug); | 476 | ++put_count; |
476 | } | 477 | } |
477 | if (bo->mem.mm_node) { | 478 | if (bo->mem.mm_node) { |
478 | bo->mem.mm_node->private = NULL; | 479 | bo->mem.mm_node->private = NULL; |
479 | drm_mm_put_block(bo->mem.mm_node); | 480 | drm_mm_put_block(bo->mem.mm_node); |
480 | bo->mem.mm_node = NULL; | 481 | bo->mem.mm_node = NULL; |
481 | } | 482 | } |
482 | put_count = ttm_bo_del_from_lru(bo); | ||
483 | spin_unlock(&glob->lru_lock); | 483 | spin_unlock(&glob->lru_lock); |
484 | 484 | ||
485 | atomic_set(&bo->reserved, 0); | 485 | atomic_set(&bo->reserved, 0); |
486 | 486 | ||
487 | while (put_count--) | 487 | while (put_count--) |
488 | kref_put(&bo->list_kref, ttm_bo_release_list); | 488 | kref_put(&bo->list_kref, ttm_bo_ref_bug); |
489 | 489 | ||
490 | return 0; | 490 | return 0; |
491 | } | 491 | } |
@@ -684,19 +684,45 @@ static int ttm_mem_evict_first(struct ttm_bo_device *bdev, | |||
684 | struct ttm_buffer_object *bo; | 684 | struct ttm_buffer_object *bo; |
685 | int ret, put_count = 0; | 685 | int ret, put_count = 0; |
686 | 686 | ||
687 | retry: | ||
687 | spin_lock(&glob->lru_lock); | 688 | spin_lock(&glob->lru_lock); |
689 | if (list_empty(&man->lru)) { | ||
690 | spin_unlock(&glob->lru_lock); | ||
691 | return -EBUSY; | ||
692 | } | ||
693 | |||
688 | bo = list_first_entry(&man->lru, struct ttm_buffer_object, lru); | 694 | bo = list_first_entry(&man->lru, struct ttm_buffer_object, lru); |
689 | kref_get(&bo->list_kref); | 695 | kref_get(&bo->list_kref); |
690 | ret = ttm_bo_reserve_locked(bo, interruptible, no_wait, false, 0); | 696 | |
691 | if (likely(ret == 0)) | 697 | ret = ttm_bo_reserve_locked(bo, false, true, false, 0); |
692 | put_count = ttm_bo_del_from_lru(bo); | 698 | |
699 | if (unlikely(ret == -EBUSY)) { | ||
700 | spin_unlock(&glob->lru_lock); | ||
701 | if (likely(!no_wait)) | ||
702 | ret = ttm_bo_wait_unreserved(bo, interruptible); | ||
703 | |||
704 | kref_put(&bo->list_kref, ttm_bo_release_list); | ||
705 | |||
706 | /** | ||
707 | * We *need* to retry after releasing the lru lock. | ||
708 | */ | ||
709 | |||
710 | if (unlikely(ret != 0)) | ||
711 | return ret; | ||
712 | goto retry; | ||
713 | } | ||
714 | |||
715 | put_count = ttm_bo_del_from_lru(bo); | ||
693 | spin_unlock(&glob->lru_lock); | 716 | spin_unlock(&glob->lru_lock); |
694 | if (unlikely(ret != 0)) | 717 | |
695 | return ret; | 718 | BUG_ON(ret != 0); |
719 | |||
696 | while (put_count--) | 720 | while (put_count--) |
697 | kref_put(&bo->list_kref, ttm_bo_ref_bug); | 721 | kref_put(&bo->list_kref, ttm_bo_ref_bug); |
722 | |||
698 | ret = ttm_bo_evict(bo, interruptible, no_wait); | 723 | ret = ttm_bo_evict(bo, interruptible, no_wait); |
699 | ttm_bo_unreserve(bo); | 724 | ttm_bo_unreserve(bo); |
725 | |||
700 | kref_put(&bo->list_kref, ttm_bo_release_list); | 726 | kref_put(&bo->list_kref, ttm_bo_release_list); |
701 | return ret; | 727 | return ret; |
702 | } | 728 | } |
@@ -849,7 +875,7 @@ int ttm_bo_mem_space(struct ttm_buffer_object *bo, | |||
849 | int i, ret; | 875 | int i, ret; |
850 | 876 | ||
851 | mem->mm_node = NULL; | 877 | mem->mm_node = NULL; |
852 | for (i = 0; i <= placement->num_placement; ++i) { | 878 | for (i = 0; i < placement->num_placement; ++i) { |
853 | ret = ttm_mem_type_from_flags(placement->placement[i], | 879 | ret = ttm_mem_type_from_flags(placement->placement[i], |
854 | &mem_type); | 880 | &mem_type); |
855 | if (ret) | 881 | if (ret) |
@@ -900,8 +926,8 @@ int ttm_bo_mem_space(struct ttm_buffer_object *bo, | |||
900 | if (!type_found) | 926 | if (!type_found) |
901 | return -EINVAL; | 927 | return -EINVAL; |
902 | 928 | ||
903 | for (i = 0; i <= placement->num_busy_placement; ++i) { | 929 | for (i = 0; i < placement->num_busy_placement; ++i) { |
904 | ret = ttm_mem_type_from_flags(placement->placement[i], | 930 | ret = ttm_mem_type_from_flags(placement->busy_placement[i], |
905 | &mem_type); | 931 | &mem_type); |
906 | if (ret) | 932 | if (ret) |
907 | return ret; | 933 | return ret; |
@@ -911,7 +937,7 @@ int ttm_bo_mem_space(struct ttm_buffer_object *bo, | |||
911 | if (!ttm_bo_mt_compatible(man, | 937 | if (!ttm_bo_mt_compatible(man, |
912 | bo->type == ttm_bo_type_user, | 938 | bo->type == ttm_bo_type_user, |
913 | mem_type, | 939 | mem_type, |
914 | placement->placement[i], | 940 | placement->busy_placement[i], |
915 | &cur_flags)) | 941 | &cur_flags)) |
916 | continue; | 942 | continue; |
917 | 943 | ||
@@ -921,7 +947,7 @@ int ttm_bo_mem_space(struct ttm_buffer_object *bo, | |||
921 | * Use the access and other non-mapping-related flag bits from | 947 | * Use the access and other non-mapping-related flag bits from |
922 | * the memory placement flags to the current flags | 948 | * the memory placement flags to the current flags |
923 | */ | 949 | */ |
924 | ttm_flag_masked(&cur_flags, placement->placement[i], | 950 | ttm_flag_masked(&cur_flags, placement->busy_placement[i], |
925 | ~TTM_PL_MASK_MEMTYPE); | 951 | ~TTM_PL_MASK_MEMTYPE); |
926 | 952 | ||
927 | ret = ttm_bo_mem_force_space(bo, mem_type, placement, mem, | 953 | ret = ttm_bo_mem_force_space(bo, mem_type, placement, mem, |
@@ -1115,6 +1141,7 @@ int ttm_bo_init(struct ttm_bo_device *bdev, | |||
1115 | bo->glob = bdev->glob; | 1141 | bo->glob = bdev->glob; |
1116 | bo->type = type; | 1142 | bo->type = type; |
1117 | bo->num_pages = num_pages; | 1143 | bo->num_pages = num_pages; |
1144 | bo->mem.size = num_pages << PAGE_SHIFT; | ||
1118 | bo->mem.mem_type = TTM_PL_SYSTEM; | 1145 | bo->mem.mem_type = TTM_PL_SYSTEM; |
1119 | bo->mem.num_pages = bo->num_pages; | 1146 | bo->mem.num_pages = bo->num_pages; |
1120 | bo->mem.mm_node = NULL; | 1147 | bo->mem.mm_node = NULL; |
diff --git a/drivers/gpu/drm/ttm/ttm_bo_vm.c b/drivers/gpu/drm/ttm/ttm_bo_vm.c index 609a85a4d855..668dbe8b8dd3 100644 --- a/drivers/gpu/drm/ttm/ttm_bo_vm.c +++ b/drivers/gpu/drm/ttm/ttm_bo_vm.c | |||
@@ -320,7 +320,7 @@ ssize_t ttm_bo_io(struct ttm_bo_device *bdev, struct file *filp, | |||
320 | return -EFAULT; | 320 | return -EFAULT; |
321 | 321 | ||
322 | driver = bo->bdev->driver; | 322 | driver = bo->bdev->driver; |
323 | if (unlikely(driver->verify_access)) { | 323 | if (unlikely(!driver->verify_access)) { |
324 | ret = -EPERM; | 324 | ret = -EPERM; |
325 | goto out_unref; | 325 | goto out_unref; |
326 | } | 326 | } |