diff options
49 files changed, 3337 insertions, 1610 deletions
diff --git a/drivers/gpu/drm/drm_crtc.c b/drivers/gpu/drm/drm_crtc.c index 8e7b0ebece0c..5cae0b3eee9b 100644 --- a/drivers/gpu/drm/drm_crtc.c +++ b/drivers/gpu/drm/drm_crtc.c | |||
| @@ -1556,8 +1556,6 @@ int drm_mode_cursor_ioctl(struct drm_device *dev, | |||
| 1556 | struct drm_crtc *crtc; | 1556 | struct drm_crtc *crtc; |
| 1557 | int ret = 0; | 1557 | int ret = 0; |
| 1558 | 1558 | ||
| 1559 | DRM_DEBUG_KMS("\n"); | ||
| 1560 | |||
| 1561 | if (!req->flags) { | 1559 | if (!req->flags) { |
| 1562 | DRM_ERROR("no operation set\n"); | 1560 | DRM_ERROR("no operation set\n"); |
| 1563 | return -EINVAL; | 1561 | return -EINVAL; |
diff --git a/drivers/gpu/drm/drm_fb_helper.c b/drivers/gpu/drm/drm_fb_helper.c index 819ddcbfcce5..23dc9c115fd9 100644 --- a/drivers/gpu/drm/drm_fb_helper.c +++ b/drivers/gpu/drm/drm_fb_helper.c | |||
| @@ -454,6 +454,96 @@ out_free: | |||
| 454 | } | 454 | } |
| 455 | EXPORT_SYMBOL(drm_fb_helper_init_crtc_count); | 455 | EXPORT_SYMBOL(drm_fb_helper_init_crtc_count); |
| 456 | 456 | ||
| 457 | static void setcolreg(struct drm_crtc *crtc, u16 red, u16 green, | ||
| 458 | u16 blue, u16 regno, struct fb_info *info) | ||
| 459 | { | ||
| 460 | struct drm_fb_helper *fb_helper = info->par; | ||
| 461 | struct drm_framebuffer *fb = fb_helper->fb; | ||
| 462 | int pindex; | ||
| 463 | |||
| 464 | pindex = regno; | ||
| 465 | |||
| 466 | if (fb->bits_per_pixel == 16) { | ||
| 467 | pindex = regno << 3; | ||
| 468 | |||
| 469 | if (fb->depth == 16 && regno > 63) | ||
| 470 | return; | ||
| 471 | if (fb->depth == 15 && regno > 31) | ||
| 472 | return; | ||
| 473 | |||
| 474 | if (fb->depth == 16) { | ||
| 475 | u16 r, g, b; | ||
| 476 | int i; | ||
| 477 | if (regno < 32) { | ||
| 478 | for (i = 0; i < 8; i++) | ||
| 479 | fb_helper->funcs->gamma_set(crtc, red, | ||
| 480 | green, blue, pindex + i); | ||
| 481 | } | ||
| 482 | |||
| 483 | fb_helper->funcs->gamma_get(crtc, &r, | ||
| 484 | &g, &b, | ||
| 485 | pindex >> 1); | ||
| 486 | |||
| 487 | for (i = 0; i < 4; i++) | ||
| 488 | fb_helper->funcs->gamma_set(crtc, r, | ||
| 489 | green, b, | ||
| 490 | (pindex >> 1) + i); | ||
| 491 | } | ||
| 492 | } | ||
| 493 | |||
| 494 | if (fb->depth != 16) | ||
| 495 | fb_helper->funcs->gamma_set(crtc, red, green, blue, pindex); | ||
| 496 | |||
| 497 | if (regno < 16 && info->fix.visual == FB_VISUAL_DIRECTCOLOR) { | ||
| 498 | ((u32 *) fb->pseudo_palette)[regno] = | ||
| 499 | (regno << info->var.red.offset) | | ||
| 500 | (regno << info->var.green.offset) | | ||
| 501 | (regno << info->var.blue.offset); | ||
| 502 | } | ||
| 503 | } | ||
| 504 | |||
| 505 | int drm_fb_helper_setcmap(struct fb_cmap *cmap, struct fb_info *info) | ||
| 506 | { | ||
| 507 | struct drm_fb_helper *fb_helper = info->par; | ||
| 508 | struct drm_device *dev = fb_helper->dev; | ||
| 509 | u16 *red, *green, *blue, *transp; | ||
| 510 | struct drm_crtc *crtc; | ||
| 511 | int i, rc = 0; | ||
| 512 | int start; | ||
| 513 | |||
| 514 | list_for_each_entry(crtc, &dev->mode_config.crtc_list, head) { | ||
| 515 | struct drm_crtc_helper_funcs *crtc_funcs = crtc->helper_private; | ||
| 516 | for (i = 0; i < fb_helper->crtc_count; i++) { | ||
| 517 | if (crtc->base.id == fb_helper->crtc_info[i].crtc_id) | ||
| 518 | break; | ||
| 519 | } | ||
| 520 | if (i == fb_helper->crtc_count) | ||
| 521 | continue; | ||
| 522 | |||
| 523 | red = cmap->red; | ||
| 524 | green = cmap->green; | ||
| 525 | blue = cmap->blue; | ||
| 526 | transp = cmap->transp; | ||
| 527 | start = cmap->start; | ||
| 528 | |||
| 529 | for (i = 0; i < cmap->len; i++) { | ||
| 530 | u16 hred, hgreen, hblue, htransp = 0xffff; | ||
| 531 | |||
| 532 | hred = *red++; | ||
| 533 | hgreen = *green++; | ||
| 534 | hblue = *blue++; | ||
| 535 | |||
| 536 | if (transp) | ||
| 537 | htransp = *transp++; | ||
| 538 | |||
| 539 | setcolreg(crtc, hred, hgreen, hblue, start++, info); | ||
| 540 | } | ||
| 541 | crtc_funcs->load_lut(crtc); | ||
| 542 | } | ||
| 543 | return rc; | ||
| 544 | } | ||
| 545 | EXPORT_SYMBOL(drm_fb_helper_setcmap); | ||
| 546 | |||
| 457 | int drm_fb_helper_setcolreg(unsigned regno, | 547 | int drm_fb_helper_setcolreg(unsigned regno, |
| 458 | unsigned red, | 548 | unsigned red, |
| 459 | unsigned green, | 549 | unsigned green, |
| @@ -466,9 +556,11 @@ int drm_fb_helper_setcolreg(unsigned regno, | |||
| 466 | struct drm_crtc *crtc; | 556 | struct drm_crtc *crtc; |
| 467 | int i; | 557 | int i; |
| 468 | 558 | ||
| 469 | list_for_each_entry(crtc, &dev->mode_config.crtc_list, head) { | 559 | if (regno > 255) |
| 470 | struct drm_framebuffer *fb = fb_helper->fb; | 560 | return 1; |
| 471 | 561 | ||
| 562 | list_for_each_entry(crtc, &dev->mode_config.crtc_list, head) { | ||
| 563 | struct drm_crtc_helper_funcs *crtc_funcs = crtc->helper_private; | ||
| 472 | for (i = 0; i < fb_helper->crtc_count; i++) { | 564 | for (i = 0; i < fb_helper->crtc_count; i++) { |
| 473 | if (crtc->base.id == fb_helper->crtc_info[i].crtc_id) | 565 | if (crtc->base.id == fb_helper->crtc_info[i].crtc_id) |
| 474 | break; | 566 | break; |
| @@ -476,35 +568,9 @@ int drm_fb_helper_setcolreg(unsigned regno, | |||
| 476 | if (i == fb_helper->crtc_count) | 568 | if (i == fb_helper->crtc_count) |
| 477 | continue; | 569 | continue; |
| 478 | 570 | ||
| 479 | if (regno > 255) | ||
| 480 | return 1; | ||
| 481 | |||
| 482 | if (fb->depth == 8) { | ||
| 483 | fb_helper->funcs->gamma_set(crtc, red, green, blue, regno); | ||
| 484 | return 0; | ||
| 485 | } | ||
| 486 | 571 | ||
| 487 | if (regno < 16) { | 572 | setcolreg(crtc, red, green, blue, regno, info); |
| 488 | switch (fb->depth) { | 573 | crtc_funcs->load_lut(crtc); |
| 489 | case 15: | ||
| 490 | fb->pseudo_palette[regno] = ((red & 0xf800) >> 1) | | ||
| 491 | ((green & 0xf800) >> 6) | | ||
| 492 | ((blue & 0xf800) >> 11); | ||
| 493 | break; | ||
| 494 | case 16: | ||
| 495 | fb->pseudo_palette[regno] = (red & 0xf800) | | ||
| 496 | ((green & 0xfc00) >> 5) | | ||
| 497 | ((blue & 0xf800) >> 11); | ||
| 498 | break; | ||
| 499 | case 24: | ||
| 500 | case 32: | ||
| 501 | fb->pseudo_palette[regno] = | ||
| 502 | (((red >> 8) & 0xff) << info->var.red.offset) | | ||
| 503 | (((green >> 8) & 0xff) << info->var.green.offset) | | ||
| 504 | (((blue >> 8) & 0xff) << info->var.blue.offset); | ||
| 505 | break; | ||
| 506 | } | ||
| 507 | } | ||
| 508 | } | 574 | } |
| 509 | return 0; | 575 | return 0; |
| 510 | } | 576 | } |
| @@ -674,6 +740,7 @@ int drm_fb_helper_pan_display(struct fb_var_screeninfo *var, | |||
| 674 | EXPORT_SYMBOL(drm_fb_helper_pan_display); | 740 | EXPORT_SYMBOL(drm_fb_helper_pan_display); |
| 675 | 741 | ||
| 676 | int drm_fb_helper_single_fb_probe(struct drm_device *dev, | 742 | int drm_fb_helper_single_fb_probe(struct drm_device *dev, |
| 743 | int preferred_bpp, | ||
| 677 | int (*fb_create)(struct drm_device *dev, | 744 | int (*fb_create)(struct drm_device *dev, |
| 678 | uint32_t fb_width, | 745 | uint32_t fb_width, |
| 679 | uint32_t fb_height, | 746 | uint32_t fb_height, |
| @@ -696,6 +763,11 @@ int drm_fb_helper_single_fb_probe(struct drm_device *dev, | |||
| 696 | struct drm_fb_helper *fb_helper; | 763 | struct drm_fb_helper *fb_helper; |
| 697 | uint32_t surface_depth = 24, surface_bpp = 32; | 764 | uint32_t surface_depth = 24, surface_bpp = 32; |
| 698 | 765 | ||
| 766 | /* if driver picks 8 or 16 by default use that | ||
| 767 | for both depth/bpp */ | ||
| 768 | if (preferred_bpp != surface_bpp) { | ||
| 769 | surface_depth = surface_bpp = preferred_bpp; | ||
| 770 | } | ||
| 699 | /* first up get a count of crtcs now in use and new min/maxes width/heights */ | 771 | /* first up get a count of crtcs now in use and new min/maxes width/heights */ |
| 700 | list_for_each_entry(connector, &dev->mode_config.connector_list, head) { | 772 | list_for_each_entry(connector, &dev->mode_config.connector_list, head) { |
| 701 | struct drm_fb_helper_connector *fb_help_conn = connector->fb_helper_private; | 773 | struct drm_fb_helper_connector *fb_help_conn = connector->fb_helper_private; |
| @@ -851,10 +923,12 @@ void drm_fb_helper_free(struct drm_fb_helper *helper) | |||
| 851 | } | 923 | } |
| 852 | EXPORT_SYMBOL(drm_fb_helper_free); | 924 | EXPORT_SYMBOL(drm_fb_helper_free); |
| 853 | 925 | ||
| 854 | void drm_fb_helper_fill_fix(struct fb_info *info, uint32_t pitch) | 926 | void drm_fb_helper_fill_fix(struct fb_info *info, uint32_t pitch, |
| 927 | uint32_t depth) | ||
| 855 | { | 928 | { |
| 856 | info->fix.type = FB_TYPE_PACKED_PIXELS; | 929 | info->fix.type = FB_TYPE_PACKED_PIXELS; |
| 857 | info->fix.visual = FB_VISUAL_TRUECOLOR; | 930 | info->fix.visual = depth == 8 ? FB_VISUAL_PSEUDOCOLOR : |
| 931 | FB_VISUAL_DIRECTCOLOR; | ||
| 858 | info->fix.type_aux = 0; | 932 | info->fix.type_aux = 0; |
| 859 | info->fix.xpanstep = 1; /* doing it in hw */ | 933 | info->fix.xpanstep = 1; /* doing it in hw */ |
| 860 | info->fix.ypanstep = 1; /* doing it in hw */ | 934 | info->fix.ypanstep = 1; /* doing it in hw */ |
diff --git a/drivers/gpu/drm/i915/intel_display.c b/drivers/gpu/drm/i915/intel_display.c index 93ff6c03733e..ffa39671751f 100644 --- a/drivers/gpu/drm/i915/intel_display.c +++ b/drivers/gpu/drm/i915/intel_display.c | |||
| @@ -3244,6 +3244,16 @@ void intel_crtc_fb_gamma_set(struct drm_crtc *crtc, u16 red, u16 green, | |||
| 3244 | intel_crtc->lut_b[regno] = blue >> 8; | 3244 | intel_crtc->lut_b[regno] = blue >> 8; |
| 3245 | } | 3245 | } |
| 3246 | 3246 | ||
| 3247 | void intel_crtc_fb_gamma_get(struct drm_crtc *crtc, u16 *red, u16 *green, | ||
| 3248 | u16 *blue, int regno) | ||
| 3249 | { | ||
| 3250 | struct intel_crtc *intel_crtc = to_intel_crtc(crtc); | ||
| 3251 | |||
| 3252 | *red = intel_crtc->lut_r[regno] << 8; | ||
| 3253 | *green = intel_crtc->lut_g[regno] << 8; | ||
| 3254 | *blue = intel_crtc->lut_b[regno] << 8; | ||
| 3255 | } | ||
| 3256 | |||
| 3247 | static void intel_crtc_gamma_set(struct drm_crtc *crtc, u16 *red, u16 *green, | 3257 | static void intel_crtc_gamma_set(struct drm_crtc *crtc, u16 *red, u16 *green, |
| 3248 | u16 *blue, uint32_t size) | 3258 | u16 *blue, uint32_t size) |
| 3249 | { | 3259 | { |
| @@ -3835,6 +3845,7 @@ static const struct drm_crtc_helper_funcs intel_helper_funcs = { | |||
| 3835 | .mode_set_base = intel_pipe_set_base, | 3845 | .mode_set_base = intel_pipe_set_base, |
| 3836 | .prepare = intel_crtc_prepare, | 3846 | .prepare = intel_crtc_prepare, |
| 3837 | .commit = intel_crtc_commit, | 3847 | .commit = intel_crtc_commit, |
| 3848 | .load_lut = intel_crtc_load_lut, | ||
| 3838 | }; | 3849 | }; |
| 3839 | 3850 | ||
| 3840 | static const struct drm_crtc_funcs intel_crtc_funcs = { | 3851 | static const struct drm_crtc_funcs intel_crtc_funcs = { |
diff --git a/drivers/gpu/drm/i915/intel_drv.h b/drivers/gpu/drm/i915/intel_drv.h index 8aa4b7f30daa..ef61fe9507e2 100644 --- a/drivers/gpu/drm/i915/intel_drv.h +++ b/drivers/gpu/drm/i915/intel_drv.h | |||
| @@ -175,6 +175,8 @@ extern int intelfb_resize(struct drm_device *dev, struct drm_crtc *crtc); | |||
| 175 | extern void intelfb_restore(void); | 175 | extern void intelfb_restore(void); |
| 176 | extern void intel_crtc_fb_gamma_set(struct drm_crtc *crtc, u16 red, u16 green, | 176 | extern void intel_crtc_fb_gamma_set(struct drm_crtc *crtc, u16 red, u16 green, |
| 177 | u16 blue, int regno); | 177 | u16 blue, int regno); |
| 178 | extern void intel_crtc_fb_gamma_get(struct drm_crtc *crtc, u16 *red, u16 *green, | ||
| 179 | u16 *blue, int regno); | ||
| 178 | 180 | ||
| 179 | extern int intel_framebuffer_create(struct drm_device *dev, | 181 | extern int intel_framebuffer_create(struct drm_device *dev, |
| 180 | struct drm_mode_fb_cmd *mode_cmd, | 182 | struct drm_mode_fb_cmd *mode_cmd, |
diff --git a/drivers/gpu/drm/i915/intel_fb.c b/drivers/gpu/drm/i915/intel_fb.c index e85d7e9eed7d..2b0fe54cd92c 100644 --- a/drivers/gpu/drm/i915/intel_fb.c +++ b/drivers/gpu/drm/i915/intel_fb.c | |||
| @@ -60,10 +60,12 @@ static struct fb_ops intelfb_ops = { | |||
| 60 | .fb_imageblit = cfb_imageblit, | 60 | .fb_imageblit = cfb_imageblit, |
| 61 | .fb_pan_display = drm_fb_helper_pan_display, | 61 | .fb_pan_display = drm_fb_helper_pan_display, |
| 62 | .fb_blank = drm_fb_helper_blank, | 62 | .fb_blank = drm_fb_helper_blank, |
| 63 | .fb_setcmap = drm_fb_helper_setcmap, | ||
| 63 | }; | 64 | }; |
| 64 | 65 | ||
| 65 | static struct drm_fb_helper_funcs intel_fb_helper_funcs = { | 66 | static struct drm_fb_helper_funcs intel_fb_helper_funcs = { |
| 66 | .gamma_set = intel_crtc_fb_gamma_set, | 67 | .gamma_set = intel_crtc_fb_gamma_set, |
| 68 | .gamma_get = intel_crtc_fb_gamma_get, | ||
| 67 | }; | 69 | }; |
| 68 | 70 | ||
| 69 | 71 | ||
| @@ -123,6 +125,10 @@ static int intelfb_create(struct drm_device *dev, uint32_t fb_width, | |||
| 123 | struct device *device = &dev->pdev->dev; | 125 | struct device *device = &dev->pdev->dev; |
| 124 | int size, ret, mmio_bar = IS_I9XX(dev) ? 0 : 1; | 126 | int size, ret, mmio_bar = IS_I9XX(dev) ? 0 : 1; |
| 125 | 127 | ||
| 128 | /* we don't do packed 24bpp */ | ||
| 129 | if (surface_bpp == 24) | ||
| 130 | surface_bpp = 32; | ||
| 131 | |||
| 126 | mode_cmd.width = surface_width; | 132 | mode_cmd.width = surface_width; |
| 127 | mode_cmd.height = surface_height; | 133 | mode_cmd.height = surface_height; |
| 128 | 134 | ||
| @@ -206,7 +212,7 @@ static int intelfb_create(struct drm_device *dev, uint32_t fb_width, | |||
| 206 | 212 | ||
| 207 | // memset(info->screen_base, 0, size); | 213 | // memset(info->screen_base, 0, size); |
| 208 | 214 | ||
| 209 | drm_fb_helper_fill_fix(info, fb->pitch); | 215 | drm_fb_helper_fill_fix(info, fb->pitch, fb->depth); |
| 210 | drm_fb_helper_fill_var(info, fb, fb_width, fb_height); | 216 | drm_fb_helper_fill_var(info, fb, fb_width, fb_height); |
| 211 | 217 | ||
| 212 | /* FIXME: we really shouldn't expose mmio space at all */ | 218 | /* FIXME: we really shouldn't expose mmio space at all */ |
| @@ -244,7 +250,7 @@ int intelfb_probe(struct drm_device *dev) | |||
| 244 | int ret; | 250 | int ret; |
| 245 | 251 | ||
| 246 | DRM_DEBUG("\n"); | 252 | DRM_DEBUG("\n"); |
| 247 | ret = drm_fb_helper_single_fb_probe(dev, intelfb_create); | 253 | ret = drm_fb_helper_single_fb_probe(dev, 32, intelfb_create); |
| 248 | return ret; | 254 | return ret; |
| 249 | } | 255 | } |
| 250 | EXPORT_SYMBOL(intelfb_probe); | 256 | EXPORT_SYMBOL(intelfb_probe); |
diff --git a/drivers/gpu/drm/radeon/atombios_crtc.c b/drivers/gpu/drm/radeon/atombios_crtc.c index 6a015929deee..14fa9701aeb3 100644 --- a/drivers/gpu/drm/radeon/atombios_crtc.c +++ b/drivers/gpu/drm/radeon/atombios_crtc.c | |||
| @@ -733,6 +733,7 @@ static const struct drm_crtc_helper_funcs atombios_helper_funcs = { | |||
| 733 | .mode_set_base = atombios_crtc_set_base, | 733 | .mode_set_base = atombios_crtc_set_base, |
| 734 | .prepare = atombios_crtc_prepare, | 734 | .prepare = atombios_crtc_prepare, |
| 735 | .commit = atombios_crtc_commit, | 735 | .commit = atombios_crtc_commit, |
| 736 | .load_lut = radeon_crtc_load_lut, | ||
| 736 | }; | 737 | }; |
| 737 | 738 | ||
| 738 | void radeon_atombios_init_crtc(struct drm_device *dev, | 739 | void radeon_atombios_init_crtc(struct drm_device *dev, |
diff --git a/drivers/gpu/drm/radeon/r100.c b/drivers/gpu/drm/radeon/r100.c index e6cce24de802..161094c07d94 100644 --- a/drivers/gpu/drm/radeon/r100.c +++ b/drivers/gpu/drm/radeon/r100.c | |||
| @@ -32,6 +32,9 @@ | |||
| 32 | #include "radeon_reg.h" | 32 | #include "radeon_reg.h" |
| 33 | #include "radeon.h" | 33 | #include "radeon.h" |
| 34 | #include "r100d.h" | 34 | #include "r100d.h" |
| 35 | #include "rs100d.h" | ||
| 36 | #include "rv200d.h" | ||
| 37 | #include "rv250d.h" | ||
| 35 | 38 | ||
| 36 | #include <linux/firmware.h> | 39 | #include <linux/firmware.h> |
| 37 | #include <linux/platform_device.h> | 40 | #include <linux/platform_device.h> |
| @@ -60,18 +63,7 @@ MODULE_FIRMWARE(FIRMWARE_R520); | |||
| 60 | 63 | ||
| 61 | /* This files gather functions specifics to: | 64 | /* This files gather functions specifics to: |
| 62 | * r100,rv100,rs100,rv200,rs200,r200,rv250,rs300,rv280 | 65 | * r100,rv100,rs100,rv200,rs200,r200,rv250,rs300,rv280 |
| 63 | * | ||
| 64 | * Some of these functions might be used by newer ASICs. | ||
| 65 | */ | 66 | */ |
| 66 | int r200_init(struct radeon_device *rdev); | ||
| 67 | void r100_hdp_reset(struct radeon_device *rdev); | ||
| 68 | void r100_gpu_init(struct radeon_device *rdev); | ||
| 69 | int r100_gui_wait_for_idle(struct radeon_device *rdev); | ||
| 70 | int r100_mc_wait_for_idle(struct radeon_device *rdev); | ||
| 71 | void r100_gpu_wait_for_vsync(struct radeon_device *rdev); | ||
| 72 | void r100_gpu_wait_for_vsync2(struct radeon_device *rdev); | ||
| 73 | int r100_debugfs_mc_info_init(struct radeon_device *rdev); | ||
| 74 | |||
| 75 | 67 | ||
| 76 | /* | 68 | /* |
| 77 | * PCI GART | 69 | * PCI GART |
| @@ -152,136 +144,6 @@ void r100_pci_gart_fini(struct radeon_device *rdev) | |||
| 152 | radeon_gart_fini(rdev); | 144 | radeon_gart_fini(rdev); |
| 153 | } | 145 | } |
| 154 | 146 | ||
| 155 | |||
| 156 | /* | ||
| 157 | * MC | ||
| 158 | */ | ||
| 159 | void r100_mc_disable_clients(struct radeon_device *rdev) | ||
| 160 | { | ||
| 161 | uint32_t ov0_scale_cntl, crtc_ext_cntl, crtc_gen_cntl, crtc2_gen_cntl; | ||
| 162 | |||
| 163 | /* FIXME: is this function correct for rs100,rs200,rs300 ? */ | ||
| 164 | if (r100_gui_wait_for_idle(rdev)) { | ||
| 165 | printk(KERN_WARNING "Failed to wait GUI idle while " | ||
| 166 | "programming pipes. Bad things might happen.\n"); | ||
| 167 | } | ||
| 168 | |||
| 169 | /* stop display and memory access */ | ||
| 170 | ov0_scale_cntl = RREG32(RADEON_OV0_SCALE_CNTL); | ||
| 171 | WREG32(RADEON_OV0_SCALE_CNTL, ov0_scale_cntl & ~RADEON_SCALER_ENABLE); | ||
| 172 | crtc_ext_cntl = RREG32(RADEON_CRTC_EXT_CNTL); | ||
| 173 | WREG32(RADEON_CRTC_EXT_CNTL, crtc_ext_cntl | RADEON_CRTC_DISPLAY_DIS); | ||
| 174 | crtc_gen_cntl = RREG32(RADEON_CRTC_GEN_CNTL); | ||
| 175 | |||
| 176 | r100_gpu_wait_for_vsync(rdev); | ||
| 177 | |||
| 178 | WREG32(RADEON_CRTC_GEN_CNTL, | ||
| 179 | (crtc_gen_cntl & ~(RADEON_CRTC_CUR_EN | RADEON_CRTC_ICON_EN)) | | ||
| 180 | RADEON_CRTC_DISP_REQ_EN_B | RADEON_CRTC_EXT_DISP_EN); | ||
| 181 | |||
| 182 | if (!(rdev->flags & RADEON_SINGLE_CRTC)) { | ||
| 183 | crtc2_gen_cntl = RREG32(RADEON_CRTC2_GEN_CNTL); | ||
| 184 | |||
| 185 | r100_gpu_wait_for_vsync2(rdev); | ||
| 186 | WREG32(RADEON_CRTC2_GEN_CNTL, | ||
| 187 | (crtc2_gen_cntl & | ||
| 188 | ~(RADEON_CRTC2_CUR_EN | RADEON_CRTC2_ICON_EN)) | | ||
| 189 | RADEON_CRTC2_DISP_REQ_EN_B); | ||
| 190 | } | ||
| 191 | |||
| 192 | udelay(500); | ||
| 193 | } | ||
| 194 | |||
| 195 | void r100_mc_setup(struct radeon_device *rdev) | ||
| 196 | { | ||
| 197 | uint32_t tmp; | ||
| 198 | int r; | ||
| 199 | |||
| 200 | r = r100_debugfs_mc_info_init(rdev); | ||
| 201 | if (r) { | ||
| 202 | DRM_ERROR("Failed to register debugfs file for R100 MC !\n"); | ||
| 203 | } | ||
| 204 | /* Write VRAM size in case we are limiting it */ | ||
| 205 | WREG32(RADEON_CONFIG_MEMSIZE, rdev->mc.real_vram_size); | ||
| 206 | /* Novell bug 204882 for RN50/M6/M7 with 8/16/32MB VRAM, | ||
| 207 | * if the aperture is 64MB but we have 32MB VRAM | ||
| 208 | * we report only 32MB VRAM but we have to set MC_FB_LOCATION | ||
| 209 | * to 64MB, otherwise the gpu accidentially dies */ | ||
| 210 | tmp = rdev->mc.vram_location + rdev->mc.mc_vram_size - 1; | ||
| 211 | tmp = REG_SET(RADEON_MC_FB_TOP, tmp >> 16); | ||
| 212 | tmp |= REG_SET(RADEON_MC_FB_START, rdev->mc.vram_location >> 16); | ||
| 213 | WREG32(RADEON_MC_FB_LOCATION, tmp); | ||
| 214 | |||
| 215 | /* Enable bus mastering */ | ||
| 216 | tmp = RREG32(RADEON_BUS_CNTL) & ~RADEON_BUS_MASTER_DIS; | ||
| 217 | WREG32(RADEON_BUS_CNTL, tmp); | ||
| 218 | |||
| 219 | if (rdev->flags & RADEON_IS_AGP) { | ||
| 220 | tmp = rdev->mc.gtt_location + rdev->mc.gtt_size - 1; | ||
| 221 | tmp = REG_SET(RADEON_MC_AGP_TOP, tmp >> 16); | ||
| 222 | tmp |= REG_SET(RADEON_MC_AGP_START, rdev->mc.gtt_location >> 16); | ||
| 223 | WREG32(RADEON_MC_AGP_LOCATION, tmp); | ||
| 224 | WREG32(RADEON_AGP_BASE, rdev->mc.agp_base); | ||
| 225 | } else { | ||
| 226 | WREG32(RADEON_MC_AGP_LOCATION, 0x0FFFFFFF); | ||
| 227 | WREG32(RADEON_AGP_BASE, 0); | ||
| 228 | } | ||
| 229 | |||
| 230 | tmp = RREG32(RADEON_HOST_PATH_CNTL) & RADEON_HDP_APER_CNTL; | ||
| 231 | tmp |= (7 << 28); | ||
| 232 | WREG32(RADEON_HOST_PATH_CNTL, tmp | RADEON_HDP_SOFT_RESET | RADEON_HDP_READ_BUFFER_INVALIDATE); | ||
| 233 | (void)RREG32(RADEON_HOST_PATH_CNTL); | ||
| 234 | WREG32(RADEON_HOST_PATH_CNTL, tmp); | ||
| 235 | (void)RREG32(RADEON_HOST_PATH_CNTL); | ||
| 236 | } | ||
| 237 | |||
| 238 | int r100_mc_init(struct radeon_device *rdev) | ||
| 239 | { | ||
| 240 | int r; | ||
| 241 | |||
| 242 | if (r100_debugfs_rbbm_init(rdev)) { | ||
| 243 | DRM_ERROR("Failed to register debugfs file for RBBM !\n"); | ||
| 244 | } | ||
| 245 | |||
| 246 | r100_gpu_init(rdev); | ||
| 247 | /* Disable gart which also disable out of gart access */ | ||
| 248 | r100_pci_gart_disable(rdev); | ||
| 249 | |||
| 250 | /* Setup GPU memory space */ | ||
| 251 | rdev->mc.gtt_location = 0xFFFFFFFFUL; | ||
| 252 | if (rdev->flags & RADEON_IS_AGP) { | ||
| 253 | r = radeon_agp_init(rdev); | ||
| 254 | if (r) { | ||
| 255 | printk(KERN_WARNING "[drm] Disabling AGP\n"); | ||
| 256 | rdev->flags &= ~RADEON_IS_AGP; | ||
| 257 | rdev->mc.gtt_size = radeon_gart_size * 1024 * 1024; | ||
| 258 | } else { | ||
| 259 | rdev->mc.gtt_location = rdev->mc.agp_base; | ||
| 260 | } | ||
| 261 | } | ||
| 262 | r = radeon_mc_setup(rdev); | ||
| 263 | if (r) { | ||
| 264 | return r; | ||
| 265 | } | ||
| 266 | |||
| 267 | r100_mc_disable_clients(rdev); | ||
| 268 | if (r100_mc_wait_for_idle(rdev)) { | ||
| 269 | printk(KERN_WARNING "Failed to wait MC idle while " | ||
| 270 | "programming pipes. Bad things might happen.\n"); | ||
| 271 | } | ||
| 272 | |||
| 273 | r100_mc_setup(rdev); | ||
| 274 | return 0; | ||
| 275 | } | ||
| 276 | |||
| 277 | void r100_mc_fini(struct radeon_device *rdev) | ||
| 278 | { | ||
| 279 | } | ||
| 280 | |||
| 281 | |||
| 282 | /* | ||
| 283 | * Interrupts | ||
| 284 | */ | ||
| 285 | int r100_irq_set(struct radeon_device *rdev) | 147 | int r100_irq_set(struct radeon_device *rdev) |
| 286 | { | 148 | { |
| 287 | uint32_t tmp = 0; | 149 | uint32_t tmp = 0; |
| @@ -358,10 +220,6 @@ u32 r100_get_vblank_counter(struct radeon_device *rdev, int crtc) | |||
| 358 | return RREG32(RADEON_CRTC2_CRNT_FRAME); | 220 | return RREG32(RADEON_CRTC2_CRNT_FRAME); |
| 359 | } | 221 | } |
| 360 | 222 | ||
| 361 | |||
| 362 | /* | ||
| 363 | * Fence emission | ||
| 364 | */ | ||
| 365 | void r100_fence_ring_emit(struct radeon_device *rdev, | 223 | void r100_fence_ring_emit(struct radeon_device *rdev, |
| 366 | struct radeon_fence *fence) | 224 | struct radeon_fence *fence) |
| 367 | { | 225 | { |
| @@ -377,10 +235,6 @@ void r100_fence_ring_emit(struct radeon_device *rdev, | |||
| 377 | radeon_ring_write(rdev, RADEON_SW_INT_FIRE); | 235 | radeon_ring_write(rdev, RADEON_SW_INT_FIRE); |
| 378 | } | 236 | } |
| 379 | 237 | ||
| 380 | |||
| 381 | /* | ||
| 382 | * Writeback | ||
| 383 | */ | ||
| 384 | int r100_wb_init(struct radeon_device *rdev) | 238 | int r100_wb_init(struct radeon_device *rdev) |
| 385 | { | 239 | { |
| 386 | int r; | 240 | int r; |
| @@ -504,10 +358,6 @@ int r100_copy_blit(struct radeon_device *rdev, | |||
| 504 | return r; | 358 | return r; |
| 505 | } | 359 | } |
| 506 | 360 | ||
| 507 | |||
| 508 | /* | ||
| 509 | * CP | ||
| 510 | */ | ||
| 511 | static int r100_cp_wait_for_idle(struct radeon_device *rdev) | 361 | static int r100_cp_wait_for_idle(struct radeon_device *rdev) |
| 512 | { | 362 | { |
| 513 | unsigned i; | 363 | unsigned i; |
| @@ -612,6 +462,7 @@ static int r100_cp_init_microcode(struct radeon_device *rdev) | |||
| 612 | } | 462 | } |
| 613 | return err; | 463 | return err; |
| 614 | } | 464 | } |
| 465 | |||
| 615 | static void r100_cp_load_microcode(struct radeon_device *rdev) | 466 | static void r100_cp_load_microcode(struct radeon_device *rdev) |
| 616 | { | 467 | { |
| 617 | const __be32 *fw_data; | 468 | const __be32 *fw_data; |
| @@ -978,7 +829,7 @@ int r100_cs_packet_parse_vline(struct radeon_cs_parser *p) | |||
| 978 | 829 | ||
| 979 | header = radeon_get_ib_value(p, h_idx); | 830 | header = radeon_get_ib_value(p, h_idx); |
| 980 | crtc_id = radeon_get_ib_value(p, h_idx + 5); | 831 | crtc_id = radeon_get_ib_value(p, h_idx + 5); |
| 981 | reg = header >> 2; | 832 | reg = CP_PACKET0_GET_REG(header); |
| 982 | mutex_lock(&p->rdev->ddev->mode_config.mutex); | 833 | mutex_lock(&p->rdev->ddev->mode_config.mutex); |
| 983 | obj = drm_mode_object_find(p->rdev->ddev, crtc_id, DRM_MODE_OBJECT_CRTC); | 834 | obj = drm_mode_object_find(p->rdev->ddev, crtc_id, DRM_MODE_OBJECT_CRTC); |
| 984 | if (!obj) { | 835 | if (!obj) { |
| @@ -1990,7 +1841,7 @@ void r100_pll_wreg(struct radeon_device *rdev, uint32_t reg, uint32_t v) | |||
| 1990 | r100_pll_errata_after_data(rdev); | 1841 | r100_pll_errata_after_data(rdev); |
| 1991 | } | 1842 | } |
| 1992 | 1843 | ||
| 1993 | int r100_init(struct radeon_device *rdev) | 1844 | void r100_set_safe_registers(struct radeon_device *rdev) |
| 1994 | { | 1845 | { |
| 1995 | if (ASIC_IS_RN50(rdev)) { | 1846 | if (ASIC_IS_RN50(rdev)) { |
| 1996 | rdev->config.r100.reg_safe_bm = rn50_reg_safe_bm; | 1847 | rdev->config.r100.reg_safe_bm = rn50_reg_safe_bm; |
| @@ -1999,9 +1850,8 @@ int r100_init(struct radeon_device *rdev) | |||
| 1999 | rdev->config.r100.reg_safe_bm = r100_reg_safe_bm; | 1850 | rdev->config.r100.reg_safe_bm = r100_reg_safe_bm; |
| 2000 | rdev->config.r100.reg_safe_bm_size = ARRAY_SIZE(r100_reg_safe_bm); | 1851 | rdev->config.r100.reg_safe_bm_size = ARRAY_SIZE(r100_reg_safe_bm); |
| 2001 | } else { | 1852 | } else { |
| 2002 | return r200_init(rdev); | 1853 | r200_set_safe_registers(rdev); |
| 2003 | } | 1854 | } |
| 2004 | return 0; | ||
| 2005 | } | 1855 | } |
| 2006 | 1856 | ||
| 2007 | /* | 1857 | /* |
| @@ -2299,9 +2149,11 @@ void r100_bandwidth_update(struct radeon_device *rdev) | |||
| 2299 | mode1 = &rdev->mode_info.crtcs[0]->base.mode; | 2149 | mode1 = &rdev->mode_info.crtcs[0]->base.mode; |
| 2300 | pixel_bytes1 = rdev->mode_info.crtcs[0]->base.fb->bits_per_pixel / 8; | 2150 | pixel_bytes1 = rdev->mode_info.crtcs[0]->base.fb->bits_per_pixel / 8; |
| 2301 | } | 2151 | } |
| 2302 | if (rdev->mode_info.crtcs[1]->base.enabled) { | 2152 | if (!(rdev->flags & RADEON_SINGLE_CRTC)) { |
| 2303 | mode2 = &rdev->mode_info.crtcs[1]->base.mode; | 2153 | if (rdev->mode_info.crtcs[1]->base.enabled) { |
| 2304 | pixel_bytes2 = rdev->mode_info.crtcs[1]->base.fb->bits_per_pixel / 8; | 2154 | mode2 = &rdev->mode_info.crtcs[1]->base.mode; |
| 2155 | pixel_bytes2 = rdev->mode_info.crtcs[1]->base.fb->bits_per_pixel / 8; | ||
| 2156 | } | ||
| 2305 | } | 2157 | } |
| 2306 | 2158 | ||
| 2307 | min_mem_eff.full = rfixed_const_8(0); | 2159 | min_mem_eff.full = rfixed_const_8(0); |
| @@ -3114,7 +2966,7 @@ void r100_mc_stop(struct radeon_device *rdev, struct r100_mc_save *save) | |||
| 3114 | WREG32(R_000740_CP_CSQ_CNTL, 0); | 2966 | WREG32(R_000740_CP_CSQ_CNTL, 0); |
| 3115 | 2967 | ||
| 3116 | /* Save few CRTC registers */ | 2968 | /* Save few CRTC registers */ |
| 3117 | save->GENMO_WT = RREG32(R_0003C0_GENMO_WT); | 2969 | save->GENMO_WT = RREG8(R_0003C2_GENMO_WT); |
| 3118 | save->CRTC_EXT_CNTL = RREG32(R_000054_CRTC_EXT_CNTL); | 2970 | save->CRTC_EXT_CNTL = RREG32(R_000054_CRTC_EXT_CNTL); |
| 3119 | save->CRTC_GEN_CNTL = RREG32(R_000050_CRTC_GEN_CNTL); | 2971 | save->CRTC_GEN_CNTL = RREG32(R_000050_CRTC_GEN_CNTL); |
| 3120 | save->CUR_OFFSET = RREG32(R_000260_CUR_OFFSET); | 2972 | save->CUR_OFFSET = RREG32(R_000260_CUR_OFFSET); |
| @@ -3124,7 +2976,7 @@ void r100_mc_stop(struct radeon_device *rdev, struct r100_mc_save *save) | |||
| 3124 | } | 2976 | } |
| 3125 | 2977 | ||
| 3126 | /* Disable VGA aperture access */ | 2978 | /* Disable VGA aperture access */ |
| 3127 | WREG32(R_0003C0_GENMO_WT, C_0003C0_VGA_RAM_EN & save->GENMO_WT); | 2979 | WREG8(R_0003C2_GENMO_WT, C_0003C2_VGA_RAM_EN & save->GENMO_WT); |
| 3128 | /* Disable cursor, overlay, crtc */ | 2980 | /* Disable cursor, overlay, crtc */ |
| 3129 | WREG32(R_000260_CUR_OFFSET, save->CUR_OFFSET | S_000260_CUR_LOCK(1)); | 2981 | WREG32(R_000260_CUR_OFFSET, save->CUR_OFFSET | S_000260_CUR_LOCK(1)); |
| 3130 | WREG32(R_000054_CRTC_EXT_CNTL, save->CRTC_EXT_CNTL | | 2982 | WREG32(R_000054_CRTC_EXT_CNTL, save->CRTC_EXT_CNTL | |
| @@ -3156,10 +3008,264 @@ void r100_mc_resume(struct radeon_device *rdev, struct r100_mc_save *save) | |||
| 3156 | rdev->mc.vram_location); | 3008 | rdev->mc.vram_location); |
| 3157 | } | 3009 | } |
| 3158 | /* Restore CRTC registers */ | 3010 | /* Restore CRTC registers */ |
| 3159 | WREG32(R_0003C0_GENMO_WT, save->GENMO_WT); | 3011 | WREG8(R_0003C2_GENMO_WT, save->GENMO_WT); |
| 3160 | WREG32(R_000054_CRTC_EXT_CNTL, save->CRTC_EXT_CNTL); | 3012 | WREG32(R_000054_CRTC_EXT_CNTL, save->CRTC_EXT_CNTL); |
| 3161 | WREG32(R_000050_CRTC_GEN_CNTL, save->CRTC_GEN_CNTL); | 3013 | WREG32(R_000050_CRTC_GEN_CNTL, save->CRTC_GEN_CNTL); |
| 3162 | if (!(rdev->flags & RADEON_SINGLE_CRTC)) { | 3014 | if (!(rdev->flags & RADEON_SINGLE_CRTC)) { |
| 3163 | WREG32(R_0003F8_CRTC2_GEN_CNTL, save->CRTC2_GEN_CNTL); | 3015 | WREG32(R_0003F8_CRTC2_GEN_CNTL, save->CRTC2_GEN_CNTL); |
| 3164 | } | 3016 | } |
| 3165 | } | 3017 | } |
| 3018 | |||
| 3019 | void r100_vga_render_disable(struct radeon_device *rdev) | ||
| 3020 | { | ||
| 3021 | u32 tmp; | ||
| 3022 | |||
| 3023 | tmp = RREG8(R_0003C2_GENMO_WT); | ||
| 3024 | WREG8(R_0003C2_GENMO_WT, C_0003C2_VGA_RAM_EN & tmp); | ||
| 3025 | } | ||
| 3026 | |||
| 3027 | static void r100_debugfs(struct radeon_device *rdev) | ||
| 3028 | { | ||
| 3029 | int r; | ||
| 3030 | |||
| 3031 | r = r100_debugfs_mc_info_init(rdev); | ||
| 3032 | if (r) | ||
| 3033 | dev_warn(rdev->dev, "Failed to create r100_mc debugfs file.\n"); | ||
| 3034 | } | ||
| 3035 | |||
| 3036 | static void r100_mc_program(struct radeon_device *rdev) | ||
| 3037 | { | ||
| 3038 | struct r100_mc_save save; | ||
| 3039 | |||
| 3040 | /* Stops all mc clients */ | ||
| 3041 | r100_mc_stop(rdev, &save); | ||
| 3042 | if (rdev->flags & RADEON_IS_AGP) { | ||
| 3043 | WREG32(R_00014C_MC_AGP_LOCATION, | ||
| 3044 | S_00014C_MC_AGP_START(rdev->mc.gtt_start >> 16) | | ||
| 3045 | S_00014C_MC_AGP_TOP(rdev->mc.gtt_end >> 16)); | ||
| 3046 | WREG32(R_000170_AGP_BASE, lower_32_bits(rdev->mc.agp_base)); | ||
| 3047 | if (rdev->family > CHIP_RV200) | ||
| 3048 | WREG32(R_00015C_AGP_BASE_2, | ||
| 3049 | upper_32_bits(rdev->mc.agp_base) & 0xff); | ||
| 3050 | } else { | ||
| 3051 | WREG32(R_00014C_MC_AGP_LOCATION, 0x0FFFFFFF); | ||
| 3052 | WREG32(R_000170_AGP_BASE, 0); | ||
| 3053 | if (rdev->family > CHIP_RV200) | ||
| 3054 | WREG32(R_00015C_AGP_BASE_2, 0); | ||
| 3055 | } | ||
| 3056 | /* Wait for mc idle */ | ||
| 3057 | if (r100_mc_wait_for_idle(rdev)) | ||
| 3058 | dev_warn(rdev->dev, "Wait for MC idle timeout.\n"); | ||
| 3059 | /* Program MC, should be a 32bits limited address space */ | ||
| 3060 | WREG32(R_000148_MC_FB_LOCATION, | ||
| 3061 | S_000148_MC_FB_START(rdev->mc.vram_start >> 16) | | ||
| 3062 | S_000148_MC_FB_TOP(rdev->mc.vram_end >> 16)); | ||
| 3063 | r100_mc_resume(rdev, &save); | ||
| 3064 | } | ||
| 3065 | |||
| 3066 | void r100_clock_startup(struct radeon_device *rdev) | ||
| 3067 | { | ||
| 3068 | u32 tmp; | ||
| 3069 | |||
| 3070 | if (radeon_dynclks != -1 && radeon_dynclks) | ||
| 3071 | radeon_legacy_set_clock_gating(rdev, 1); | ||
| 3072 | /* We need to force on some of the block */ | ||
| 3073 | tmp = RREG32_PLL(R_00000D_SCLK_CNTL); | ||
| 3074 | tmp |= S_00000D_FORCE_CP(1) | S_00000D_FORCE_VIP(1); | ||
| 3075 | if ((rdev->family == CHIP_RV250) || (rdev->family == CHIP_RV280)) | ||
| 3076 | tmp |= S_00000D_FORCE_DISP1(1) | S_00000D_FORCE_DISP2(1); | ||
| 3077 | WREG32_PLL(R_00000D_SCLK_CNTL, tmp); | ||
| 3078 | } | ||
| 3079 | |||
| 3080 | static int r100_startup(struct radeon_device *rdev) | ||
| 3081 | { | ||
| 3082 | int r; | ||
| 3083 | |||
| 3084 | r100_mc_program(rdev); | ||
| 3085 | /* Resume clock */ | ||
| 3086 | r100_clock_startup(rdev); | ||
| 3087 | /* Initialize GPU configuration (# pipes, ...) */ | ||
| 3088 | r100_gpu_init(rdev); | ||
| 3089 | /* Initialize GART (initialize after TTM so we can allocate | ||
| 3090 | * memory through TTM but finalize after TTM) */ | ||
| 3091 | if (rdev->flags & RADEON_IS_PCI) { | ||
| 3092 | r = r100_pci_gart_enable(rdev); | ||
| 3093 | if (r) | ||
| 3094 | return r; | ||
| 3095 | } | ||
| 3096 | /* Enable IRQ */ | ||
| 3097 | rdev->irq.sw_int = true; | ||
| 3098 | r100_irq_set(rdev); | ||
| 3099 | /* 1M ring buffer */ | ||
| 3100 | r = r100_cp_init(rdev, 1024 * 1024); | ||
| 3101 | if (r) { | ||
| 3102 | dev_err(rdev->dev, "failled initializing CP (%d).\n", r); | ||
| 3103 | return r; | ||
| 3104 | } | ||
| 3105 | r = r100_wb_init(rdev); | ||
| 3106 | if (r) | ||
| 3107 | dev_err(rdev->dev, "failled initializing WB (%d).\n", r); | ||
| 3108 | r = r100_ib_init(rdev); | ||
| 3109 | if (r) { | ||
| 3110 | dev_err(rdev->dev, "failled initializing IB (%d).\n", r); | ||
| 3111 | return r; | ||
| 3112 | } | ||
| 3113 | return 0; | ||
| 3114 | } | ||
| 3115 | |||
| 3116 | int r100_resume(struct radeon_device *rdev) | ||
| 3117 | { | ||
| 3118 | /* Make sur GART are not working */ | ||
| 3119 | if (rdev->flags & RADEON_IS_PCI) | ||
| 3120 | r100_pci_gart_disable(rdev); | ||
| 3121 | /* Resume clock before doing reset */ | ||
| 3122 | r100_clock_startup(rdev); | ||
| 3123 | /* Reset gpu before posting otherwise ATOM will enter infinite loop */ | ||
| 3124 | if (radeon_gpu_reset(rdev)) { | ||
| 3125 | dev_warn(rdev->dev, "GPU reset failed ! (0xE40=0x%08X, 0x7C0=0x%08X)\n", | ||
| 3126 | RREG32(R_000E40_RBBM_STATUS), | ||
| 3127 | RREG32(R_0007C0_CP_STAT)); | ||
| 3128 | } | ||
| 3129 | /* post */ | ||
| 3130 | radeon_combios_asic_init(rdev->ddev); | ||
| 3131 | /* Resume clock after posting */ | ||
| 3132 | r100_clock_startup(rdev); | ||
| 3133 | return r100_startup(rdev); | ||
| 3134 | } | ||
| 3135 | |||
| 3136 | int r100_suspend(struct radeon_device *rdev) | ||
| 3137 | { | ||
| 3138 | r100_cp_disable(rdev); | ||
| 3139 | r100_wb_disable(rdev); | ||
| 3140 | r100_irq_disable(rdev); | ||
| 3141 | if (rdev->flags & RADEON_IS_PCI) | ||
| 3142 | r100_pci_gart_disable(rdev); | ||
| 3143 | return 0; | ||
| 3144 | } | ||
| 3145 | |||
| 3146 | void r100_fini(struct radeon_device *rdev) | ||
| 3147 | { | ||
| 3148 | r100_suspend(rdev); | ||
| 3149 | r100_cp_fini(rdev); | ||
| 3150 | r100_wb_fini(rdev); | ||
| 3151 | r100_ib_fini(rdev); | ||
| 3152 | radeon_gem_fini(rdev); | ||
| 3153 | if (rdev->flags & RADEON_IS_PCI) | ||
| 3154 | r100_pci_gart_fini(rdev); | ||
| 3155 | radeon_irq_kms_fini(rdev); | ||
| 3156 | radeon_fence_driver_fini(rdev); | ||
| 3157 | radeon_object_fini(rdev); | ||
| 3158 | radeon_atombios_fini(rdev); | ||
| 3159 | kfree(rdev->bios); | ||
| 3160 | rdev->bios = NULL; | ||
| 3161 | } | ||
| 3162 | |||
| 3163 | int r100_mc_init(struct radeon_device *rdev) | ||
| 3164 | { | ||
| 3165 | int r; | ||
| 3166 | u32 tmp; | ||
| 3167 | |||
| 3168 | /* Setup GPU memory space */ | ||
| 3169 | rdev->mc.vram_location = 0xFFFFFFFFUL; | ||
| 3170 | rdev->mc.gtt_location = 0xFFFFFFFFUL; | ||
| 3171 | if (rdev->flags & RADEON_IS_IGP) { | ||
| 3172 | tmp = G_00015C_MC_FB_START(RREG32(R_00015C_NB_TOM)); | ||
| 3173 | rdev->mc.vram_location = tmp << 16; | ||
| 3174 | } | ||
| 3175 | if (rdev->flags & RADEON_IS_AGP) { | ||
| 3176 | r = radeon_agp_init(rdev); | ||
| 3177 | if (r) { | ||
| 3178 | printk(KERN_WARNING "[drm] Disabling AGP\n"); | ||
| 3179 | rdev->flags &= ~RADEON_IS_AGP; | ||
| 3180 | rdev->mc.gtt_size = radeon_gart_size * 1024 * 1024; | ||
| 3181 | } else { | ||
| 3182 | rdev->mc.gtt_location = rdev->mc.agp_base; | ||
| 3183 | } | ||
| 3184 | } | ||
| 3185 | r = radeon_mc_setup(rdev); | ||
| 3186 | if (r) | ||
| 3187 | return r; | ||
| 3188 | return 0; | ||
| 3189 | } | ||
| 3190 | |||
| 3191 | int r100_init(struct radeon_device *rdev) | ||
| 3192 | { | ||
| 3193 | int r; | ||
| 3194 | |||
| 3195 | /* Register debugfs file specific to this group of asics */ | ||
| 3196 | r100_debugfs(rdev); | ||
| 3197 | /* Disable VGA */ | ||
| 3198 | r100_vga_render_disable(rdev); | ||
| 3199 | /* Initialize scratch registers */ | ||
| 3200 | radeon_scratch_init(rdev); | ||
| 3201 | /* Initialize surface registers */ | ||
| 3202 | radeon_surface_init(rdev); | ||
| 3203 | /* TODO: disable VGA need to use VGA request */ | ||
| 3204 | /* BIOS*/ | ||
| 3205 | if (!radeon_get_bios(rdev)) { | ||
| 3206 | if (ASIC_IS_AVIVO(rdev)) | ||
| 3207 | return -EINVAL; | ||
| 3208 | } | ||
| 3209 | if (rdev->is_atom_bios) { | ||
| 3210 | dev_err(rdev->dev, "Expecting combios for RS400/RS480 GPU\n"); | ||
| 3211 | return -EINVAL; | ||
| 3212 | } else { | ||
| 3213 | r = radeon_combios_init(rdev); | ||
| 3214 | if (r) | ||
| 3215 | return r; | ||
| 3216 | } | ||
| 3217 | /* Reset gpu before posting otherwise ATOM will enter infinite loop */ | ||
| 3218 | if (radeon_gpu_reset(rdev)) { | ||
| 3219 | dev_warn(rdev->dev, | ||
| 3220 | "GPU reset failed ! (0xE40=0x%08X, 0x7C0=0x%08X)\n", | ||
| 3221 | RREG32(R_000E40_RBBM_STATUS), | ||
| 3222 | RREG32(R_0007C0_CP_STAT)); | ||
| 3223 | } | ||
| 3224 | /* check if cards are posted or not */ | ||
| 3225 | if (!radeon_card_posted(rdev) && rdev->bios) { | ||
| 3226 | DRM_INFO("GPU not posted. posting now...\n"); | ||
| 3227 | radeon_combios_asic_init(rdev->ddev); | ||
| 3228 | } | ||
| 3229 | /* Set asic errata */ | ||
| 3230 | r100_errata(rdev); | ||
| 3231 | /* Initialize clocks */ | ||
| 3232 | radeon_get_clock_info(rdev->ddev); | ||
| 3233 | /* Get vram informations */ | ||
| 3234 | r100_vram_info(rdev); | ||
| 3235 | /* Initialize memory controller (also test AGP) */ | ||
| 3236 | r = r100_mc_init(rdev); | ||
| 3237 | if (r) | ||
| 3238 | return r; | ||
| 3239 | /* Fence driver */ | ||
| 3240 | r = radeon_fence_driver_init(rdev); | ||
| 3241 | if (r) | ||
| 3242 | return r; | ||
| 3243 | r = radeon_irq_kms_init(rdev); | ||
| 3244 | if (r) | ||
| 3245 | return r; | ||
| 3246 | /* Memory manager */ | ||
| 3247 | r = radeon_object_init(rdev); | ||
| 3248 | if (r) | ||
| 3249 | return r; | ||
| 3250 | if (rdev->flags & RADEON_IS_PCI) { | ||
| 3251 | r = r100_pci_gart_init(rdev); | ||
| 3252 | if (r) | ||
| 3253 | return r; | ||
| 3254 | } | ||
| 3255 | r100_set_safe_registers(rdev); | ||
| 3256 | rdev->accel_working = true; | ||
| 3257 | r = r100_startup(rdev); | ||
| 3258 | if (r) { | ||
| 3259 | /* Somethings want wront with the accel init stop accel */ | ||
| 3260 | dev_err(rdev->dev, "Disabling GPU acceleration\n"); | ||
| 3261 | r100_suspend(rdev); | ||
| 3262 | r100_cp_fini(rdev); | ||
| 3263 | r100_wb_fini(rdev); | ||
| 3264 | r100_ib_fini(rdev); | ||
| 3265 | if (rdev->flags & RADEON_IS_PCI) | ||
| 3266 | r100_pci_gart_fini(rdev); | ||
| 3267 | radeon_irq_kms_fini(rdev); | ||
| 3268 | rdev->accel_working = false; | ||
| 3269 | } | ||
| 3270 | return 0; | ||
| 3271 | } | ||
diff --git a/drivers/gpu/drm/radeon/r100d.h b/drivers/gpu/drm/radeon/r100d.h index c4b257ec920e..df29a630c466 100644 --- a/drivers/gpu/drm/radeon/r100d.h +++ b/drivers/gpu/drm/radeon/r100d.h | |||
| @@ -381,6 +381,24 @@ | |||
| 381 | #define S_000054_VCRTC_IDX_MASTER(x) (((x) & 0x7F) << 24) | 381 | #define S_000054_VCRTC_IDX_MASTER(x) (((x) & 0x7F) << 24) |
| 382 | #define G_000054_VCRTC_IDX_MASTER(x) (((x) >> 24) & 0x7F) | 382 | #define G_000054_VCRTC_IDX_MASTER(x) (((x) >> 24) & 0x7F) |
| 383 | #define C_000054_VCRTC_IDX_MASTER 0x80FFFFFF | 383 | #define C_000054_VCRTC_IDX_MASTER 0x80FFFFFF |
| 384 | #define R_000148_MC_FB_LOCATION 0x000148 | ||
| 385 | #define S_000148_MC_FB_START(x) (((x) & 0xFFFF) << 0) | ||
| 386 | #define G_000148_MC_FB_START(x) (((x) >> 0) & 0xFFFF) | ||
| 387 | #define C_000148_MC_FB_START 0xFFFF0000 | ||
| 388 | #define S_000148_MC_FB_TOP(x) (((x) & 0xFFFF) << 16) | ||
| 389 | #define G_000148_MC_FB_TOP(x) (((x) >> 16) & 0xFFFF) | ||
| 390 | #define C_000148_MC_FB_TOP 0x0000FFFF | ||
| 391 | #define R_00014C_MC_AGP_LOCATION 0x00014C | ||
| 392 | #define S_00014C_MC_AGP_START(x) (((x) & 0xFFFF) << 0) | ||
| 393 | #define G_00014C_MC_AGP_START(x) (((x) >> 0) & 0xFFFF) | ||
| 394 | #define C_00014C_MC_AGP_START 0xFFFF0000 | ||
| 395 | #define S_00014C_MC_AGP_TOP(x) (((x) & 0xFFFF) << 16) | ||
| 396 | #define G_00014C_MC_AGP_TOP(x) (((x) >> 16) & 0xFFFF) | ||
| 397 | #define C_00014C_MC_AGP_TOP 0x0000FFFF | ||
| 398 | #define R_000170_AGP_BASE 0x000170 | ||
| 399 | #define S_000170_AGP_BASE_ADDR(x) (((x) & 0xFFFFFFFF) << 0) | ||
| 400 | #define G_000170_AGP_BASE_ADDR(x) (((x) >> 0) & 0xFFFFFFFF) | ||
| 401 | #define C_000170_AGP_BASE_ADDR 0x00000000 | ||
| 384 | #define R_00023C_DISPLAY_BASE_ADDR 0x00023C | 402 | #define R_00023C_DISPLAY_BASE_ADDR 0x00023C |
| 385 | #define S_00023C_DISPLAY_BASE_ADDR(x) (((x) & 0xFFFFFFFF) << 0) | 403 | #define S_00023C_DISPLAY_BASE_ADDR(x) (((x) & 0xFFFFFFFF) << 0) |
| 386 | #define G_00023C_DISPLAY_BASE_ADDR(x) (((x) >> 0) & 0xFFFFFFFF) | 404 | #define G_00023C_DISPLAY_BASE_ADDR(x) (((x) >> 0) & 0xFFFFFFFF) |
| @@ -403,25 +421,25 @@ | |||
| 403 | #define S_000360_CUR2_LOCK(x) (((x) & 0x1) << 31) | 421 | #define S_000360_CUR2_LOCK(x) (((x) & 0x1) << 31) |
| 404 | #define G_000360_CUR2_LOCK(x) (((x) >> 31) & 0x1) | 422 | #define G_000360_CUR2_LOCK(x) (((x) >> 31) & 0x1) |
| 405 | #define C_000360_CUR2_LOCK 0x7FFFFFFF | 423 | #define C_000360_CUR2_LOCK 0x7FFFFFFF |
| 406 | #define R_0003C0_GENMO_WT 0x0003C0 | 424 | #define R_0003C2_GENMO_WT 0x0003C0 |
| 407 | #define S_0003C0_GENMO_MONO_ADDRESS_B(x) (((x) & 0x1) << 0) | 425 | #define S_0003C2_GENMO_MONO_ADDRESS_B(x) (((x) & 0x1) << 0) |
| 408 | #define G_0003C0_GENMO_MONO_ADDRESS_B(x) (((x) >> 0) & 0x1) | 426 | #define G_0003C2_GENMO_MONO_ADDRESS_B(x) (((x) >> 0) & 0x1) |
| 409 | #define C_0003C0_GENMO_MONO_ADDRESS_B 0xFFFFFFFE | 427 | #define C_0003C2_GENMO_MONO_ADDRESS_B 0xFE |
| 410 | #define S_0003C0_VGA_RAM_EN(x) (((x) & 0x1) << 1) | 428 | #define S_0003C2_VGA_RAM_EN(x) (((x) & 0x1) << 1) |
| 411 | #define G_0003C0_VGA_RAM_EN(x) (((x) >> 1) & 0x1) | 429 | #define G_0003C2_VGA_RAM_EN(x) (((x) >> 1) & 0x1) |
| 412 | #define C_0003C0_VGA_RAM_EN 0xFFFFFFFD | 430 | #define C_0003C2_VGA_RAM_EN 0xFD |
| 413 | #define S_0003C0_VGA_CKSEL(x) (((x) & 0x3) << 2) | 431 | #define S_0003C2_VGA_CKSEL(x) (((x) & 0x3) << 2) |
| 414 | #define G_0003C0_VGA_CKSEL(x) (((x) >> 2) & 0x3) | 432 | #define G_0003C2_VGA_CKSEL(x) (((x) >> 2) & 0x3) |
| 415 | #define C_0003C0_VGA_CKSEL 0xFFFFFFF3 | 433 | #define C_0003C2_VGA_CKSEL 0xF3 |
| 416 | #define S_0003C0_ODD_EVEN_MD_PGSEL(x) (((x) & 0x1) << 5) | 434 | #define S_0003C2_ODD_EVEN_MD_PGSEL(x) (((x) & 0x1) << 5) |
| 417 | #define G_0003C0_ODD_EVEN_MD_PGSEL(x) (((x) >> 5) & 0x1) | 435 | #define G_0003C2_ODD_EVEN_MD_PGSEL(x) (((x) >> 5) & 0x1) |
| 418 | #define C_0003C0_ODD_EVEN_MD_PGSEL 0xFFFFFFDF | 436 | #define C_0003C2_ODD_EVEN_MD_PGSEL 0xDF |
| 419 | #define S_0003C0_VGA_HSYNC_POL(x) (((x) & 0x1) << 6) | 437 | #define S_0003C2_VGA_HSYNC_POL(x) (((x) & 0x1) << 6) |
| 420 | #define G_0003C0_VGA_HSYNC_POL(x) (((x) >> 6) & 0x1) | 438 | #define G_0003C2_VGA_HSYNC_POL(x) (((x) >> 6) & 0x1) |
| 421 | #define C_0003C0_VGA_HSYNC_POL 0xFFFFFFBF | 439 | #define C_0003C2_VGA_HSYNC_POL 0xBF |
| 422 | #define S_0003C0_VGA_VSYNC_POL(x) (((x) & 0x1) << 7) | 440 | #define S_0003C2_VGA_VSYNC_POL(x) (((x) & 0x1) << 7) |
| 423 | #define G_0003C0_VGA_VSYNC_POL(x) (((x) >> 7) & 0x1) | 441 | #define G_0003C2_VGA_VSYNC_POL(x) (((x) >> 7) & 0x1) |
| 424 | #define C_0003C0_VGA_VSYNC_POL 0xFFFFFF7F | 442 | #define C_0003C2_VGA_VSYNC_POL 0x7F |
| 425 | #define R_0003F8_CRTC2_GEN_CNTL 0x0003F8 | 443 | #define R_0003F8_CRTC2_GEN_CNTL 0x0003F8 |
| 426 | #define S_0003F8_CRTC2_DBL_SCAN_EN(x) (((x) & 0x1) << 0) | 444 | #define S_0003F8_CRTC2_DBL_SCAN_EN(x) (((x) & 0x1) << 0) |
| 427 | #define G_0003F8_CRTC2_DBL_SCAN_EN(x) (((x) >> 0) & 0x1) | 445 | #define G_0003F8_CRTC2_DBL_SCAN_EN(x) (((x) >> 0) & 0x1) |
| @@ -545,6 +563,46 @@ | |||
| 545 | #define S_000774_SCRATCH_ADDR(x) (((x) & 0x7FFFFFF) << 5) | 563 | #define S_000774_SCRATCH_ADDR(x) (((x) & 0x7FFFFFF) << 5) |
| 546 | #define G_000774_SCRATCH_ADDR(x) (((x) >> 5) & 0x7FFFFFF) | 564 | #define G_000774_SCRATCH_ADDR(x) (((x) >> 5) & 0x7FFFFFF) |
| 547 | #define C_000774_SCRATCH_ADDR 0x0000001F | 565 | #define C_000774_SCRATCH_ADDR 0x0000001F |
| 566 | #define R_0007C0_CP_STAT 0x0007C0 | ||
| 567 | #define S_0007C0_MRU_BUSY(x) (((x) & 0x1) << 0) | ||
| 568 | #define G_0007C0_MRU_BUSY(x) (((x) >> 0) & 0x1) | ||
| 569 | #define C_0007C0_MRU_BUSY 0xFFFFFFFE | ||
| 570 | #define S_0007C0_MWU_BUSY(x) (((x) & 0x1) << 1) | ||
| 571 | #define G_0007C0_MWU_BUSY(x) (((x) >> 1) & 0x1) | ||
| 572 | #define C_0007C0_MWU_BUSY 0xFFFFFFFD | ||
| 573 | #define S_0007C0_RSIU_BUSY(x) (((x) & 0x1) << 2) | ||
| 574 | #define G_0007C0_RSIU_BUSY(x) (((x) >> 2) & 0x1) | ||
| 575 | #define C_0007C0_RSIU_BUSY 0xFFFFFFFB | ||
| 576 | #define S_0007C0_RCIU_BUSY(x) (((x) & 0x1) << 3) | ||
| 577 | #define G_0007C0_RCIU_BUSY(x) (((x) >> 3) & 0x1) | ||
| 578 | #define C_0007C0_RCIU_BUSY 0xFFFFFFF7 | ||
| 579 | #define S_0007C0_CSF_PRIMARY_BUSY(x) (((x) & 0x1) << 9) | ||
| 580 | #define G_0007C0_CSF_PRIMARY_BUSY(x) (((x) >> 9) & 0x1) | ||
| 581 | #define C_0007C0_CSF_PRIMARY_BUSY 0xFFFFFDFF | ||
| 582 | #define S_0007C0_CSF_INDIRECT_BUSY(x) (((x) & 0x1) << 10) | ||
| 583 | #define G_0007C0_CSF_INDIRECT_BUSY(x) (((x) >> 10) & 0x1) | ||
| 584 | #define C_0007C0_CSF_INDIRECT_BUSY 0xFFFFFBFF | ||
| 585 | #define S_0007C0_CSQ_PRIMARY_BUSY(x) (((x) & 0x1) << 11) | ||
| 586 | #define G_0007C0_CSQ_PRIMARY_BUSY(x) (((x) >> 11) & 0x1) | ||
| 587 | #define C_0007C0_CSQ_PRIMARY_BUSY 0xFFFFF7FF | ||
| 588 | #define S_0007C0_CSQ_INDIRECT_BUSY(x) (((x) & 0x1) << 12) | ||
| 589 | #define G_0007C0_CSQ_INDIRECT_BUSY(x) (((x) >> 12) & 0x1) | ||
| 590 | #define C_0007C0_CSQ_INDIRECT_BUSY 0xFFFFEFFF | ||
| 591 | #define S_0007C0_CSI_BUSY(x) (((x) & 0x1) << 13) | ||
| 592 | #define G_0007C0_CSI_BUSY(x) (((x) >> 13) & 0x1) | ||
| 593 | #define C_0007C0_CSI_BUSY 0xFFFFDFFF | ||
| 594 | #define S_0007C0_GUIDMA_BUSY(x) (((x) & 0x1) << 28) | ||
| 595 | #define G_0007C0_GUIDMA_BUSY(x) (((x) >> 28) & 0x1) | ||
| 596 | #define C_0007C0_GUIDMA_BUSY 0xEFFFFFFF | ||
| 597 | #define S_0007C0_VIDDMA_BUSY(x) (((x) & 0x1) << 29) | ||
| 598 | #define G_0007C0_VIDDMA_BUSY(x) (((x) >> 29) & 0x1) | ||
| 599 | #define C_0007C0_VIDDMA_BUSY 0xDFFFFFFF | ||
| 600 | #define S_0007C0_CMDSTRM_BUSY(x) (((x) & 0x1) << 30) | ||
| 601 | #define G_0007C0_CMDSTRM_BUSY(x) (((x) >> 30) & 0x1) | ||
| 602 | #define C_0007C0_CMDSTRM_BUSY 0xBFFFFFFF | ||
| 603 | #define S_0007C0_CP_BUSY(x) (((x) & 0x1) << 31) | ||
| 604 | #define G_0007C0_CP_BUSY(x) (((x) >> 31) & 0x1) | ||
| 605 | #define C_0007C0_CP_BUSY 0x7FFFFFFF | ||
| 548 | #define R_000E40_RBBM_STATUS 0x000E40 | 606 | #define R_000E40_RBBM_STATUS 0x000E40 |
| 549 | #define S_000E40_CMDFIFO_AVAIL(x) (((x) & 0x7F) << 0) | 607 | #define S_000E40_CMDFIFO_AVAIL(x) (((x) & 0x7F) << 0) |
| 550 | #define G_000E40_CMDFIFO_AVAIL(x) (((x) >> 0) & 0x7F) | 608 | #define G_000E40_CMDFIFO_AVAIL(x) (((x) >> 0) & 0x7F) |
| @@ -604,4 +662,53 @@ | |||
| 604 | #define G_000E40_GUI_ACTIVE(x) (((x) >> 31) & 0x1) | 662 | #define G_000E40_GUI_ACTIVE(x) (((x) >> 31) & 0x1) |
| 605 | #define C_000E40_GUI_ACTIVE 0x7FFFFFFF | 663 | #define C_000E40_GUI_ACTIVE 0x7FFFFFFF |
| 606 | 664 | ||
| 665 | |||
| 666 | #define R_00000D_SCLK_CNTL 0x00000D | ||
| 667 | #define S_00000D_SCLK_SRC_SEL(x) (((x) & 0x7) << 0) | ||
| 668 | #define G_00000D_SCLK_SRC_SEL(x) (((x) >> 0) & 0x7) | ||
| 669 | #define C_00000D_SCLK_SRC_SEL 0xFFFFFFF8 | ||
| 670 | #define S_00000D_TCLK_SRC_SEL(x) (((x) & 0x7) << 8) | ||
| 671 | #define G_00000D_TCLK_SRC_SEL(x) (((x) >> 8) & 0x7) | ||
| 672 | #define C_00000D_TCLK_SRC_SEL 0xFFFFF8FF | ||
| 673 | #define S_00000D_FORCE_CP(x) (((x) & 0x1) << 16) | ||
| 674 | #define G_00000D_FORCE_CP(x) (((x) >> 16) & 0x1) | ||
| 675 | #define C_00000D_FORCE_CP 0xFFFEFFFF | ||
| 676 | #define S_00000D_FORCE_HDP(x) (((x) & 0x1) << 17) | ||
| 677 | #define G_00000D_FORCE_HDP(x) (((x) >> 17) & 0x1) | ||
| 678 | #define C_00000D_FORCE_HDP 0xFFFDFFFF | ||
| 679 | #define S_00000D_FORCE_DISP(x) (((x) & 0x1) << 18) | ||
| 680 | #define G_00000D_FORCE_DISP(x) (((x) >> 18) & 0x1) | ||
| 681 | #define C_00000D_FORCE_DISP 0xFFFBFFFF | ||
| 682 | #define S_00000D_FORCE_TOP(x) (((x) & 0x1) << 19) | ||
| 683 | #define G_00000D_FORCE_TOP(x) (((x) >> 19) & 0x1) | ||
| 684 | #define C_00000D_FORCE_TOP 0xFFF7FFFF | ||
| 685 | #define S_00000D_FORCE_E2(x) (((x) & 0x1) << 20) | ||
| 686 | #define G_00000D_FORCE_E2(x) (((x) >> 20) & 0x1) | ||
| 687 | #define C_00000D_FORCE_E2 0xFFEFFFFF | ||
| 688 | #define S_00000D_FORCE_SE(x) (((x) & 0x1) << 21) | ||
| 689 | #define G_00000D_FORCE_SE(x) (((x) >> 21) & 0x1) | ||
| 690 | #define C_00000D_FORCE_SE 0xFFDFFFFF | ||
| 691 | #define S_00000D_FORCE_IDCT(x) (((x) & 0x1) << 22) | ||
| 692 | #define G_00000D_FORCE_IDCT(x) (((x) >> 22) & 0x1) | ||
| 693 | #define C_00000D_FORCE_IDCT 0xFFBFFFFF | ||
| 694 | #define S_00000D_FORCE_VIP(x) (((x) & 0x1) << 23) | ||
| 695 | #define G_00000D_FORCE_VIP(x) (((x) >> 23) & 0x1) | ||
| 696 | #define C_00000D_FORCE_VIP 0xFF7FFFFF | ||
| 697 | #define S_00000D_FORCE_RE(x) (((x) & 0x1) << 24) | ||
| 698 | #define G_00000D_FORCE_RE(x) (((x) >> 24) & 0x1) | ||
| 699 | #define C_00000D_FORCE_RE 0xFEFFFFFF | ||
| 700 | #define S_00000D_FORCE_PB(x) (((x) & 0x1) << 25) | ||
| 701 | #define G_00000D_FORCE_PB(x) (((x) >> 25) & 0x1) | ||
| 702 | #define C_00000D_FORCE_PB 0xFDFFFFFF | ||
| 703 | #define S_00000D_FORCE_TAM(x) (((x) & 0x1) << 26) | ||
| 704 | #define G_00000D_FORCE_TAM(x) (((x) >> 26) & 0x1) | ||
| 705 | #define C_00000D_FORCE_TAM 0xFBFFFFFF | ||
| 706 | #define S_00000D_FORCE_TDM(x) (((x) & 0x1) << 27) | ||
| 707 | #define G_00000D_FORCE_TDM(x) (((x) >> 27) & 0x1) | ||
| 708 | #define C_00000D_FORCE_TDM 0xF7FFFFFF | ||
| 709 | #define S_00000D_FORCE_RB(x) (((x) & 0x1) << 28) | ||
| 710 | #define G_00000D_FORCE_RB(x) (((x) >> 28) & 0x1) | ||
| 711 | #define C_00000D_FORCE_RB 0xEFFFFFFF | ||
| 712 | |||
| 713 | |||
| 607 | #endif | 714 | #endif |
diff --git a/drivers/gpu/drm/radeon/r200.c b/drivers/gpu/drm/radeon/r200.c index cf7fea5ff2e5..eb740fc3549f 100644 --- a/drivers/gpu/drm/radeon/r200.c +++ b/drivers/gpu/drm/radeon/r200.c | |||
| @@ -447,9 +447,8 @@ int r200_packet0_check(struct radeon_cs_parser *p, | |||
| 447 | return 0; | 447 | return 0; |
| 448 | } | 448 | } |
| 449 | 449 | ||
| 450 | int r200_init(struct radeon_device *rdev) | 450 | void r200_set_safe_registers(struct radeon_device *rdev) |
| 451 | { | 451 | { |
| 452 | rdev->config.r100.reg_safe_bm = r200_reg_safe_bm; | 452 | rdev->config.r100.reg_safe_bm = r200_reg_safe_bm; |
| 453 | rdev->config.r100.reg_safe_bm_size = ARRAY_SIZE(r200_reg_safe_bm); | 453 | rdev->config.r100.reg_safe_bm_size = ARRAY_SIZE(r200_reg_safe_bm); |
| 454 | return 0; | ||
| 455 | } | 454 | } |
diff --git a/drivers/gpu/drm/radeon/r300.c b/drivers/gpu/drm/radeon/r300.c index 1ebea8cc8c93..e08c4a8974ca 100644 --- a/drivers/gpu/drm/radeon/r300.c +++ b/drivers/gpu/drm/radeon/r300.c | |||
| @@ -33,43 +33,16 @@ | |||
| 33 | #include "radeon_drm.h" | 33 | #include "radeon_drm.h" |
| 34 | #include "r100_track.h" | 34 | #include "r100_track.h" |
| 35 | #include "r300d.h" | 35 | #include "r300d.h" |
| 36 | 36 | #include "rv350d.h" | |
| 37 | #include "r300_reg_safe.h" | 37 | #include "r300_reg_safe.h" |
| 38 | 38 | ||
| 39 | /* r300,r350,rv350,rv370,rv380 depends on : */ | 39 | /* This files gather functions specifics to: r300,r350,rv350,rv370,rv380 */ |
| 40 | void r100_hdp_reset(struct radeon_device *rdev); | ||
| 41 | int r100_cp_reset(struct radeon_device *rdev); | ||
| 42 | int r100_rb2d_reset(struct radeon_device *rdev); | ||
| 43 | int r100_cp_init(struct radeon_device *rdev, unsigned ring_size); | ||
| 44 | int r100_pci_gart_enable(struct radeon_device *rdev); | ||
| 45 | void r100_mc_setup(struct radeon_device *rdev); | ||
| 46 | void r100_mc_disable_clients(struct radeon_device *rdev); | ||
| 47 | int r100_gui_wait_for_idle(struct radeon_device *rdev); | ||
| 48 | int r100_cs_packet_parse(struct radeon_cs_parser *p, | ||
| 49 | struct radeon_cs_packet *pkt, | ||
| 50 | unsigned idx); | ||
| 51 | int r100_cs_packet_parse_vline(struct radeon_cs_parser *p); | ||
| 52 | int r100_cs_parse_packet0(struct radeon_cs_parser *p, | ||
| 53 | struct radeon_cs_packet *pkt, | ||
| 54 | const unsigned *auth, unsigned n, | ||
| 55 | radeon_packet0_check_t check); | ||
| 56 | int r100_cs_track_check_pkt3_indx_buffer(struct radeon_cs_parser *p, | ||
| 57 | struct radeon_cs_packet *pkt, | ||
| 58 | struct radeon_object *robj); | ||
| 59 | |||
| 60 | /* This files gather functions specifics to: | ||
| 61 | * r300,r350,rv350,rv370,rv380 | ||
| 62 | * | ||
| 63 | * Some of these functions might be used by newer ASICs. | ||
| 64 | */ | ||
| 65 | void r300_gpu_init(struct radeon_device *rdev); | ||
| 66 | int r300_mc_wait_for_idle(struct radeon_device *rdev); | ||
| 67 | int rv370_debugfs_pcie_gart_info_init(struct radeon_device *rdev); | ||
| 68 | |||
| 69 | 40 | ||
| 70 | /* | 41 | /* |
| 71 | * rv370,rv380 PCIE GART | 42 | * rv370,rv380 PCIE GART |
| 72 | */ | 43 | */ |
| 44 | static int rv370_debugfs_pcie_gart_info_init(struct radeon_device *rdev); | ||
| 45 | |||
| 73 | void rv370_pcie_gart_tlb_flush(struct radeon_device *rdev) | 46 | void rv370_pcie_gart_tlb_flush(struct radeon_device *rdev) |
| 74 | { | 47 | { |
| 75 | uint32_t tmp; | 48 | uint32_t tmp; |
| @@ -182,59 +155,6 @@ void rv370_pcie_gart_fini(struct radeon_device *rdev) | |||
| 182 | radeon_gart_fini(rdev); | 155 | radeon_gart_fini(rdev); |
| 183 | } | 156 | } |
| 184 | 157 | ||
| 185 | /* | ||
| 186 | * MC | ||
| 187 | */ | ||
| 188 | int r300_mc_init(struct radeon_device *rdev) | ||
| 189 | { | ||
| 190 | int r; | ||
| 191 | |||
| 192 | if (r100_debugfs_rbbm_init(rdev)) { | ||
| 193 | DRM_ERROR("Failed to register debugfs file for RBBM !\n"); | ||
| 194 | } | ||
| 195 | |||
| 196 | r300_gpu_init(rdev); | ||
| 197 | r100_pci_gart_disable(rdev); | ||
| 198 | if (rdev->flags & RADEON_IS_PCIE) { | ||
| 199 | rv370_pcie_gart_disable(rdev); | ||
| 200 | } | ||
| 201 | |||
| 202 | /* Setup GPU memory space */ | ||
| 203 | rdev->mc.vram_location = 0xFFFFFFFFUL; | ||
| 204 | rdev->mc.gtt_location = 0xFFFFFFFFUL; | ||
| 205 | if (rdev->flags & RADEON_IS_AGP) { | ||
| 206 | r = radeon_agp_init(rdev); | ||
| 207 | if (r) { | ||
| 208 | printk(KERN_WARNING "[drm] Disabling AGP\n"); | ||
| 209 | rdev->flags &= ~RADEON_IS_AGP; | ||
| 210 | rdev->mc.gtt_size = radeon_gart_size * 1024 * 1024; | ||
| 211 | } else { | ||
| 212 | rdev->mc.gtt_location = rdev->mc.agp_base; | ||
| 213 | } | ||
| 214 | } | ||
| 215 | r = radeon_mc_setup(rdev); | ||
| 216 | if (r) { | ||
| 217 | return r; | ||
| 218 | } | ||
| 219 | |||
| 220 | /* Program GPU memory space */ | ||
| 221 | r100_mc_disable_clients(rdev); | ||
| 222 | if (r300_mc_wait_for_idle(rdev)) { | ||
| 223 | printk(KERN_WARNING "Failed to wait MC idle while " | ||
| 224 | "programming pipes. Bad things might happen.\n"); | ||
| 225 | } | ||
| 226 | r100_mc_setup(rdev); | ||
| 227 | return 0; | ||
| 228 | } | ||
| 229 | |||
| 230 | void r300_mc_fini(struct radeon_device *rdev) | ||
| 231 | { | ||
| 232 | } | ||
| 233 | |||
| 234 | |||
| 235 | /* | ||
| 236 | * Fence emission | ||
| 237 | */ | ||
| 238 | void r300_fence_ring_emit(struct radeon_device *rdev, | 158 | void r300_fence_ring_emit(struct radeon_device *rdev, |
| 239 | struct radeon_fence *fence) | 159 | struct radeon_fence *fence) |
| 240 | { | 160 | { |
| @@ -260,10 +180,6 @@ void r300_fence_ring_emit(struct radeon_device *rdev, | |||
| 260 | radeon_ring_write(rdev, RADEON_SW_INT_FIRE); | 180 | radeon_ring_write(rdev, RADEON_SW_INT_FIRE); |
| 261 | } | 181 | } |
| 262 | 182 | ||
| 263 | |||
| 264 | /* | ||
| 265 | * Global GPU functions | ||
| 266 | */ | ||
| 267 | int r300_copy_dma(struct radeon_device *rdev, | 183 | int r300_copy_dma(struct radeon_device *rdev, |
| 268 | uint64_t src_offset, | 184 | uint64_t src_offset, |
| 269 | uint64_t dst_offset, | 185 | uint64_t dst_offset, |
| @@ -582,11 +498,6 @@ void r300_vram_info(struct radeon_device *rdev) | |||
| 582 | r100_vram_init_sizes(rdev); | 498 | r100_vram_init_sizes(rdev); |
| 583 | } | 499 | } |
| 584 | 500 | ||
| 585 | |||
| 586 | /* | ||
| 587 | * PCIE Lanes | ||
| 588 | */ | ||
| 589 | |||
| 590 | void rv370_set_pcie_lanes(struct radeon_device *rdev, int lanes) | 501 | void rv370_set_pcie_lanes(struct radeon_device *rdev, int lanes) |
| 591 | { | 502 | { |
| 592 | uint32_t link_width_cntl, mask; | 503 | uint32_t link_width_cntl, mask; |
| @@ -646,10 +557,6 @@ void rv370_set_pcie_lanes(struct radeon_device *rdev, int lanes) | |||
| 646 | 557 | ||
| 647 | } | 558 | } |
| 648 | 559 | ||
| 649 | |||
| 650 | /* | ||
| 651 | * Debugfs info | ||
| 652 | */ | ||
| 653 | #if defined(CONFIG_DEBUG_FS) | 560 | #if defined(CONFIG_DEBUG_FS) |
| 654 | static int rv370_debugfs_pcie_gart_info(struct seq_file *m, void *data) | 561 | static int rv370_debugfs_pcie_gart_info(struct seq_file *m, void *data) |
| 655 | { | 562 | { |
| @@ -680,7 +587,7 @@ static struct drm_info_list rv370_pcie_gart_info_list[] = { | |||
| 680 | }; | 587 | }; |
| 681 | #endif | 588 | #endif |
| 682 | 589 | ||
| 683 | int rv370_debugfs_pcie_gart_info_init(struct radeon_device *rdev) | 590 | static int rv370_debugfs_pcie_gart_info_init(struct radeon_device *rdev) |
| 684 | { | 591 | { |
| 685 | #if defined(CONFIG_DEBUG_FS) | 592 | #if defined(CONFIG_DEBUG_FS) |
| 686 | return radeon_debugfs_add_files(rdev, rv370_pcie_gart_info_list, 1); | 593 | return radeon_debugfs_add_files(rdev, rv370_pcie_gart_info_list, 1); |
| @@ -689,10 +596,6 @@ int rv370_debugfs_pcie_gart_info_init(struct radeon_device *rdev) | |||
| 689 | #endif | 596 | #endif |
| 690 | } | 597 | } |
| 691 | 598 | ||
| 692 | |||
| 693 | /* | ||
| 694 | * CS functions | ||
| 695 | */ | ||
| 696 | static int r300_packet0_check(struct radeon_cs_parser *p, | 599 | static int r300_packet0_check(struct radeon_cs_parser *p, |
| 697 | struct radeon_cs_packet *pkt, | 600 | struct radeon_cs_packet *pkt, |
| 698 | unsigned idx, unsigned reg) | 601 | unsigned idx, unsigned reg) |
| @@ -1226,12 +1129,6 @@ void r300_set_reg_safe(struct radeon_device *rdev) | |||
| 1226 | rdev->config.r300.reg_safe_bm_size = ARRAY_SIZE(r300_reg_safe_bm); | 1129 | rdev->config.r300.reg_safe_bm_size = ARRAY_SIZE(r300_reg_safe_bm); |
| 1227 | } | 1130 | } |
| 1228 | 1131 | ||
| 1229 | int r300_init(struct radeon_device *rdev) | ||
| 1230 | { | ||
| 1231 | r300_set_reg_safe(rdev); | ||
| 1232 | return 0; | ||
| 1233 | } | ||
| 1234 | |||
| 1235 | void r300_mc_program(struct radeon_device *rdev) | 1132 | void r300_mc_program(struct radeon_device *rdev) |
| 1236 | { | 1133 | { |
| 1237 | struct r100_mc_save save; | 1134 | struct r100_mc_save save; |
| @@ -1265,3 +1162,198 @@ void r300_mc_program(struct radeon_device *rdev) | |||
| 1265 | S_000148_MC_FB_TOP(rdev->mc.vram_end >> 16)); | 1162 | S_000148_MC_FB_TOP(rdev->mc.vram_end >> 16)); |
| 1266 | r100_mc_resume(rdev, &save); | 1163 | r100_mc_resume(rdev, &save); |
| 1267 | } | 1164 | } |
| 1165 | |||
| 1166 | void r300_clock_startup(struct radeon_device *rdev) | ||
| 1167 | { | ||
| 1168 | u32 tmp; | ||
| 1169 | |||
| 1170 | if (radeon_dynclks != -1 && radeon_dynclks) | ||
| 1171 | radeon_legacy_set_clock_gating(rdev, 1); | ||
| 1172 | /* We need to force on some of the block */ | ||
| 1173 | tmp = RREG32_PLL(R_00000D_SCLK_CNTL); | ||
| 1174 | tmp |= S_00000D_FORCE_CP(1) | S_00000D_FORCE_VIP(1); | ||
| 1175 | if ((rdev->family == CHIP_RV350) || (rdev->family == CHIP_RV380)) | ||
| 1176 | tmp |= S_00000D_FORCE_VAP(1); | ||
| 1177 | WREG32_PLL(R_00000D_SCLK_CNTL, tmp); | ||
| 1178 | } | ||
| 1179 | |||
| 1180 | static int r300_startup(struct radeon_device *rdev) | ||
| 1181 | { | ||
| 1182 | int r; | ||
| 1183 | |||
| 1184 | r300_mc_program(rdev); | ||
| 1185 | /* Resume clock */ | ||
| 1186 | r300_clock_startup(rdev); | ||
| 1187 | /* Initialize GPU configuration (# pipes, ...) */ | ||
| 1188 | r300_gpu_init(rdev); | ||
| 1189 | /* Initialize GART (initialize after TTM so we can allocate | ||
| 1190 | * memory through TTM but finalize after TTM) */ | ||
| 1191 | if (rdev->flags & RADEON_IS_PCIE) { | ||
| 1192 | r = rv370_pcie_gart_enable(rdev); | ||
| 1193 | if (r) | ||
| 1194 | return r; | ||
| 1195 | } | ||
| 1196 | if (rdev->flags & RADEON_IS_PCI) { | ||
| 1197 | r = r100_pci_gart_enable(rdev); | ||
| 1198 | if (r) | ||
| 1199 | return r; | ||
| 1200 | } | ||
| 1201 | /* Enable IRQ */ | ||
| 1202 | rdev->irq.sw_int = true; | ||
| 1203 | r100_irq_set(rdev); | ||
| 1204 | /* 1M ring buffer */ | ||
| 1205 | r = r100_cp_init(rdev, 1024 * 1024); | ||
| 1206 | if (r) { | ||
| 1207 | dev_err(rdev->dev, "failled initializing CP (%d).\n", r); | ||
| 1208 | return r; | ||
| 1209 | } | ||
| 1210 | r = r100_wb_init(rdev); | ||
| 1211 | if (r) | ||
| 1212 | dev_err(rdev->dev, "failled initializing WB (%d).\n", r); | ||
| 1213 | r = r100_ib_init(rdev); | ||
| 1214 | if (r) { | ||
| 1215 | dev_err(rdev->dev, "failled initializing IB (%d).\n", r); | ||
| 1216 | return r; | ||
| 1217 | } | ||
| 1218 | return 0; | ||
| 1219 | } | ||
| 1220 | |||
| 1221 | int r300_resume(struct radeon_device *rdev) | ||
| 1222 | { | ||
| 1223 | /* Make sur GART are not working */ | ||
| 1224 | if (rdev->flags & RADEON_IS_PCIE) | ||
| 1225 | rv370_pcie_gart_disable(rdev); | ||
| 1226 | if (rdev->flags & RADEON_IS_PCI) | ||
| 1227 | r100_pci_gart_disable(rdev); | ||
| 1228 | /* Resume clock before doing reset */ | ||
| 1229 | r300_clock_startup(rdev); | ||
| 1230 | /* Reset gpu before posting otherwise ATOM will enter infinite loop */ | ||
| 1231 | if (radeon_gpu_reset(rdev)) { | ||
| 1232 | dev_warn(rdev->dev, "GPU reset failed ! (0xE40=0x%08X, 0x7C0=0x%08X)\n", | ||
| 1233 | RREG32(R_000E40_RBBM_STATUS), | ||
| 1234 | RREG32(R_0007C0_CP_STAT)); | ||
| 1235 | } | ||
| 1236 | /* post */ | ||
| 1237 | radeon_combios_asic_init(rdev->ddev); | ||
| 1238 | /* Resume clock after posting */ | ||
| 1239 | r300_clock_startup(rdev); | ||
| 1240 | return r300_startup(rdev); | ||
| 1241 | } | ||
| 1242 | |||
| 1243 | int r300_suspend(struct radeon_device *rdev) | ||
| 1244 | { | ||
| 1245 | r100_cp_disable(rdev); | ||
| 1246 | r100_wb_disable(rdev); | ||
| 1247 | r100_irq_disable(rdev); | ||
| 1248 | if (rdev->flags & RADEON_IS_PCIE) | ||
| 1249 | rv370_pcie_gart_disable(rdev); | ||
| 1250 | if (rdev->flags & RADEON_IS_PCI) | ||
| 1251 | r100_pci_gart_disable(rdev); | ||
| 1252 | return 0; | ||
| 1253 | } | ||
| 1254 | |||
| 1255 | void r300_fini(struct radeon_device *rdev) | ||
| 1256 | { | ||
| 1257 | r300_suspend(rdev); | ||
| 1258 | r100_cp_fini(rdev); | ||
| 1259 | r100_wb_fini(rdev); | ||
| 1260 | r100_ib_fini(rdev); | ||
| 1261 | radeon_gem_fini(rdev); | ||
| 1262 | if (rdev->flags & RADEON_IS_PCIE) | ||
| 1263 | rv370_pcie_gart_fini(rdev); | ||
| 1264 | if (rdev->flags & RADEON_IS_PCI) | ||
| 1265 | r100_pci_gart_fini(rdev); | ||
| 1266 | radeon_irq_kms_fini(rdev); | ||
| 1267 | radeon_fence_driver_fini(rdev); | ||
| 1268 | radeon_object_fini(rdev); | ||
| 1269 | radeon_atombios_fini(rdev); | ||
| 1270 | kfree(rdev->bios); | ||
| 1271 | rdev->bios = NULL; | ||
| 1272 | } | ||
| 1273 | |||
| 1274 | int r300_init(struct radeon_device *rdev) | ||
| 1275 | { | ||
| 1276 | int r; | ||
| 1277 | |||
| 1278 | /* Disable VGA */ | ||
| 1279 | r100_vga_render_disable(rdev); | ||
| 1280 | /* Initialize scratch registers */ | ||
| 1281 | radeon_scratch_init(rdev); | ||
| 1282 | /* Initialize surface registers */ | ||
| 1283 | radeon_surface_init(rdev); | ||
| 1284 | /* TODO: disable VGA need to use VGA request */ | ||
| 1285 | /* BIOS*/ | ||
| 1286 | if (!radeon_get_bios(rdev)) { | ||
| 1287 | if (ASIC_IS_AVIVO(rdev)) | ||
| 1288 | return -EINVAL; | ||
| 1289 | } | ||
| 1290 | if (rdev->is_atom_bios) { | ||
| 1291 | dev_err(rdev->dev, "Expecting combios for RS400/RS480 GPU\n"); | ||
| 1292 | return -EINVAL; | ||
| 1293 | } else { | ||
| 1294 | r = radeon_combios_init(rdev); | ||
| 1295 | if (r) | ||
| 1296 | return r; | ||
| 1297 | } | ||
| 1298 | /* Reset gpu before posting otherwise ATOM will enter infinite loop */ | ||
| 1299 | if (radeon_gpu_reset(rdev)) { | ||
| 1300 | dev_warn(rdev->dev, | ||
| 1301 | "GPU reset failed ! (0xE40=0x%08X, 0x7C0=0x%08X)\n", | ||
| 1302 | RREG32(R_000E40_RBBM_STATUS), | ||
| 1303 | RREG32(R_0007C0_CP_STAT)); | ||
| 1304 | } | ||
| 1305 | /* check if cards are posted or not */ | ||
| 1306 | if (!radeon_card_posted(rdev) && rdev->bios) { | ||
| 1307 | DRM_INFO("GPU not posted. posting now...\n"); | ||
| 1308 | radeon_combios_asic_init(rdev->ddev); | ||
| 1309 | } | ||
| 1310 | /* Set asic errata */ | ||
| 1311 | r300_errata(rdev); | ||
| 1312 | /* Initialize clocks */ | ||
| 1313 | radeon_get_clock_info(rdev->ddev); | ||
| 1314 | /* Get vram informations */ | ||
| 1315 | r300_vram_info(rdev); | ||
| 1316 | /* Initialize memory controller (also test AGP) */ | ||
| 1317 | r = r420_mc_init(rdev); | ||
| 1318 | if (r) | ||
| 1319 | return r; | ||
| 1320 | /* Fence driver */ | ||
| 1321 | r = radeon_fence_driver_init(rdev); | ||
| 1322 | if (r) | ||
| 1323 | return r; | ||
| 1324 | r = radeon_irq_kms_init(rdev); | ||
| 1325 | if (r) | ||
| 1326 | return r; | ||
| 1327 | /* Memory manager */ | ||
| 1328 | r = radeon_object_init(rdev); | ||
| 1329 | if (r) | ||
| 1330 | return r; | ||
| 1331 | if (rdev->flags & RADEON_IS_PCIE) { | ||
| 1332 | r = rv370_pcie_gart_init(rdev); | ||
| 1333 | if (r) | ||
| 1334 | return r; | ||
| 1335 | } | ||
| 1336 | if (rdev->flags & RADEON_IS_PCI) { | ||
| 1337 | r = r100_pci_gart_init(rdev); | ||
| 1338 | if (r) | ||
| 1339 | return r; | ||
| 1340 | } | ||
| 1341 | r300_set_reg_safe(rdev); | ||
| 1342 | rdev->accel_working = true; | ||
| 1343 | r = r300_startup(rdev); | ||
| 1344 | if (r) { | ||
| 1345 | /* Somethings want wront with the accel init stop accel */ | ||
| 1346 | dev_err(rdev->dev, "Disabling GPU acceleration\n"); | ||
| 1347 | r300_suspend(rdev); | ||
| 1348 | r100_cp_fini(rdev); | ||
| 1349 | r100_wb_fini(rdev); | ||
| 1350 | r100_ib_fini(rdev); | ||
| 1351 | if (rdev->flags & RADEON_IS_PCIE) | ||
| 1352 | rv370_pcie_gart_fini(rdev); | ||
| 1353 | if (rdev->flags & RADEON_IS_PCI) | ||
| 1354 | r100_pci_gart_fini(rdev); | ||
| 1355 | radeon_irq_kms_fini(rdev); | ||
| 1356 | rdev->accel_working = false; | ||
| 1357 | } | ||
| 1358 | return 0; | ||
| 1359 | } | ||
diff --git a/drivers/gpu/drm/radeon/r300d.h b/drivers/gpu/drm/radeon/r300d.h index d4fa3eb1074f..4c73114f0de9 100644 --- a/drivers/gpu/drm/radeon/r300d.h +++ b/drivers/gpu/drm/radeon/r300d.h | |||
| @@ -96,6 +96,211 @@ | |||
| 96 | #define S_000170_AGP_BASE_ADDR(x) (((x) & 0xFFFFFFFF) << 0) | 96 | #define S_000170_AGP_BASE_ADDR(x) (((x) & 0xFFFFFFFF) << 0) |
| 97 | #define G_000170_AGP_BASE_ADDR(x) (((x) >> 0) & 0xFFFFFFFF) | 97 | #define G_000170_AGP_BASE_ADDR(x) (((x) >> 0) & 0xFFFFFFFF) |
| 98 | #define C_000170_AGP_BASE_ADDR 0x00000000 | 98 | #define C_000170_AGP_BASE_ADDR 0x00000000 |
| 99 | #define R_0007C0_CP_STAT 0x0007C0 | ||
| 100 | #define S_0007C0_MRU_BUSY(x) (((x) & 0x1) << 0) | ||
| 101 | #define G_0007C0_MRU_BUSY(x) (((x) >> 0) & 0x1) | ||
| 102 | #define C_0007C0_MRU_BUSY 0xFFFFFFFE | ||
| 103 | #define S_0007C0_MWU_BUSY(x) (((x) & 0x1) << 1) | ||
| 104 | #define G_0007C0_MWU_BUSY(x) (((x) >> 1) & 0x1) | ||
| 105 | #define C_0007C0_MWU_BUSY 0xFFFFFFFD | ||
| 106 | #define S_0007C0_RSIU_BUSY(x) (((x) & 0x1) << 2) | ||
| 107 | #define G_0007C0_RSIU_BUSY(x) (((x) >> 2) & 0x1) | ||
| 108 | #define C_0007C0_RSIU_BUSY 0xFFFFFFFB | ||
| 109 | #define S_0007C0_RCIU_BUSY(x) (((x) & 0x1) << 3) | ||
| 110 | #define G_0007C0_RCIU_BUSY(x) (((x) >> 3) & 0x1) | ||
| 111 | #define C_0007C0_RCIU_BUSY 0xFFFFFFF7 | ||
| 112 | #define S_0007C0_CSF_PRIMARY_BUSY(x) (((x) & 0x1) << 9) | ||
| 113 | #define G_0007C0_CSF_PRIMARY_BUSY(x) (((x) >> 9) & 0x1) | ||
| 114 | #define C_0007C0_CSF_PRIMARY_BUSY 0xFFFFFDFF | ||
| 115 | #define S_0007C0_CSF_INDIRECT_BUSY(x) (((x) & 0x1) << 10) | ||
| 116 | #define G_0007C0_CSF_INDIRECT_BUSY(x) (((x) >> 10) & 0x1) | ||
| 117 | #define C_0007C0_CSF_INDIRECT_BUSY 0xFFFFFBFF | ||
| 118 | #define S_0007C0_CSQ_PRIMARY_BUSY(x) (((x) & 0x1) << 11) | ||
| 119 | #define G_0007C0_CSQ_PRIMARY_BUSY(x) (((x) >> 11) & 0x1) | ||
| 120 | #define C_0007C0_CSQ_PRIMARY_BUSY 0xFFFFF7FF | ||
| 121 | #define S_0007C0_CSQ_INDIRECT_BUSY(x) (((x) & 0x1) << 12) | ||
| 122 | #define G_0007C0_CSQ_INDIRECT_BUSY(x) (((x) >> 12) & 0x1) | ||
| 123 | #define C_0007C0_CSQ_INDIRECT_BUSY 0xFFFFEFFF | ||
| 124 | #define S_0007C0_CSI_BUSY(x) (((x) & 0x1) << 13) | ||
| 125 | #define G_0007C0_CSI_BUSY(x) (((x) >> 13) & 0x1) | ||
| 126 | #define C_0007C0_CSI_BUSY 0xFFFFDFFF | ||
| 127 | #define S_0007C0_CSF_INDIRECT2_BUSY(x) (((x) & 0x1) << 14) | ||
| 128 | #define G_0007C0_CSF_INDIRECT2_BUSY(x) (((x) >> 14) & 0x1) | ||
| 129 | #define C_0007C0_CSF_INDIRECT2_BUSY 0xFFFFBFFF | ||
| 130 | #define S_0007C0_CSQ_INDIRECT2_BUSY(x) (((x) & 0x1) << 15) | ||
| 131 | #define G_0007C0_CSQ_INDIRECT2_BUSY(x) (((x) >> 15) & 0x1) | ||
| 132 | #define C_0007C0_CSQ_INDIRECT2_BUSY 0xFFFF7FFF | ||
| 133 | #define S_0007C0_GUIDMA_BUSY(x) (((x) & 0x1) << 28) | ||
| 134 | #define G_0007C0_GUIDMA_BUSY(x) (((x) >> 28) & 0x1) | ||
| 135 | #define C_0007C0_GUIDMA_BUSY 0xEFFFFFFF | ||
| 136 | #define S_0007C0_VIDDMA_BUSY(x) (((x) & 0x1) << 29) | ||
| 137 | #define G_0007C0_VIDDMA_BUSY(x) (((x) >> 29) & 0x1) | ||
| 138 | #define C_0007C0_VIDDMA_BUSY 0xDFFFFFFF | ||
| 139 | #define S_0007C0_CMDSTRM_BUSY(x) (((x) & 0x1) << 30) | ||
| 140 | #define G_0007C0_CMDSTRM_BUSY(x) (((x) >> 30) & 0x1) | ||
| 141 | #define C_0007C0_CMDSTRM_BUSY 0xBFFFFFFF | ||
| 142 | #define S_0007C0_CP_BUSY(x) (((x) & 0x1) << 31) | ||
| 143 | #define G_0007C0_CP_BUSY(x) (((x) >> 31) & 0x1) | ||
| 144 | #define C_0007C0_CP_BUSY 0x7FFFFFFF | ||
| 145 | #define R_000E40_RBBM_STATUS 0x000E40 | ||
| 146 | #define S_000E40_CMDFIFO_AVAIL(x) (((x) & 0x7F) << 0) | ||
| 147 | #define G_000E40_CMDFIFO_AVAIL(x) (((x) >> 0) & 0x7F) | ||
| 148 | #define C_000E40_CMDFIFO_AVAIL 0xFFFFFF80 | ||
| 149 | #define S_000E40_HIRQ_ON_RBB(x) (((x) & 0x1) << 8) | ||
| 150 | #define G_000E40_HIRQ_ON_RBB(x) (((x) >> 8) & 0x1) | ||
| 151 | #define C_000E40_HIRQ_ON_RBB 0xFFFFFEFF | ||
| 152 | #define S_000E40_CPRQ_ON_RBB(x) (((x) & 0x1) << 9) | ||
| 153 | #define G_000E40_CPRQ_ON_RBB(x) (((x) >> 9) & 0x1) | ||
| 154 | #define C_000E40_CPRQ_ON_RBB 0xFFFFFDFF | ||
| 155 | #define S_000E40_CFRQ_ON_RBB(x) (((x) & 0x1) << 10) | ||
| 156 | #define G_000E40_CFRQ_ON_RBB(x) (((x) >> 10) & 0x1) | ||
| 157 | #define C_000E40_CFRQ_ON_RBB 0xFFFFFBFF | ||
| 158 | #define S_000E40_HIRQ_IN_RTBUF(x) (((x) & 0x1) << 11) | ||
| 159 | #define G_000E40_HIRQ_IN_RTBUF(x) (((x) >> 11) & 0x1) | ||
| 160 | #define C_000E40_HIRQ_IN_RTBUF 0xFFFFF7FF | ||
| 161 | #define S_000E40_CPRQ_IN_RTBUF(x) (((x) & 0x1) << 12) | ||
| 162 | #define G_000E40_CPRQ_IN_RTBUF(x) (((x) >> 12) & 0x1) | ||
| 163 | #define C_000E40_CPRQ_IN_RTBUF 0xFFFFEFFF | ||
| 164 | #define S_000E40_CFRQ_IN_RTBUF(x) (((x) & 0x1) << 13) | ||
| 165 | #define G_000E40_CFRQ_IN_RTBUF(x) (((x) >> 13) & 0x1) | ||
| 166 | #define C_000E40_CFRQ_IN_RTBUF 0xFFFFDFFF | ||
| 167 | #define S_000E40_CF_PIPE_BUSY(x) (((x) & 0x1) << 14) | ||
| 168 | #define G_000E40_CF_PIPE_BUSY(x) (((x) >> 14) & 0x1) | ||
| 169 | #define C_000E40_CF_PIPE_BUSY 0xFFFFBFFF | ||
| 170 | #define S_000E40_ENG_EV_BUSY(x) (((x) & 0x1) << 15) | ||
| 171 | #define G_000E40_ENG_EV_BUSY(x) (((x) >> 15) & 0x1) | ||
| 172 | #define C_000E40_ENG_EV_BUSY 0xFFFF7FFF | ||
| 173 | #define S_000E40_CP_CMDSTRM_BUSY(x) (((x) & 0x1) << 16) | ||
| 174 | #define G_000E40_CP_CMDSTRM_BUSY(x) (((x) >> 16) & 0x1) | ||
| 175 | #define C_000E40_CP_CMDSTRM_BUSY 0xFFFEFFFF | ||
| 176 | #define S_000E40_E2_BUSY(x) (((x) & 0x1) << 17) | ||
| 177 | #define G_000E40_E2_BUSY(x) (((x) >> 17) & 0x1) | ||
| 178 | #define C_000E40_E2_BUSY 0xFFFDFFFF | ||
| 179 | #define S_000E40_RB2D_BUSY(x) (((x) & 0x1) << 18) | ||
| 180 | #define G_000E40_RB2D_BUSY(x) (((x) >> 18) & 0x1) | ||
| 181 | #define C_000E40_RB2D_BUSY 0xFFFBFFFF | ||
| 182 | #define S_000E40_RB3D_BUSY(x) (((x) & 0x1) << 19) | ||
| 183 | #define G_000E40_RB3D_BUSY(x) (((x) >> 19) & 0x1) | ||
| 184 | #define C_000E40_RB3D_BUSY 0xFFF7FFFF | ||
| 185 | #define S_000E40_VAP_BUSY(x) (((x) & 0x1) << 20) | ||
| 186 | #define G_000E40_VAP_BUSY(x) (((x) >> 20) & 0x1) | ||
| 187 | #define C_000E40_VAP_BUSY 0xFFEFFFFF | ||
| 188 | #define S_000E40_RE_BUSY(x) (((x) & 0x1) << 21) | ||
| 189 | #define G_000E40_RE_BUSY(x) (((x) >> 21) & 0x1) | ||
| 190 | #define C_000E40_RE_BUSY 0xFFDFFFFF | ||
| 191 | #define S_000E40_TAM_BUSY(x) (((x) & 0x1) << 22) | ||
| 192 | #define G_000E40_TAM_BUSY(x) (((x) >> 22) & 0x1) | ||
| 193 | #define C_000E40_TAM_BUSY 0xFFBFFFFF | ||
| 194 | #define S_000E40_TDM_BUSY(x) (((x) & 0x1) << 23) | ||
| 195 | #define G_000E40_TDM_BUSY(x) (((x) >> 23) & 0x1) | ||
| 196 | #define C_000E40_TDM_BUSY 0xFF7FFFFF | ||
| 197 | #define S_000E40_PB_BUSY(x) (((x) & 0x1) << 24) | ||
| 198 | #define G_000E40_PB_BUSY(x) (((x) >> 24) & 0x1) | ||
| 199 | #define C_000E40_PB_BUSY 0xFEFFFFFF | ||
| 200 | #define S_000E40_TIM_BUSY(x) (((x) & 0x1) << 25) | ||
| 201 | #define G_000E40_TIM_BUSY(x) (((x) >> 25) & 0x1) | ||
| 202 | #define C_000E40_TIM_BUSY 0xFDFFFFFF | ||
| 203 | #define S_000E40_GA_BUSY(x) (((x) & 0x1) << 26) | ||
| 204 | #define G_000E40_GA_BUSY(x) (((x) >> 26) & 0x1) | ||
| 205 | #define C_000E40_GA_BUSY 0xFBFFFFFF | ||
| 206 | #define S_000E40_CBA2D_BUSY(x) (((x) & 0x1) << 27) | ||
| 207 | #define G_000E40_CBA2D_BUSY(x) (((x) >> 27) & 0x1) | ||
| 208 | #define C_000E40_CBA2D_BUSY 0xF7FFFFFF | ||
| 209 | #define S_000E40_GUI_ACTIVE(x) (((x) & 0x1) << 31) | ||
| 210 | #define G_000E40_GUI_ACTIVE(x) (((x) >> 31) & 0x1) | ||
| 211 | #define C_000E40_GUI_ACTIVE 0x7FFFFFFF | ||
| 99 | 212 | ||
| 100 | 213 | ||
| 214 | #define R_00000D_SCLK_CNTL 0x00000D | ||
| 215 | #define S_00000D_SCLK_SRC_SEL(x) (((x) & 0x7) << 0) | ||
| 216 | #define G_00000D_SCLK_SRC_SEL(x) (((x) >> 0) & 0x7) | ||
| 217 | #define C_00000D_SCLK_SRC_SEL 0xFFFFFFF8 | ||
| 218 | #define S_00000D_CP_MAX_DYN_STOP_LAT(x) (((x) & 0x1) << 3) | ||
| 219 | #define G_00000D_CP_MAX_DYN_STOP_LAT(x) (((x) >> 3) & 0x1) | ||
| 220 | #define C_00000D_CP_MAX_DYN_STOP_LAT 0xFFFFFFF7 | ||
| 221 | #define S_00000D_HDP_MAX_DYN_STOP_LAT(x) (((x) & 0x1) << 4) | ||
| 222 | #define G_00000D_HDP_MAX_DYN_STOP_LAT(x) (((x) >> 4) & 0x1) | ||
| 223 | #define C_00000D_HDP_MAX_DYN_STOP_LAT 0xFFFFFFEF | ||
| 224 | #define S_00000D_TV_MAX_DYN_STOP_LAT(x) (((x) & 0x1) << 5) | ||
| 225 | #define G_00000D_TV_MAX_DYN_STOP_LAT(x) (((x) >> 5) & 0x1) | ||
| 226 | #define C_00000D_TV_MAX_DYN_STOP_LAT 0xFFFFFFDF | ||
| 227 | #define S_00000D_E2_MAX_DYN_STOP_LAT(x) (((x) & 0x1) << 6) | ||
| 228 | #define G_00000D_E2_MAX_DYN_STOP_LAT(x) (((x) >> 6) & 0x1) | ||
| 229 | #define C_00000D_E2_MAX_DYN_STOP_LAT 0xFFFFFFBF | ||
| 230 | #define S_00000D_SE_MAX_DYN_STOP_LAT(x) (((x) & 0x1) << 7) | ||
| 231 | #define G_00000D_SE_MAX_DYN_STOP_LAT(x) (((x) >> 7) & 0x1) | ||
| 232 | #define C_00000D_SE_MAX_DYN_STOP_LAT 0xFFFFFF7F | ||
| 233 | #define S_00000D_IDCT_MAX_DYN_STOP_LAT(x) (((x) & 0x1) << 8) | ||
| 234 | #define G_00000D_IDCT_MAX_DYN_STOP_LAT(x) (((x) >> 8) & 0x1) | ||
| 235 | #define C_00000D_IDCT_MAX_DYN_STOP_LAT 0xFFFFFEFF | ||
| 236 | #define S_00000D_VIP_MAX_DYN_STOP_LAT(x) (((x) & 0x1) << 9) | ||
| 237 | #define G_00000D_VIP_MAX_DYN_STOP_LAT(x) (((x) >> 9) & 0x1) | ||
| 238 | #define C_00000D_VIP_MAX_DYN_STOP_LAT 0xFFFFFDFF | ||
| 239 | #define S_00000D_RE_MAX_DYN_STOP_LAT(x) (((x) & 0x1) << 10) | ||
| 240 | #define G_00000D_RE_MAX_DYN_STOP_LAT(x) (((x) >> 10) & 0x1) | ||
| 241 | #define C_00000D_RE_MAX_DYN_STOP_LAT 0xFFFFFBFF | ||
| 242 | #define S_00000D_PB_MAX_DYN_STOP_LAT(x) (((x) & 0x1) << 11) | ||
| 243 | #define G_00000D_PB_MAX_DYN_STOP_LAT(x) (((x) >> 11) & 0x1) | ||
| 244 | #define C_00000D_PB_MAX_DYN_STOP_LAT 0xFFFFF7FF | ||
| 245 | #define S_00000D_TAM_MAX_DYN_STOP_LAT(x) (((x) & 0x1) << 12) | ||
| 246 | #define G_00000D_TAM_MAX_DYN_STOP_LAT(x) (((x) >> 12) & 0x1) | ||
| 247 | #define C_00000D_TAM_MAX_DYN_STOP_LAT 0xFFFFEFFF | ||
| 248 | #define S_00000D_TDM_MAX_DYN_STOP_LAT(x) (((x) & 0x1) << 13) | ||
| 249 | #define G_00000D_TDM_MAX_DYN_STOP_LAT(x) (((x) >> 13) & 0x1) | ||
| 250 | #define C_00000D_TDM_MAX_DYN_STOP_LAT 0xFFFFDFFF | ||
| 251 | #define S_00000D_RB_MAX_DYN_STOP_LAT(x) (((x) & 0x1) << 14) | ||
| 252 | #define G_00000D_RB_MAX_DYN_STOP_LAT(x) (((x) >> 14) & 0x1) | ||
| 253 | #define C_00000D_RB_MAX_DYN_STOP_LAT 0xFFFFBFFF | ||
| 254 | #define S_00000D_FORCE_DISP2(x) (((x) & 0x1) << 15) | ||
| 255 | #define G_00000D_FORCE_DISP2(x) (((x) >> 15) & 0x1) | ||
| 256 | #define C_00000D_FORCE_DISP2 0xFFFF7FFF | ||
| 257 | #define S_00000D_FORCE_CP(x) (((x) & 0x1) << 16) | ||
| 258 | #define G_00000D_FORCE_CP(x) (((x) >> 16) & 0x1) | ||
| 259 | #define C_00000D_FORCE_CP 0xFFFEFFFF | ||
| 260 | #define S_00000D_FORCE_HDP(x) (((x) & 0x1) << 17) | ||
| 261 | #define G_00000D_FORCE_HDP(x) (((x) >> 17) & 0x1) | ||
| 262 | #define C_00000D_FORCE_HDP 0xFFFDFFFF | ||
| 263 | #define S_00000D_FORCE_DISP1(x) (((x) & 0x1) << 18) | ||
| 264 | #define G_00000D_FORCE_DISP1(x) (((x) >> 18) & 0x1) | ||
| 265 | #define C_00000D_FORCE_DISP1 0xFFFBFFFF | ||
| 266 | #define S_00000D_FORCE_TOP(x) (((x) & 0x1) << 19) | ||
| 267 | #define G_00000D_FORCE_TOP(x) (((x) >> 19) & 0x1) | ||
| 268 | #define C_00000D_FORCE_TOP 0xFFF7FFFF | ||
| 269 | #define S_00000D_FORCE_E2(x) (((x) & 0x1) << 20) | ||
| 270 | #define G_00000D_FORCE_E2(x) (((x) >> 20) & 0x1) | ||
| 271 | #define C_00000D_FORCE_E2 0xFFEFFFFF | ||
| 272 | #define S_00000D_FORCE_SE(x) (((x) & 0x1) << 21) | ||
| 273 | #define G_00000D_FORCE_SE(x) (((x) >> 21) & 0x1) | ||
| 274 | #define C_00000D_FORCE_SE 0xFFDFFFFF | ||
| 275 | #define S_00000D_FORCE_IDCT(x) (((x) & 0x1) << 22) | ||
| 276 | #define G_00000D_FORCE_IDCT(x) (((x) >> 22) & 0x1) | ||
| 277 | #define C_00000D_FORCE_IDCT 0xFFBFFFFF | ||
| 278 | #define S_00000D_FORCE_VIP(x) (((x) & 0x1) << 23) | ||
| 279 | #define G_00000D_FORCE_VIP(x) (((x) >> 23) & 0x1) | ||
| 280 | #define C_00000D_FORCE_VIP 0xFF7FFFFF | ||
| 281 | #define S_00000D_FORCE_RE(x) (((x) & 0x1) << 24) | ||
| 282 | #define G_00000D_FORCE_RE(x) (((x) >> 24) & 0x1) | ||
| 283 | #define C_00000D_FORCE_RE 0xFEFFFFFF | ||
| 284 | #define S_00000D_FORCE_PB(x) (((x) & 0x1) << 25) | ||
| 285 | #define G_00000D_FORCE_PB(x) (((x) >> 25) & 0x1) | ||
| 286 | #define C_00000D_FORCE_PB 0xFDFFFFFF | ||
| 287 | #define S_00000D_FORCE_TAM(x) (((x) & 0x1) << 26) | ||
| 288 | #define G_00000D_FORCE_TAM(x) (((x) >> 26) & 0x1) | ||
| 289 | #define C_00000D_FORCE_TAM 0xFBFFFFFF | ||
| 290 | #define S_00000D_FORCE_TDM(x) (((x) & 0x1) << 27) | ||
| 291 | #define G_00000D_FORCE_TDM(x) (((x) >> 27) & 0x1) | ||
| 292 | #define C_00000D_FORCE_TDM 0xF7FFFFFF | ||
| 293 | #define S_00000D_FORCE_RB(x) (((x) & 0x1) << 28) | ||
| 294 | #define G_00000D_FORCE_RB(x) (((x) >> 28) & 0x1) | ||
| 295 | #define C_00000D_FORCE_RB 0xEFFFFFFF | ||
| 296 | #define S_00000D_FORCE_TV_SCLK(x) (((x) & 0x1) << 29) | ||
| 297 | #define G_00000D_FORCE_TV_SCLK(x) (((x) >> 29) & 0x1) | ||
| 298 | #define C_00000D_FORCE_TV_SCLK 0xDFFFFFFF | ||
| 299 | #define S_00000D_FORCE_SUBPIC(x) (((x) & 0x1) << 30) | ||
| 300 | #define G_00000D_FORCE_SUBPIC(x) (((x) >> 30) & 0x1) | ||
| 301 | #define C_00000D_FORCE_SUBPIC 0xBFFFFFFF | ||
| 302 | #define S_00000D_FORCE_OV0(x) (((x) & 0x1) << 31) | ||
| 303 | #define G_00000D_FORCE_OV0(x) (((x) >> 31) & 0x1) | ||
| 304 | #define C_00000D_FORCE_OV0 0x7FFFFFFF | ||
| 305 | |||
| 101 | #endif | 306 | #endif |
diff --git a/drivers/gpu/drm/radeon/r420.c b/drivers/gpu/drm/radeon/r420.c index 49a2fdc57d27..5c7fe52de30e 100644 --- a/drivers/gpu/drm/radeon/r420.c +++ b/drivers/gpu/drm/radeon/r420.c | |||
| @@ -155,6 +155,9 @@ static void r420_debugfs(struct radeon_device *rdev) | |||
| 155 | static void r420_clock_resume(struct radeon_device *rdev) | 155 | static void r420_clock_resume(struct radeon_device *rdev) |
| 156 | { | 156 | { |
| 157 | u32 sclk_cntl; | 157 | u32 sclk_cntl; |
| 158 | |||
| 159 | if (radeon_dynclks != -1 && radeon_dynclks) | ||
| 160 | radeon_atom_set_clock_gating(rdev, 1); | ||
| 158 | sclk_cntl = RREG32_PLL(R_00000D_SCLK_CNTL); | 161 | sclk_cntl = RREG32_PLL(R_00000D_SCLK_CNTL); |
| 159 | sclk_cntl |= S_00000D_FORCE_CP(1) | S_00000D_FORCE_VIP(1); | 162 | sclk_cntl |= S_00000D_FORCE_CP(1) | S_00000D_FORCE_VIP(1); |
| 160 | if (rdev->family == CHIP_R420) | 163 | if (rdev->family == CHIP_R420) |
| @@ -167,6 +170,8 @@ static int r420_startup(struct radeon_device *rdev) | |||
| 167 | int r; | 170 | int r; |
| 168 | 171 | ||
| 169 | r300_mc_program(rdev); | 172 | r300_mc_program(rdev); |
| 173 | /* Resume clock */ | ||
| 174 | r420_clock_resume(rdev); | ||
| 170 | /* Initialize GART (initialize after TTM so we can allocate | 175 | /* Initialize GART (initialize after TTM so we can allocate |
| 171 | * memory through TTM but finalize after TTM) */ | 176 | * memory through TTM but finalize after TTM) */ |
| 172 | if (rdev->flags & RADEON_IS_PCIE) { | 177 | if (rdev->flags & RADEON_IS_PCIE) { |
| @@ -267,7 +272,6 @@ int r420_init(struct radeon_device *rdev) | |||
| 267 | { | 272 | { |
| 268 | int r; | 273 | int r; |
| 269 | 274 | ||
| 270 | rdev->new_init_path = true; | ||
| 271 | /* Initialize scratch registers */ | 275 | /* Initialize scratch registers */ |
| 272 | radeon_scratch_init(rdev); | 276 | radeon_scratch_init(rdev); |
| 273 | /* Initialize surface registers */ | 277 | /* Initialize surface registers */ |
diff --git a/drivers/gpu/drm/radeon/r420d.h b/drivers/gpu/drm/radeon/r420d.h index a48a7db1e2aa..fc78d31a0b4a 100644 --- a/drivers/gpu/drm/radeon/r420d.h +++ b/drivers/gpu/drm/radeon/r420d.h | |||
| @@ -212,9 +212,9 @@ | |||
| 212 | #define S_00000D_FORCE_E2(x) (((x) & 0x1) << 20) | 212 | #define S_00000D_FORCE_E2(x) (((x) & 0x1) << 20) |
| 213 | #define G_00000D_FORCE_E2(x) (((x) >> 20) & 0x1) | 213 | #define G_00000D_FORCE_E2(x) (((x) >> 20) & 0x1) |
| 214 | #define C_00000D_FORCE_E2 0xFFEFFFFF | 214 | #define C_00000D_FORCE_E2 0xFFEFFFFF |
| 215 | #define S_00000D_FORCE_SE(x) (((x) & 0x1) << 21) | 215 | #define S_00000D_FORCE_VAP(x) (((x) & 0x1) << 21) |
| 216 | #define G_00000D_FORCE_SE(x) (((x) >> 21) & 0x1) | 216 | #define G_00000D_FORCE_VAP(x) (((x) >> 21) & 0x1) |
| 217 | #define C_00000D_FORCE_SE 0xFFDFFFFF | 217 | #define C_00000D_FORCE_VAP 0xFFDFFFFF |
| 218 | #define S_00000D_FORCE_IDCT(x) (((x) & 0x1) << 22) | 218 | #define S_00000D_FORCE_IDCT(x) (((x) & 0x1) << 22) |
| 219 | #define G_00000D_FORCE_IDCT(x) (((x) >> 22) & 0x1) | 219 | #define G_00000D_FORCE_IDCT(x) (((x) >> 22) & 0x1) |
| 220 | #define C_00000D_FORCE_IDCT 0xFFBFFFFF | 220 | #define C_00000D_FORCE_IDCT 0xFFBFFFFF |
| @@ -224,24 +224,24 @@ | |||
| 224 | #define S_00000D_FORCE_RE(x) (((x) & 0x1) << 24) | 224 | #define S_00000D_FORCE_RE(x) (((x) & 0x1) << 24) |
| 225 | #define G_00000D_FORCE_RE(x) (((x) >> 24) & 0x1) | 225 | #define G_00000D_FORCE_RE(x) (((x) >> 24) & 0x1) |
| 226 | #define C_00000D_FORCE_RE 0xFEFFFFFF | 226 | #define C_00000D_FORCE_RE 0xFEFFFFFF |
| 227 | #define S_00000D_FORCE_PB(x) (((x) & 0x1) << 25) | 227 | #define S_00000D_FORCE_SR(x) (((x) & 0x1) << 25) |
| 228 | #define G_00000D_FORCE_PB(x) (((x) >> 25) & 0x1) | 228 | #define G_00000D_FORCE_SR(x) (((x) >> 25) & 0x1) |
| 229 | #define C_00000D_FORCE_PB 0xFDFFFFFF | 229 | #define C_00000D_FORCE_SR 0xFDFFFFFF |
| 230 | #define S_00000D_FORCE_PX(x) (((x) & 0x1) << 26) | 230 | #define S_00000D_FORCE_PX(x) (((x) & 0x1) << 26) |
| 231 | #define G_00000D_FORCE_PX(x) (((x) >> 26) & 0x1) | 231 | #define G_00000D_FORCE_PX(x) (((x) >> 26) & 0x1) |
| 232 | #define C_00000D_FORCE_PX 0xFBFFFFFF | 232 | #define C_00000D_FORCE_PX 0xFBFFFFFF |
| 233 | #define S_00000D_FORCE_TX(x) (((x) & 0x1) << 27) | 233 | #define S_00000D_FORCE_TX(x) (((x) & 0x1) << 27) |
| 234 | #define G_00000D_FORCE_TX(x) (((x) >> 27) & 0x1) | 234 | #define G_00000D_FORCE_TX(x) (((x) >> 27) & 0x1) |
| 235 | #define C_00000D_FORCE_TX 0xF7FFFFFF | 235 | #define C_00000D_FORCE_TX 0xF7FFFFFF |
| 236 | #define S_00000D_FORCE_RB(x) (((x) & 0x1) << 28) | 236 | #define S_00000D_FORCE_US(x) (((x) & 0x1) << 28) |
| 237 | #define G_00000D_FORCE_RB(x) (((x) >> 28) & 0x1) | 237 | #define G_00000D_FORCE_US(x) (((x) >> 28) & 0x1) |
| 238 | #define C_00000D_FORCE_RB 0xEFFFFFFF | 238 | #define C_00000D_FORCE_US 0xEFFFFFFF |
| 239 | #define S_00000D_FORCE_TV_SCLK(x) (((x) & 0x1) << 29) | 239 | #define S_00000D_FORCE_TV_SCLK(x) (((x) & 0x1) << 29) |
| 240 | #define G_00000D_FORCE_TV_SCLK(x) (((x) >> 29) & 0x1) | 240 | #define G_00000D_FORCE_TV_SCLK(x) (((x) >> 29) & 0x1) |
| 241 | #define C_00000D_FORCE_TV_SCLK 0xDFFFFFFF | 241 | #define C_00000D_FORCE_TV_SCLK 0xDFFFFFFF |
| 242 | #define S_00000D_FORCE_SUBPIC(x) (((x) & 0x1) << 30) | 242 | #define S_00000D_FORCE_SU(x) (((x) & 0x1) << 30) |
| 243 | #define G_00000D_FORCE_SUBPIC(x) (((x) >> 30) & 0x1) | 243 | #define G_00000D_FORCE_SU(x) (((x) >> 30) & 0x1) |
| 244 | #define C_00000D_FORCE_SUBPIC 0xBFFFFFFF | 244 | #define C_00000D_FORCE_SU 0xBFFFFFFF |
| 245 | #define S_00000D_FORCE_OV0(x) (((x) & 0x1) << 31) | 245 | #define S_00000D_FORCE_OV0(x) (((x) & 0x1) << 31) |
| 246 | #define G_00000D_FORCE_OV0(x) (((x) >> 31) & 0x1) | 246 | #define G_00000D_FORCE_OV0(x) (((x) >> 31) & 0x1) |
| 247 | #define C_00000D_FORCE_OV0 0x7FFFFFFF | 247 | #define C_00000D_FORCE_OV0 0x7FFFFFFF |
diff --git a/drivers/gpu/drm/radeon/r520.c b/drivers/gpu/drm/radeon/r520.c index 0bf13fccdaf2..a555b7b19b48 100644 --- a/drivers/gpu/drm/radeon/r520.c +++ b/drivers/gpu/drm/radeon/r520.c | |||
| @@ -186,7 +186,7 @@ static int r520_startup(struct radeon_device *rdev) | |||
| 186 | } | 186 | } |
| 187 | /* Enable IRQ */ | 187 | /* Enable IRQ */ |
| 188 | rdev->irq.sw_int = true; | 188 | rdev->irq.sw_int = true; |
| 189 | r100_irq_set(rdev); | 189 | rs600_irq_set(rdev); |
| 190 | /* 1M ring buffer */ | 190 | /* 1M ring buffer */ |
| 191 | r = r100_cp_init(rdev, 1024 * 1024); | 191 | r = r100_cp_init(rdev, 1024 * 1024); |
| 192 | if (r) { | 192 | if (r) { |
| @@ -228,7 +228,6 @@ int r520_init(struct radeon_device *rdev) | |||
| 228 | { | 228 | { |
| 229 | int r; | 229 | int r; |
| 230 | 230 | ||
| 231 | rdev->new_init_path = true; | ||
| 232 | /* Initialize scratch registers */ | 231 | /* Initialize scratch registers */ |
| 233 | radeon_scratch_init(rdev); | 232 | radeon_scratch_init(rdev); |
| 234 | /* Initialize surface registers */ | 233 | /* Initialize surface registers */ |
diff --git a/drivers/gpu/drm/radeon/r600.c b/drivers/gpu/drm/radeon/r600.c index 2e4e60edbff4..609719490ec2 100644 --- a/drivers/gpu/drm/radeon/r600.c +++ b/drivers/gpu/drm/radeon/r600.c | |||
| @@ -65,16 +65,11 @@ MODULE_FIRMWARE("radeon/RV710_me.bin"); | |||
| 65 | 65 | ||
| 66 | int r600_debugfs_mc_info_init(struct radeon_device *rdev); | 66 | int r600_debugfs_mc_info_init(struct radeon_device *rdev); |
| 67 | 67 | ||
| 68 | /* This files gather functions specifics to: | 68 | /* r600,rv610,rv630,rv620,rv635,rv670 */ |
| 69 | * r600,rv610,rv630,rv620,rv635,rv670 | ||
| 70 | * | ||
| 71 | * Some of these functions might be used by newer ASICs. | ||
| 72 | */ | ||
| 73 | int r600_mc_wait_for_idle(struct radeon_device *rdev); | 69 | int r600_mc_wait_for_idle(struct radeon_device *rdev); |
| 74 | void r600_gpu_init(struct radeon_device *rdev); | 70 | void r600_gpu_init(struct radeon_device *rdev); |
| 75 | void r600_fini(struct radeon_device *rdev); | 71 | void r600_fini(struct radeon_device *rdev); |
| 76 | 72 | ||
| 77 | |||
| 78 | /* | 73 | /* |
| 79 | * R600 PCIE GART | 74 | * R600 PCIE GART |
| 80 | */ | 75 | */ |
| @@ -168,7 +163,7 @@ int r600_pcie_gart_enable(struct radeon_device *rdev) | |||
| 168 | WREG32(MC_VM_L1_TLB_MCB_RD_SEM_CNTL, tmp | ENABLE_SEMAPHORE_MODE); | 163 | WREG32(MC_VM_L1_TLB_MCB_RD_SEM_CNTL, tmp | ENABLE_SEMAPHORE_MODE); |
| 169 | WREG32(MC_VM_L1_TLB_MCB_WR_SEM_CNTL, tmp | ENABLE_SEMAPHORE_MODE); | 164 | WREG32(MC_VM_L1_TLB_MCB_WR_SEM_CNTL, tmp | ENABLE_SEMAPHORE_MODE); |
| 170 | WREG32(VM_CONTEXT0_PAGE_TABLE_START_ADDR, rdev->mc.gtt_start >> 12); | 165 | WREG32(VM_CONTEXT0_PAGE_TABLE_START_ADDR, rdev->mc.gtt_start >> 12); |
| 171 | WREG32(VM_CONTEXT0_PAGE_TABLE_END_ADDR, (rdev->mc.gtt_end - 1) >> 12); | 166 | WREG32(VM_CONTEXT0_PAGE_TABLE_END_ADDR, rdev->mc.gtt_end >> 12); |
| 172 | WREG32(VM_CONTEXT0_PAGE_TABLE_BASE_ADDR, rdev->gart.table_addr >> 12); | 167 | WREG32(VM_CONTEXT0_PAGE_TABLE_BASE_ADDR, rdev->gart.table_addr >> 12); |
| 173 | WREG32(VM_CONTEXT0_CNTL, ENABLE_CONTEXT | PAGE_TABLE_DEPTH(0) | | 168 | WREG32(VM_CONTEXT0_CNTL, ENABLE_CONTEXT | PAGE_TABLE_DEPTH(0) | |
| 174 | RANGE_PROTECTION_FAULT_ENABLE_DEFAULT); | 169 | RANGE_PROTECTION_FAULT_ENABLE_DEFAULT); |
| @@ -225,6 +220,40 @@ void r600_pcie_gart_fini(struct radeon_device *rdev) | |||
| 225 | radeon_gart_fini(rdev); | 220 | radeon_gart_fini(rdev); |
| 226 | } | 221 | } |
| 227 | 222 | ||
| 223 | void r600_agp_enable(struct radeon_device *rdev) | ||
| 224 | { | ||
| 225 | u32 tmp; | ||
| 226 | int i; | ||
| 227 | |||
| 228 | /* Setup L2 cache */ | ||
| 229 | WREG32(VM_L2_CNTL, ENABLE_L2_CACHE | ENABLE_L2_FRAGMENT_PROCESSING | | ||
| 230 | ENABLE_L2_PTE_CACHE_LRU_UPDATE_BY_WRITE | | ||
| 231 | EFFECTIVE_L2_QUEUE_SIZE(7)); | ||
| 232 | WREG32(VM_L2_CNTL2, 0); | ||
| 233 | WREG32(VM_L2_CNTL3, BANK_SELECT_0(0) | BANK_SELECT_1(1)); | ||
| 234 | /* Setup TLB control */ | ||
| 235 | tmp = ENABLE_L1_TLB | ENABLE_L1_FRAGMENT_PROCESSING | | ||
| 236 | SYSTEM_ACCESS_MODE_NOT_IN_SYS | | ||
| 237 | EFFECTIVE_L1_TLB_SIZE(5) | EFFECTIVE_L1_QUEUE_SIZE(5) | | ||
| 238 | ENABLE_WAIT_L2_QUERY; | ||
| 239 | WREG32(MC_VM_L1_TLB_MCB_RD_SYS_CNTL, tmp); | ||
| 240 | WREG32(MC_VM_L1_TLB_MCB_WR_SYS_CNTL, tmp); | ||
| 241 | WREG32(MC_VM_L1_TLB_MCB_RD_HDP_CNTL, tmp | ENABLE_L1_STRICT_ORDERING); | ||
| 242 | WREG32(MC_VM_L1_TLB_MCB_WR_HDP_CNTL, tmp); | ||
| 243 | WREG32(MC_VM_L1_TLB_MCD_RD_A_CNTL, tmp); | ||
| 244 | WREG32(MC_VM_L1_TLB_MCD_WR_A_CNTL, tmp); | ||
| 245 | WREG32(MC_VM_L1_TLB_MCD_RD_B_CNTL, tmp); | ||
| 246 | WREG32(MC_VM_L1_TLB_MCD_WR_B_CNTL, tmp); | ||
| 247 | WREG32(MC_VM_L1_TLB_MCB_RD_GFX_CNTL, tmp); | ||
| 248 | WREG32(MC_VM_L1_TLB_MCB_WR_GFX_CNTL, tmp); | ||
| 249 | WREG32(MC_VM_L1_TLB_MCB_RD_PDMA_CNTL, tmp); | ||
| 250 | WREG32(MC_VM_L1_TLB_MCB_WR_PDMA_CNTL, tmp); | ||
| 251 | WREG32(MC_VM_L1_TLB_MCB_RD_SEM_CNTL, tmp | ENABLE_SEMAPHORE_MODE); | ||
| 252 | WREG32(MC_VM_L1_TLB_MCB_WR_SEM_CNTL, tmp | ENABLE_SEMAPHORE_MODE); | ||
| 253 | for (i = 0; i < 7; i++) | ||
| 254 | WREG32(VM_CONTEXT0_CNTL + (i * 4), 0); | ||
| 255 | } | ||
| 256 | |||
| 228 | int r600_mc_wait_for_idle(struct radeon_device *rdev) | 257 | int r600_mc_wait_for_idle(struct radeon_device *rdev) |
| 229 | { | 258 | { |
| 230 | unsigned i; | 259 | unsigned i; |
| @@ -240,14 +269,9 @@ int r600_mc_wait_for_idle(struct radeon_device *rdev) | |||
| 240 | return -1; | 269 | return -1; |
| 241 | } | 270 | } |
| 242 | 271 | ||
| 243 | static void r600_mc_resume(struct radeon_device *rdev) | 272 | static void r600_mc_program(struct radeon_device *rdev) |
| 244 | { | 273 | { |
| 245 | u32 d1vga_control, d2vga_control; | 274 | struct rv515_mc_save save; |
| 246 | u32 vga_render_control, vga_hdp_control; | ||
| 247 | u32 d1crtc_control, d2crtc_control; | ||
| 248 | u32 new_d1grph_primary, new_d1grph_secondary; | ||
| 249 | u32 new_d2grph_primary, new_d2grph_secondary; | ||
| 250 | u64 old_vram_start; | ||
| 251 | u32 tmp; | 275 | u32 tmp; |
| 252 | int i, j; | 276 | int i, j; |
| 253 | 277 | ||
| @@ -261,85 +285,51 @@ static void r600_mc_resume(struct radeon_device *rdev) | |||
| 261 | } | 285 | } |
| 262 | WREG32(HDP_REG_COHERENCY_FLUSH_CNTL, 0); | 286 | WREG32(HDP_REG_COHERENCY_FLUSH_CNTL, 0); |
| 263 | 287 | ||
| 264 | d1vga_control = RREG32(D1VGA_CONTROL); | 288 | rv515_mc_stop(rdev, &save); |
| 265 | d2vga_control = RREG32(D2VGA_CONTROL); | ||
| 266 | vga_render_control = RREG32(VGA_RENDER_CONTROL); | ||
| 267 | vga_hdp_control = RREG32(VGA_HDP_CONTROL); | ||
| 268 | d1crtc_control = RREG32(D1CRTC_CONTROL); | ||
| 269 | d2crtc_control = RREG32(D2CRTC_CONTROL); | ||
| 270 | old_vram_start = (u64)(RREG32(MC_VM_FB_LOCATION) & 0xFFFF) << 24; | ||
| 271 | new_d1grph_primary = RREG32(D1GRPH_PRIMARY_SURFACE_ADDRESS); | ||
| 272 | new_d1grph_secondary = RREG32(D1GRPH_SECONDARY_SURFACE_ADDRESS); | ||
| 273 | new_d1grph_primary += rdev->mc.vram_start - old_vram_start; | ||
| 274 | new_d1grph_secondary += rdev->mc.vram_start - old_vram_start; | ||
| 275 | new_d2grph_primary = RREG32(D2GRPH_PRIMARY_SURFACE_ADDRESS); | ||
| 276 | new_d2grph_secondary = RREG32(D2GRPH_SECONDARY_SURFACE_ADDRESS); | ||
| 277 | new_d2grph_primary += rdev->mc.vram_start - old_vram_start; | ||
| 278 | new_d2grph_secondary += rdev->mc.vram_start - old_vram_start; | ||
| 279 | |||
| 280 | /* Stop all video */ | ||
| 281 | WREG32(D1VGA_CONTROL, 0); | ||
| 282 | WREG32(D2VGA_CONTROL, 0); | ||
| 283 | WREG32(VGA_RENDER_CONTROL, 0); | ||
| 284 | WREG32(D1CRTC_UPDATE_LOCK, 1); | ||
| 285 | WREG32(D2CRTC_UPDATE_LOCK, 1); | ||
| 286 | WREG32(D1CRTC_CONTROL, 0); | ||
| 287 | WREG32(D2CRTC_CONTROL, 0); | ||
| 288 | WREG32(D1CRTC_UPDATE_LOCK, 0); | ||
| 289 | WREG32(D2CRTC_UPDATE_LOCK, 0); | ||
| 290 | |||
| 291 | mdelay(1); | ||
| 292 | if (r600_mc_wait_for_idle(rdev)) { | 289 | if (r600_mc_wait_for_idle(rdev)) { |
| 293 | printk(KERN_WARNING "[drm] MC not idle !\n"); | 290 | dev_warn(rdev->dev, "Wait for MC idle timedout !\n"); |
| 294 | } | 291 | } |
| 295 | 292 | /* Lockout access through VGA aperture (doesn't exist before R600) */ | |
| 296 | /* Lockout access through VGA aperture*/ | ||
| 297 | WREG32(VGA_HDP_CONTROL, VGA_MEMORY_DISABLE); | 293 | WREG32(VGA_HDP_CONTROL, VGA_MEMORY_DISABLE); |
| 298 | |||
| 299 | /* Update configuration */ | 294 | /* Update configuration */ |
| 300 | WREG32(MC_VM_SYSTEM_APERTURE_LOW_ADDR, rdev->mc.vram_start >> 12); | 295 | if (rdev->flags & RADEON_IS_AGP) { |
| 301 | WREG32(MC_VM_SYSTEM_APERTURE_HIGH_ADDR, (rdev->mc.vram_end - 1) >> 12); | 296 | if (rdev->mc.vram_start < rdev->mc.gtt_start) { |
| 297 | /* VRAM before AGP */ | ||
| 298 | WREG32(MC_VM_SYSTEM_APERTURE_LOW_ADDR, | ||
| 299 | rdev->mc.vram_start >> 12); | ||
| 300 | WREG32(MC_VM_SYSTEM_APERTURE_HIGH_ADDR, | ||
| 301 | rdev->mc.gtt_end >> 12); | ||
| 302 | } else { | ||
| 303 | /* VRAM after AGP */ | ||
| 304 | WREG32(MC_VM_SYSTEM_APERTURE_LOW_ADDR, | ||
| 305 | rdev->mc.gtt_start >> 12); | ||
| 306 | WREG32(MC_VM_SYSTEM_APERTURE_HIGH_ADDR, | ||
| 307 | rdev->mc.vram_end >> 12); | ||
| 308 | } | ||
| 309 | } else { | ||
| 310 | WREG32(MC_VM_SYSTEM_APERTURE_LOW_ADDR, rdev->mc.vram_start >> 12); | ||
| 311 | WREG32(MC_VM_SYSTEM_APERTURE_HIGH_ADDR, rdev->mc.vram_end >> 12); | ||
| 312 | } | ||
| 302 | WREG32(MC_VM_SYSTEM_APERTURE_DEFAULT_ADDR, 0); | 313 | WREG32(MC_VM_SYSTEM_APERTURE_DEFAULT_ADDR, 0); |
| 303 | tmp = (((rdev->mc.vram_end - 1) >> 24) & 0xFFFF) << 16; | 314 | tmp = ((rdev->mc.vram_end >> 24) & 0xFFFF) << 16; |
| 304 | tmp |= ((rdev->mc.vram_start >> 24) & 0xFFFF); | 315 | tmp |= ((rdev->mc.vram_start >> 24) & 0xFFFF); |
| 305 | WREG32(MC_VM_FB_LOCATION, tmp); | 316 | WREG32(MC_VM_FB_LOCATION, tmp); |
| 306 | WREG32(HDP_NONSURFACE_BASE, (rdev->mc.vram_start >> 8)); | 317 | WREG32(HDP_NONSURFACE_BASE, (rdev->mc.vram_start >> 8)); |
| 307 | WREG32(HDP_NONSURFACE_INFO, (2 << 7)); | 318 | WREG32(HDP_NONSURFACE_INFO, (2 << 7)); |
| 308 | WREG32(HDP_NONSURFACE_SIZE, (rdev->mc.mc_vram_size - 1) | 0x3FF); | 319 | WREG32(HDP_NONSURFACE_SIZE, rdev->mc.mc_vram_size | 0x3FF); |
| 309 | if (rdev->flags & RADEON_IS_AGP) { | 320 | if (rdev->flags & RADEON_IS_AGP) { |
| 310 | WREG32(MC_VM_AGP_TOP, (rdev->mc.gtt_end - 1) >> 16); | 321 | WREG32(MC_VM_AGP_TOP, rdev->mc.gtt_end >> 22); |
| 311 | WREG32(MC_VM_AGP_BOT, rdev->mc.gtt_start >> 16); | 322 | WREG32(MC_VM_AGP_BOT, rdev->mc.gtt_start >> 22); |
| 312 | WREG32(MC_VM_AGP_BASE, rdev->mc.agp_base >> 22); | 323 | WREG32(MC_VM_AGP_BASE, rdev->mc.agp_base >> 22); |
| 313 | } else { | 324 | } else { |
| 314 | WREG32(MC_VM_AGP_BASE, 0); | 325 | WREG32(MC_VM_AGP_BASE, 0); |
| 315 | WREG32(MC_VM_AGP_TOP, 0x0FFFFFFF); | 326 | WREG32(MC_VM_AGP_TOP, 0x0FFFFFFF); |
| 316 | WREG32(MC_VM_AGP_BOT, 0x0FFFFFFF); | 327 | WREG32(MC_VM_AGP_BOT, 0x0FFFFFFF); |
| 317 | } | 328 | } |
| 318 | WREG32(D1GRPH_PRIMARY_SURFACE_ADDRESS, new_d1grph_primary); | ||
| 319 | WREG32(D1GRPH_SECONDARY_SURFACE_ADDRESS, new_d1grph_secondary); | ||
| 320 | WREG32(D2GRPH_PRIMARY_SURFACE_ADDRESS, new_d2grph_primary); | ||
| 321 | WREG32(D2GRPH_SECONDARY_SURFACE_ADDRESS, new_d2grph_secondary); | ||
| 322 | WREG32(VGA_MEMORY_BASE_ADDRESS, rdev->mc.vram_start); | ||
| 323 | |||
| 324 | /* Unlock host access */ | ||
| 325 | WREG32(VGA_HDP_CONTROL, vga_hdp_control); | ||
| 326 | |||
| 327 | mdelay(1); | ||
| 328 | if (r600_mc_wait_for_idle(rdev)) { | 329 | if (r600_mc_wait_for_idle(rdev)) { |
| 329 | printk(KERN_WARNING "[drm] MC not idle !\n"); | 330 | dev_warn(rdev->dev, "Wait for MC idle timedout !\n"); |
| 330 | } | 331 | } |
| 331 | 332 | rv515_mc_resume(rdev, &save); | |
| 332 | /* Restore video state */ | ||
| 333 | WREG32(D1CRTC_UPDATE_LOCK, 1); | ||
| 334 | WREG32(D2CRTC_UPDATE_LOCK, 1); | ||
| 335 | WREG32(D1CRTC_CONTROL, d1crtc_control); | ||
| 336 | WREG32(D2CRTC_CONTROL, d2crtc_control); | ||
| 337 | WREG32(D1CRTC_UPDATE_LOCK, 0); | ||
| 338 | WREG32(D2CRTC_UPDATE_LOCK, 0); | ||
| 339 | WREG32(D1VGA_CONTROL, d1vga_control); | ||
| 340 | WREG32(D2VGA_CONTROL, d2vga_control); | ||
| 341 | WREG32(VGA_RENDER_CONTROL, vga_render_control); | ||
| 342 | |||
| 343 | /* we need to own VRAM, so turn off the VGA renderer here | 333 | /* we need to own VRAM, so turn off the VGA renderer here |
| 344 | * to stop it overwriting our objects */ | 334 | * to stop it overwriting our objects */ |
| 345 | rv515_vga_render_disable(rdev); | 335 | rv515_vga_render_disable(rdev); |
| @@ -445,9 +435,9 @@ int r600_mc_init(struct radeon_device *rdev) | |||
| 445 | } | 435 | } |
| 446 | } | 436 | } |
| 447 | rdev->mc.vram_start = rdev->mc.vram_location; | 437 | rdev->mc.vram_start = rdev->mc.vram_location; |
| 448 | rdev->mc.vram_end = rdev->mc.vram_location + rdev->mc.mc_vram_size; | 438 | rdev->mc.vram_end = rdev->mc.vram_location + rdev->mc.mc_vram_size - 1; |
| 449 | rdev->mc.gtt_start = rdev->mc.gtt_location; | 439 | rdev->mc.gtt_start = rdev->mc.gtt_location; |
| 450 | rdev->mc.gtt_end = rdev->mc.gtt_location + rdev->mc.gtt_size; | 440 | rdev->mc.gtt_end = rdev->mc.gtt_location + rdev->mc.gtt_size - 1; |
| 451 | /* FIXME: we should enforce default clock in case GPU is not in | 441 | /* FIXME: we should enforce default clock in case GPU is not in |
| 452 | * default setup | 442 | * default setup |
| 453 | */ | 443 | */ |
| @@ -463,6 +453,7 @@ int r600_mc_init(struct radeon_device *rdev) | |||
| 463 | */ | 453 | */ |
| 464 | int r600_gpu_soft_reset(struct radeon_device *rdev) | 454 | int r600_gpu_soft_reset(struct radeon_device *rdev) |
| 465 | { | 455 | { |
| 456 | struct rv515_mc_save save; | ||
| 466 | u32 grbm_busy_mask = S_008010_VC_BUSY(1) | S_008010_VGT_BUSY_NO_DMA(1) | | 457 | u32 grbm_busy_mask = S_008010_VC_BUSY(1) | S_008010_VGT_BUSY_NO_DMA(1) | |
| 467 | S_008010_VGT_BUSY(1) | S_008010_TA03_BUSY(1) | | 458 | S_008010_VGT_BUSY(1) | S_008010_TA03_BUSY(1) | |
| 468 | S_008010_TC_BUSY(1) | S_008010_SX_BUSY(1) | | 459 | S_008010_TC_BUSY(1) | S_008010_SX_BUSY(1) | |
| @@ -480,13 +471,25 @@ int r600_gpu_soft_reset(struct radeon_device *rdev) | |||
| 480 | S_008014_CB0_BUSY(1) | S_008014_CB1_BUSY(1) | | 471 | S_008014_CB0_BUSY(1) | S_008014_CB1_BUSY(1) | |
| 481 | S_008014_CB2_BUSY(1) | S_008014_CB3_BUSY(1); | 472 | S_008014_CB2_BUSY(1) | S_008014_CB3_BUSY(1); |
| 482 | u32 srbm_reset = 0; | 473 | u32 srbm_reset = 0; |
| 474 | u32 tmp; | ||
| 483 | 475 | ||
| 476 | dev_info(rdev->dev, "GPU softreset \n"); | ||
| 477 | dev_info(rdev->dev, " R_008010_GRBM_STATUS=0x%08X\n", | ||
| 478 | RREG32(R_008010_GRBM_STATUS)); | ||
| 479 | dev_info(rdev->dev, " R_008014_GRBM_STATUS2=0x%08X\n", | ||
| 480 | RREG32(R_008014_GRBM_STATUS2)); | ||
| 481 | dev_info(rdev->dev, " R_000E50_SRBM_STATUS=0x%08X\n", | ||
| 482 | RREG32(R_000E50_SRBM_STATUS)); | ||
| 483 | rv515_mc_stop(rdev, &save); | ||
| 484 | if (r600_mc_wait_for_idle(rdev)) { | ||
| 485 | dev_warn(rdev->dev, "Wait for MC idle timedout !\n"); | ||
| 486 | } | ||
| 484 | /* Disable CP parsing/prefetching */ | 487 | /* Disable CP parsing/prefetching */ |
| 485 | WREG32(R_0086D8_CP_ME_CNTL, S_0086D8_CP_ME_HALT(0xff)); | 488 | WREG32(R_0086D8_CP_ME_CNTL, S_0086D8_CP_ME_HALT(0xff)); |
| 486 | /* Check if any of the rendering block is busy and reset it */ | 489 | /* Check if any of the rendering block is busy and reset it */ |
| 487 | if ((RREG32(R_008010_GRBM_STATUS) & grbm_busy_mask) || | 490 | if ((RREG32(R_008010_GRBM_STATUS) & grbm_busy_mask) || |
| 488 | (RREG32(R_008014_GRBM_STATUS2) & grbm2_busy_mask)) { | 491 | (RREG32(R_008014_GRBM_STATUS2) & grbm2_busy_mask)) { |
| 489 | WREG32(R_008020_GRBM_SOFT_RESET, S_008020_SOFT_RESET_CR(1) | | 492 | tmp = S_008020_SOFT_RESET_CR(1) | |
| 490 | S_008020_SOFT_RESET_DB(1) | | 493 | S_008020_SOFT_RESET_DB(1) | |
| 491 | S_008020_SOFT_RESET_CB(1) | | 494 | S_008020_SOFT_RESET_CB(1) | |
| 492 | S_008020_SOFT_RESET_PA(1) | | 495 | S_008020_SOFT_RESET_PA(1) | |
| @@ -498,14 +501,18 @@ int r600_gpu_soft_reset(struct radeon_device *rdev) | |||
| 498 | S_008020_SOFT_RESET_TC(1) | | 501 | S_008020_SOFT_RESET_TC(1) | |
| 499 | S_008020_SOFT_RESET_TA(1) | | 502 | S_008020_SOFT_RESET_TA(1) | |
| 500 | S_008020_SOFT_RESET_VC(1) | | 503 | S_008020_SOFT_RESET_VC(1) | |
| 501 | S_008020_SOFT_RESET_VGT(1)); | 504 | S_008020_SOFT_RESET_VGT(1); |
| 505 | dev_info(rdev->dev, " R_008020_GRBM_SOFT_RESET=0x%08X\n", tmp); | ||
| 506 | WREG32(R_008020_GRBM_SOFT_RESET, tmp); | ||
| 502 | (void)RREG32(R_008020_GRBM_SOFT_RESET); | 507 | (void)RREG32(R_008020_GRBM_SOFT_RESET); |
| 503 | udelay(50); | 508 | udelay(50); |
| 504 | WREG32(R_008020_GRBM_SOFT_RESET, 0); | 509 | WREG32(R_008020_GRBM_SOFT_RESET, 0); |
| 505 | (void)RREG32(R_008020_GRBM_SOFT_RESET); | 510 | (void)RREG32(R_008020_GRBM_SOFT_RESET); |
| 506 | } | 511 | } |
| 507 | /* Reset CP (we always reset CP) */ | 512 | /* Reset CP (we always reset CP) */ |
| 508 | WREG32(R_008020_GRBM_SOFT_RESET, S_008020_SOFT_RESET_CP(1)); | 513 | tmp = S_008020_SOFT_RESET_CP(1); |
| 514 | dev_info(rdev->dev, "R_008020_GRBM_SOFT_RESET=0x%08X\n", tmp); | ||
| 515 | WREG32(R_008020_GRBM_SOFT_RESET, tmp); | ||
| 509 | (void)RREG32(R_008020_GRBM_SOFT_RESET); | 516 | (void)RREG32(R_008020_GRBM_SOFT_RESET); |
| 510 | udelay(50); | 517 | udelay(50); |
| 511 | WREG32(R_008020_GRBM_SOFT_RESET, 0); | 518 | WREG32(R_008020_GRBM_SOFT_RESET, 0); |
| @@ -533,6 +540,14 @@ int r600_gpu_soft_reset(struct radeon_device *rdev) | |||
| 533 | srbm_reset |= S_000E60_SOFT_RESET_RLC(1); | 540 | srbm_reset |= S_000E60_SOFT_RESET_RLC(1); |
| 534 | if (G_000E50_SEM_BUSY(RREG32(R_000E50_SRBM_STATUS))) | 541 | if (G_000E50_SEM_BUSY(RREG32(R_000E50_SRBM_STATUS))) |
| 535 | srbm_reset |= S_000E60_SOFT_RESET_SEM(1); | 542 | srbm_reset |= S_000E60_SOFT_RESET_SEM(1); |
| 543 | if (G_000E50_BIF_BUSY(RREG32(R_000E50_SRBM_STATUS))) | ||
| 544 | srbm_reset |= S_000E60_SOFT_RESET_BIF(1); | ||
| 545 | dev_info(rdev->dev, " R_000E60_SRBM_SOFT_RESET=0x%08X\n", srbm_reset); | ||
| 546 | WREG32(R_000E60_SRBM_SOFT_RESET, srbm_reset); | ||
| 547 | (void)RREG32(R_000E60_SRBM_SOFT_RESET); | ||
| 548 | udelay(50); | ||
| 549 | WREG32(R_000E60_SRBM_SOFT_RESET, 0); | ||
| 550 | (void)RREG32(R_000E60_SRBM_SOFT_RESET); | ||
| 536 | WREG32(R_000E60_SRBM_SOFT_RESET, srbm_reset); | 551 | WREG32(R_000E60_SRBM_SOFT_RESET, srbm_reset); |
| 537 | (void)RREG32(R_000E60_SRBM_SOFT_RESET); | 552 | (void)RREG32(R_000E60_SRBM_SOFT_RESET); |
| 538 | udelay(50); | 553 | udelay(50); |
| @@ -540,6 +555,17 @@ int r600_gpu_soft_reset(struct radeon_device *rdev) | |||
| 540 | (void)RREG32(R_000E60_SRBM_SOFT_RESET); | 555 | (void)RREG32(R_000E60_SRBM_SOFT_RESET); |
| 541 | /* Wait a little for things to settle down */ | 556 | /* Wait a little for things to settle down */ |
| 542 | udelay(50); | 557 | udelay(50); |
| 558 | dev_info(rdev->dev, " R_008010_GRBM_STATUS=0x%08X\n", | ||
| 559 | RREG32(R_008010_GRBM_STATUS)); | ||
| 560 | dev_info(rdev->dev, " R_008014_GRBM_STATUS2=0x%08X\n", | ||
| 561 | RREG32(R_008014_GRBM_STATUS2)); | ||
| 562 | dev_info(rdev->dev, " R_000E50_SRBM_STATUS=0x%08X\n", | ||
| 563 | RREG32(R_000E50_SRBM_STATUS)); | ||
| 564 | /* After reset we need to reinit the asic as GPU often endup in an | ||
| 565 | * incoherent state. | ||
| 566 | */ | ||
| 567 | atom_asic_init(rdev->mode_info.atom_context); | ||
| 568 | rv515_mc_resume(rdev, &save); | ||
| 543 | return 0; | 569 | return 0; |
| 544 | } | 570 | } |
| 545 | 571 | ||
| @@ -1350,32 +1376,47 @@ int r600_ring_test(struct radeon_device *rdev) | |||
| 1350 | return r; | 1376 | return r; |
| 1351 | } | 1377 | } |
| 1352 | 1378 | ||
| 1353 | /* | 1379 | void r600_wb_disable(struct radeon_device *rdev) |
| 1354 | * Writeback | 1380 | { |
| 1355 | */ | 1381 | WREG32(SCRATCH_UMSK, 0); |
| 1356 | int r600_wb_init(struct radeon_device *rdev) | 1382 | if (rdev->wb.wb_obj) { |
| 1383 | radeon_object_kunmap(rdev->wb.wb_obj); | ||
| 1384 | radeon_object_unpin(rdev->wb.wb_obj); | ||
| 1385 | } | ||
| 1386 | } | ||
| 1387 | |||
| 1388 | void r600_wb_fini(struct radeon_device *rdev) | ||
| 1389 | { | ||
| 1390 | r600_wb_disable(rdev); | ||
| 1391 | if (rdev->wb.wb_obj) { | ||
| 1392 | radeon_object_unref(&rdev->wb.wb_obj); | ||
| 1393 | rdev->wb.wb = NULL; | ||
| 1394 | rdev->wb.wb_obj = NULL; | ||
| 1395 | } | ||
| 1396 | } | ||
| 1397 | |||
| 1398 | int r600_wb_enable(struct radeon_device *rdev) | ||
| 1357 | { | 1399 | { |
| 1358 | int r; | 1400 | int r; |
| 1359 | 1401 | ||
| 1360 | if (rdev->wb.wb_obj == NULL) { | 1402 | if (rdev->wb.wb_obj == NULL) { |
| 1361 | r = radeon_object_create(rdev, NULL, 4096, | 1403 | r = radeon_object_create(rdev, NULL, 4096, true, |
| 1362 | true, | 1404 | RADEON_GEM_DOMAIN_GTT, false, &rdev->wb.wb_obj); |
| 1363 | RADEON_GEM_DOMAIN_GTT, | ||
| 1364 | false, &rdev->wb.wb_obj); | ||
| 1365 | if (r) { | 1405 | if (r) { |
| 1366 | DRM_ERROR("radeon: failed to create WB buffer (%d).\n", r); | 1406 | dev_warn(rdev->dev, "failed to create WB buffer (%d).\n", r); |
| 1367 | return r; | 1407 | return r; |
| 1368 | } | 1408 | } |
| 1369 | r = radeon_object_pin(rdev->wb.wb_obj, | 1409 | r = radeon_object_pin(rdev->wb.wb_obj, RADEON_GEM_DOMAIN_GTT, |
| 1370 | RADEON_GEM_DOMAIN_GTT, | 1410 | &rdev->wb.gpu_addr); |
| 1371 | &rdev->wb.gpu_addr); | ||
| 1372 | if (r) { | 1411 | if (r) { |
| 1373 | DRM_ERROR("radeon: failed to pin WB buffer (%d).\n", r); | 1412 | dev_warn(rdev->dev, "failed to pin WB buffer (%d).\n", r); |
| 1413 | r600_wb_fini(rdev); | ||
| 1374 | return r; | 1414 | return r; |
| 1375 | } | 1415 | } |
| 1376 | r = radeon_object_kmap(rdev->wb.wb_obj, (void **)&rdev->wb.wb); | 1416 | r = radeon_object_kmap(rdev->wb.wb_obj, (void **)&rdev->wb.wb); |
| 1377 | if (r) { | 1417 | if (r) { |
| 1378 | DRM_ERROR("radeon: failed to map WB buffer (%d).\n", r); | 1418 | dev_warn(rdev->dev, "failed to map WB buffer (%d).\n", r); |
| 1419 | r600_wb_fini(rdev); | ||
| 1379 | return r; | 1420 | return r; |
| 1380 | } | 1421 | } |
| 1381 | } | 1422 | } |
| @@ -1386,21 +1427,6 @@ int r600_wb_init(struct radeon_device *rdev) | |||
| 1386 | return 0; | 1427 | return 0; |
| 1387 | } | 1428 | } |
| 1388 | 1429 | ||
| 1389 | void r600_wb_fini(struct radeon_device *rdev) | ||
| 1390 | { | ||
| 1391 | if (rdev->wb.wb_obj) { | ||
| 1392 | radeon_object_kunmap(rdev->wb.wb_obj); | ||
| 1393 | radeon_object_unpin(rdev->wb.wb_obj); | ||
| 1394 | radeon_object_unref(&rdev->wb.wb_obj); | ||
| 1395 | rdev->wb.wb = NULL; | ||
| 1396 | rdev->wb.wb_obj = NULL; | ||
| 1397 | } | ||
| 1398 | } | ||
| 1399 | |||
| 1400 | |||
| 1401 | /* | ||
| 1402 | * CS | ||
| 1403 | */ | ||
| 1404 | void r600_fence_ring_emit(struct radeon_device *rdev, | 1430 | void r600_fence_ring_emit(struct radeon_device *rdev, |
| 1405 | struct radeon_fence *fence) | 1431 | struct radeon_fence *fence) |
| 1406 | { | 1432 | { |
| @@ -1477,11 +1503,14 @@ int r600_startup(struct radeon_device *rdev) | |||
| 1477 | { | 1503 | { |
| 1478 | int r; | 1504 | int r; |
| 1479 | 1505 | ||
| 1480 | r600_gpu_reset(rdev); | 1506 | r600_mc_program(rdev); |
| 1481 | r600_mc_resume(rdev); | 1507 | if (rdev->flags & RADEON_IS_AGP) { |
| 1482 | r = r600_pcie_gart_enable(rdev); | 1508 | r600_agp_enable(rdev); |
| 1483 | if (r) | 1509 | } else { |
| 1484 | return r; | 1510 | r = r600_pcie_gart_enable(rdev); |
| 1511 | if (r) | ||
| 1512 | return r; | ||
| 1513 | } | ||
| 1485 | r600_gpu_init(rdev); | 1514 | r600_gpu_init(rdev); |
| 1486 | 1515 | ||
| 1487 | r = radeon_object_pin(rdev->r600_blit.shader_obj, RADEON_GEM_DOMAIN_VRAM, | 1516 | r = radeon_object_pin(rdev->r600_blit.shader_obj, RADEON_GEM_DOMAIN_VRAM, |
| @@ -1500,9 +1529,8 @@ int r600_startup(struct radeon_device *rdev) | |||
| 1500 | r = r600_cp_resume(rdev); | 1529 | r = r600_cp_resume(rdev); |
| 1501 | if (r) | 1530 | if (r) |
| 1502 | return r; | 1531 | return r; |
| 1503 | r = r600_wb_init(rdev); | 1532 | /* write back buffer are not vital so don't worry about failure */ |
| 1504 | if (r) | 1533 | r600_wb_enable(rdev); |
| 1505 | return r; | ||
| 1506 | return 0; | 1534 | return 0; |
| 1507 | } | 1535 | } |
| 1508 | 1536 | ||
| @@ -1524,15 +1552,12 @@ int r600_resume(struct radeon_device *rdev) | |||
| 1524 | { | 1552 | { |
| 1525 | int r; | 1553 | int r; |
| 1526 | 1554 | ||
| 1527 | if (radeon_gpu_reset(rdev)) { | 1555 | /* Do not reset GPU before posting, on r600 hw unlike on r500 hw, |
| 1528 | /* FIXME: what do we want to do here ? */ | 1556 | * posting will perform necessary task to bring back GPU into good |
| 1529 | } | 1557 | * shape. |
| 1558 | */ | ||
| 1530 | /* post card */ | 1559 | /* post card */ |
| 1531 | if (rdev->is_atom_bios) { | 1560 | atom_asic_init(rdev->mode_info.atom_context); |
| 1532 | atom_asic_init(rdev->mode_info.atom_context); | ||
| 1533 | } else { | ||
| 1534 | radeon_combios_asic_init(rdev->ddev); | ||
| 1535 | } | ||
| 1536 | /* Initialize clocks */ | 1561 | /* Initialize clocks */ |
| 1537 | r = radeon_clocks_init(rdev); | 1562 | r = radeon_clocks_init(rdev); |
| 1538 | if (r) { | 1563 | if (r) { |
| @@ -1545,7 +1570,7 @@ int r600_resume(struct radeon_device *rdev) | |||
| 1545 | return r; | 1570 | return r; |
| 1546 | } | 1571 | } |
| 1547 | 1572 | ||
| 1548 | r = radeon_ib_test(rdev); | 1573 | r = r600_ib_test(rdev); |
| 1549 | if (r) { | 1574 | if (r) { |
| 1550 | DRM_ERROR("radeon: failled testing IB (%d).\n", r); | 1575 | DRM_ERROR("radeon: failled testing IB (%d).\n", r); |
| 1551 | return r; | 1576 | return r; |
| @@ -1553,13 +1578,12 @@ int r600_resume(struct radeon_device *rdev) | |||
| 1553 | return r; | 1578 | return r; |
| 1554 | } | 1579 | } |
| 1555 | 1580 | ||
| 1556 | |||
| 1557 | int r600_suspend(struct radeon_device *rdev) | 1581 | int r600_suspend(struct radeon_device *rdev) |
| 1558 | { | 1582 | { |
| 1559 | /* FIXME: we should wait for ring to be empty */ | 1583 | /* FIXME: we should wait for ring to be empty */ |
| 1560 | r600_cp_stop(rdev); | 1584 | r600_cp_stop(rdev); |
| 1561 | rdev->cp.ready = false; | 1585 | rdev->cp.ready = false; |
| 1562 | 1586 | r600_wb_disable(rdev); | |
| 1563 | r600_pcie_gart_disable(rdev); | 1587 | r600_pcie_gart_disable(rdev); |
| 1564 | /* unpin shaders bo */ | 1588 | /* unpin shaders bo */ |
| 1565 | radeon_object_unpin(rdev->r600_blit.shader_obj); | 1589 | radeon_object_unpin(rdev->r600_blit.shader_obj); |
| @@ -1576,7 +1600,6 @@ int r600_init(struct radeon_device *rdev) | |||
| 1576 | { | 1600 | { |
| 1577 | int r; | 1601 | int r; |
| 1578 | 1602 | ||
| 1579 | rdev->new_init_path = true; | ||
| 1580 | r = radeon_dummy_page_init(rdev); | 1603 | r = radeon_dummy_page_init(rdev); |
| 1581 | if (r) | 1604 | if (r) |
| 1582 | return r; | 1605 | return r; |
| @@ -1593,8 +1616,10 @@ int r600_init(struct radeon_device *rdev) | |||
| 1593 | return -EINVAL; | 1616 | return -EINVAL; |
| 1594 | } | 1617 | } |
| 1595 | /* Must be an ATOMBIOS */ | 1618 | /* Must be an ATOMBIOS */ |
| 1596 | if (!rdev->is_atom_bios) | 1619 | if (!rdev->is_atom_bios) { |
| 1620 | dev_err(rdev->dev, "Expecting atombios for R600 GPU\n"); | ||
| 1597 | return -EINVAL; | 1621 | return -EINVAL; |
| 1622 | } | ||
| 1598 | r = radeon_atombios_init(rdev); | 1623 | r = radeon_atombios_init(rdev); |
| 1599 | if (r) | 1624 | if (r) |
| 1600 | return r; | 1625 | return r; |
| @@ -1616,15 +1641,8 @@ int r600_init(struct radeon_device *rdev) | |||
| 1616 | if (r) | 1641 | if (r) |
| 1617 | return r; | 1642 | return r; |
| 1618 | r = r600_mc_init(rdev); | 1643 | r = r600_mc_init(rdev); |
| 1619 | if (r) { | 1644 | if (r) |
| 1620 | if (rdev->flags & RADEON_IS_AGP) { | ||
| 1621 | /* Retry with disabling AGP */ | ||
| 1622 | r600_fini(rdev); | ||
| 1623 | rdev->flags &= ~RADEON_IS_AGP; | ||
| 1624 | return r600_init(rdev); | ||
| 1625 | } | ||
| 1626 | return r; | 1645 | return r; |
| 1627 | } | ||
| 1628 | /* Memory manager */ | 1646 | /* Memory manager */ |
| 1629 | r = radeon_object_init(rdev); | 1647 | r = radeon_object_init(rdev); |
| 1630 | if (r) | 1648 | if (r) |
| @@ -1653,12 +1671,10 @@ int r600_init(struct radeon_device *rdev) | |||
| 1653 | 1671 | ||
| 1654 | r = r600_startup(rdev); | 1672 | r = r600_startup(rdev); |
| 1655 | if (r) { | 1673 | if (r) { |
| 1656 | if (rdev->flags & RADEON_IS_AGP) { | 1674 | r600_suspend(rdev); |
| 1657 | /* Retry with disabling AGP */ | 1675 | r600_wb_fini(rdev); |
| 1658 | r600_fini(rdev); | 1676 | radeon_ring_fini(rdev); |
| 1659 | rdev->flags &= ~RADEON_IS_AGP; | 1677 | r600_pcie_gart_fini(rdev); |
| 1660 | return r600_init(rdev); | ||
| 1661 | } | ||
| 1662 | rdev->accel_working = false; | 1678 | rdev->accel_working = false; |
| 1663 | } | 1679 | } |
| 1664 | if (rdev->accel_working) { | 1680 | if (rdev->accel_working) { |
| @@ -1667,7 +1683,7 @@ int r600_init(struct radeon_device *rdev) | |||
| 1667 | DRM_ERROR("radeon: failled initializing IB pool (%d).\n", r); | 1683 | DRM_ERROR("radeon: failled initializing IB pool (%d).\n", r); |
| 1668 | rdev->accel_working = false; | 1684 | rdev->accel_working = false; |
| 1669 | } | 1685 | } |
| 1670 | r = radeon_ib_test(rdev); | 1686 | r = r600_ib_test(rdev); |
| 1671 | if (r) { | 1687 | if (r) { |
| 1672 | DRM_ERROR("radeon: failled testing IB (%d).\n", r); | 1688 | DRM_ERROR("radeon: failled testing IB (%d).\n", r); |
| 1673 | rdev->accel_working = false; | 1689 | rdev->accel_working = false; |
| @@ -1683,19 +1699,15 @@ void r600_fini(struct radeon_device *rdev) | |||
| 1683 | 1699 | ||
| 1684 | r600_blit_fini(rdev); | 1700 | r600_blit_fini(rdev); |
| 1685 | radeon_ring_fini(rdev); | 1701 | radeon_ring_fini(rdev); |
| 1702 | r600_wb_fini(rdev); | ||
| 1686 | r600_pcie_gart_fini(rdev); | 1703 | r600_pcie_gart_fini(rdev); |
| 1687 | radeon_gem_fini(rdev); | 1704 | radeon_gem_fini(rdev); |
| 1688 | radeon_fence_driver_fini(rdev); | 1705 | radeon_fence_driver_fini(rdev); |
| 1689 | radeon_clocks_fini(rdev); | 1706 | radeon_clocks_fini(rdev); |
| 1690 | #if __OS_HAS_AGP | ||
| 1691 | if (rdev->flags & RADEON_IS_AGP) | 1707 | if (rdev->flags & RADEON_IS_AGP) |
| 1692 | radeon_agp_fini(rdev); | 1708 | radeon_agp_fini(rdev); |
| 1693 | #endif | ||
| 1694 | radeon_object_fini(rdev); | 1709 | radeon_object_fini(rdev); |
| 1695 | if (rdev->is_atom_bios) | 1710 | radeon_atombios_fini(rdev); |
| 1696 | radeon_atombios_fini(rdev); | ||
| 1697 | else | ||
| 1698 | radeon_combios_fini(rdev); | ||
| 1699 | kfree(rdev->bios); | 1711 | kfree(rdev->bios); |
| 1700 | rdev->bios = NULL; | 1712 | rdev->bios = NULL; |
| 1701 | radeon_dummy_page_fini(rdev); | 1713 | radeon_dummy_page_fini(rdev); |
diff --git a/drivers/gpu/drm/radeon/r600_blit.c b/drivers/gpu/drm/radeon/r600_blit.c index d988eece0187..dec501081608 100644 --- a/drivers/gpu/drm/radeon/r600_blit.c +++ b/drivers/gpu/drm/radeon/r600_blit.c | |||
| @@ -582,8 +582,6 @@ r600_blit_copy(struct drm_device *dev, | |||
| 582 | u64 vb_addr; | 582 | u64 vb_addr; |
| 583 | u32 *vb; | 583 | u32 *vb; |
| 584 | 584 | ||
| 585 | vb = r600_nomm_get_vb_ptr(dev); | ||
| 586 | |||
| 587 | if ((size_bytes & 3) || (src_gpu_addr & 3) || (dst_gpu_addr & 3)) { | 585 | if ((size_bytes & 3) || (src_gpu_addr & 3) || (dst_gpu_addr & 3)) { |
| 588 | max_bytes = 8192; | 586 | max_bytes = 8192; |
| 589 | 587 | ||
| @@ -619,8 +617,8 @@ r600_blit_copy(struct drm_device *dev, | |||
| 619 | if (!dev_priv->blit_vb) | 617 | if (!dev_priv->blit_vb) |
| 620 | return; | 618 | return; |
| 621 | set_shaders(dev); | 619 | set_shaders(dev); |
| 622 | vb = r600_nomm_get_vb_ptr(dev); | ||
| 623 | } | 620 | } |
| 621 | vb = r600_nomm_get_vb_ptr(dev); | ||
| 624 | 622 | ||
| 625 | vb[0] = i2f(dst_x); | 623 | vb[0] = i2f(dst_x); |
| 626 | vb[1] = 0; | 624 | vb[1] = 0; |
| @@ -708,8 +706,8 @@ r600_blit_copy(struct drm_device *dev, | |||
| 708 | return; | 706 | return; |
| 709 | 707 | ||
| 710 | set_shaders(dev); | 708 | set_shaders(dev); |
| 711 | vb = r600_nomm_get_vb_ptr(dev); | ||
| 712 | } | 709 | } |
| 710 | vb = r600_nomm_get_vb_ptr(dev); | ||
| 713 | 711 | ||
| 714 | vb[0] = i2f(dst_x / 4); | 712 | vb[0] = i2f(dst_x / 4); |
| 715 | vb[1] = 0; | 713 | vb[1] = 0; |
| @@ -777,8 +775,6 @@ r600_blit_swap(struct drm_device *dev, | |||
| 777 | u64 vb_addr; | 775 | u64 vb_addr; |
| 778 | u32 *vb; | 776 | u32 *vb; |
| 779 | 777 | ||
| 780 | vb = r600_nomm_get_vb_ptr(dev); | ||
| 781 | |||
| 782 | if ((dev_priv->blit_vb->used + 48) > dev_priv->blit_vb->total) { | 778 | if ((dev_priv->blit_vb->used + 48) > dev_priv->blit_vb->total) { |
| 783 | 779 | ||
| 784 | r600_nomm_put_vb(dev); | 780 | r600_nomm_put_vb(dev); |
| @@ -787,8 +783,8 @@ r600_blit_swap(struct drm_device *dev, | |||
| 787 | return; | 783 | return; |
| 788 | 784 | ||
| 789 | set_shaders(dev); | 785 | set_shaders(dev); |
| 790 | vb = r600_nomm_get_vb_ptr(dev); | ||
| 791 | } | 786 | } |
| 787 | vb = r600_nomm_get_vb_ptr(dev); | ||
| 792 | 788 | ||
| 793 | if (cpp == 4) { | 789 | if (cpp == 4) { |
| 794 | cb_format = COLOR_8_8_8_8; | 790 | cb_format = COLOR_8_8_8_8; |
diff --git a/drivers/gpu/drm/radeon/r600_blit_kms.c b/drivers/gpu/drm/radeon/r600_blit_kms.c index acae33e2ad51..93108bb31d1d 100644 --- a/drivers/gpu/drm/radeon/r600_blit_kms.c +++ b/drivers/gpu/drm/radeon/r600_blit_kms.c | |||
| @@ -610,7 +610,6 @@ void r600_kms_blit_copy(struct radeon_device *rdev, | |||
| 610 | 610 | ||
| 611 | DRM_DEBUG("emitting copy %16llx %16llx %d %d\n", src_gpu_addr, dst_gpu_addr, | 611 | DRM_DEBUG("emitting copy %16llx %16llx %d %d\n", src_gpu_addr, dst_gpu_addr, |
| 612 | size_bytes, rdev->r600_blit.vb_used); | 612 | size_bytes, rdev->r600_blit.vb_used); |
| 613 | vb = (u32 *)(rdev->r600_blit.vb_ib->ptr + rdev->r600_blit.vb_used); | ||
| 614 | if ((size_bytes & 3) || (src_gpu_addr & 3) || (dst_gpu_addr & 3)) { | 613 | if ((size_bytes & 3) || (src_gpu_addr & 3) || (dst_gpu_addr & 3)) { |
| 615 | max_bytes = 8192; | 614 | max_bytes = 8192; |
| 616 | 615 | ||
| @@ -653,6 +652,7 @@ void r600_kms_blit_copy(struct radeon_device *rdev, | |||
| 653 | vb = r600_nomm_get_vb_ptr(dev); | 652 | vb = r600_nomm_get_vb_ptr(dev); |
| 654 | #endif | 653 | #endif |
| 655 | } | 654 | } |
| 655 | vb = (u32 *)(rdev->r600_blit.vb_ib->ptr + rdev->r600_blit.vb_used); | ||
| 656 | 656 | ||
| 657 | vb[0] = i2f(dst_x); | 657 | vb[0] = i2f(dst_x); |
| 658 | vb[1] = 0; | 658 | vb[1] = 0; |
| @@ -747,6 +747,7 @@ void r600_kms_blit_copy(struct radeon_device *rdev, | |||
| 747 | vb = r600_nomm_get_vb_ptr(dev); | 747 | vb = r600_nomm_get_vb_ptr(dev); |
| 748 | } | 748 | } |
| 749 | #endif | 749 | #endif |
| 750 | vb = (u32 *)(rdev->r600_blit.vb_ib->ptr + rdev->r600_blit.vb_used); | ||
| 750 | 751 | ||
| 751 | vb[0] = i2f(dst_x / 4); | 752 | vb[0] = i2f(dst_x / 4); |
| 752 | vb[1] = 0; | 753 | vb[1] = 0; |
diff --git a/drivers/gpu/drm/radeon/r600_cs.c b/drivers/gpu/drm/radeon/r600_cs.c index d28970db6a2d..17e42195c632 100644 --- a/drivers/gpu/drm/radeon/r600_cs.c +++ b/drivers/gpu/drm/radeon/r600_cs.c | |||
| @@ -252,7 +252,7 @@ static int r600_cs_packet_parse_vline(struct radeon_cs_parser *p) | |||
| 252 | 252 | ||
| 253 | header = radeon_get_ib_value(p, h_idx); | 253 | header = radeon_get_ib_value(p, h_idx); |
| 254 | crtc_id = radeon_get_ib_value(p, h_idx + 2 + 7 + 1); | 254 | crtc_id = radeon_get_ib_value(p, h_idx + 2 + 7 + 1); |
| 255 | reg = header >> 2; | 255 | reg = CP_PACKET0_GET_REG(header); |
| 256 | mutex_lock(&p->rdev->ddev->mode_config.mutex); | 256 | mutex_lock(&p->rdev->ddev->mode_config.mutex); |
| 257 | obj = drm_mode_object_find(p->rdev->ddev, crtc_id, DRM_MODE_OBJECT_CRTC); | 257 | obj = drm_mode_object_find(p->rdev->ddev, crtc_id, DRM_MODE_OBJECT_CRTC); |
| 258 | if (!obj) { | 258 | if (!obj) { |
diff --git a/drivers/gpu/drm/radeon/r600d.h b/drivers/gpu/drm/radeon/r600d.h index 4a9028a85c9b..9b64d47f1f82 100644 --- a/drivers/gpu/drm/radeon/r600d.h +++ b/drivers/gpu/drm/radeon/r600d.h | |||
| @@ -643,6 +643,7 @@ | |||
| 643 | #define G_000E50_MCDW_BUSY(x) (((x) >> 13) & 1) | 643 | #define G_000E50_MCDW_BUSY(x) (((x) >> 13) & 1) |
| 644 | #define G_000E50_SEM_BUSY(x) (((x) >> 14) & 1) | 644 | #define G_000E50_SEM_BUSY(x) (((x) >> 14) & 1) |
| 645 | #define G_000E50_RLC_BUSY(x) (((x) >> 15) & 1) | 645 | #define G_000E50_RLC_BUSY(x) (((x) >> 15) & 1) |
| 646 | #define G_000E50_BIF_BUSY(x) (((x) >> 29) & 1) | ||
| 646 | #define R_000E60_SRBM_SOFT_RESET 0x0E60 | 647 | #define R_000E60_SRBM_SOFT_RESET 0x0E60 |
| 647 | #define S_000E60_SOFT_RESET_BIF(x) (((x) & 1) << 1) | 648 | #define S_000E60_SOFT_RESET_BIF(x) (((x) & 1) << 1) |
| 648 | #define S_000E60_SOFT_RESET_CG(x) (((x) & 1) << 2) | 649 | #define S_000E60_SOFT_RESET_CG(x) (((x) & 1) << 2) |
diff --git a/drivers/gpu/drm/radeon/radeon.h b/drivers/gpu/drm/radeon/radeon.h index 950b346e343f..5ab35b81c86b 100644 --- a/drivers/gpu/drm/radeon/radeon.h +++ b/drivers/gpu/drm/radeon/radeon.h | |||
| @@ -590,18 +590,8 @@ struct radeon_asic { | |||
| 590 | void (*fini)(struct radeon_device *rdev); | 590 | void (*fini)(struct radeon_device *rdev); |
| 591 | int (*resume)(struct radeon_device *rdev); | 591 | int (*resume)(struct radeon_device *rdev); |
| 592 | int (*suspend)(struct radeon_device *rdev); | 592 | int (*suspend)(struct radeon_device *rdev); |
| 593 | void (*errata)(struct radeon_device *rdev); | ||
| 594 | void (*vram_info)(struct radeon_device *rdev); | ||
| 595 | void (*vga_set_state)(struct radeon_device *rdev, bool state); | 593 | void (*vga_set_state)(struct radeon_device *rdev, bool state); |
| 596 | int (*gpu_reset)(struct radeon_device *rdev); | 594 | int (*gpu_reset)(struct radeon_device *rdev); |
| 597 | int (*mc_init)(struct radeon_device *rdev); | ||
| 598 | void (*mc_fini)(struct radeon_device *rdev); | ||
| 599 | int (*wb_init)(struct radeon_device *rdev); | ||
| 600 | void (*wb_fini)(struct radeon_device *rdev); | ||
| 601 | int (*gart_init)(struct radeon_device *rdev); | ||
| 602 | void (*gart_fini)(struct radeon_device *rdev); | ||
| 603 | int (*gart_enable)(struct radeon_device *rdev); | ||
| 604 | void (*gart_disable)(struct radeon_device *rdev); | ||
| 605 | void (*gart_tlb_flush)(struct radeon_device *rdev); | 595 | void (*gart_tlb_flush)(struct radeon_device *rdev); |
| 606 | int (*gart_set_page)(struct radeon_device *rdev, int i, uint64_t addr); | 596 | int (*gart_set_page)(struct radeon_device *rdev, int i, uint64_t addr); |
| 607 | int (*cp_init)(struct radeon_device *rdev, unsigned ring_size); | 597 | int (*cp_init)(struct radeon_device *rdev, unsigned ring_size); |
| @@ -611,7 +601,6 @@ struct radeon_asic { | |||
| 611 | void (*ring_start)(struct radeon_device *rdev); | 601 | void (*ring_start)(struct radeon_device *rdev); |
| 612 | int (*ring_test)(struct radeon_device *rdev); | 602 | int (*ring_test)(struct radeon_device *rdev); |
| 613 | void (*ring_ib_execute)(struct radeon_device *rdev, struct radeon_ib *ib); | 603 | void (*ring_ib_execute)(struct radeon_device *rdev, struct radeon_ib *ib); |
| 614 | int (*ib_test)(struct radeon_device *rdev); | ||
| 615 | int (*irq_set)(struct radeon_device *rdev); | 604 | int (*irq_set)(struct radeon_device *rdev); |
| 616 | int (*irq_process)(struct radeon_device *rdev); | 605 | int (*irq_process)(struct radeon_device *rdev); |
| 617 | u32 (*get_vblank_counter)(struct radeon_device *rdev, int crtc); | 606 | u32 (*get_vblank_counter)(struct radeon_device *rdev, int crtc); |
| @@ -789,7 +778,6 @@ struct radeon_device { | |||
| 789 | bool shutdown; | 778 | bool shutdown; |
| 790 | bool suspend; | 779 | bool suspend; |
| 791 | bool need_dma32; | 780 | bool need_dma32; |
| 792 | bool new_init_path; | ||
| 793 | bool accel_working; | 781 | bool accel_working; |
| 794 | struct radeon_surface_reg surface_regs[RADEON_GEM_MAX_SURFACES]; | 782 | struct radeon_surface_reg surface_regs[RADEON_GEM_MAX_SURFACES]; |
| 795 | const struct firmware *me_fw; /* all family ME firmware */ | 783 | const struct firmware *me_fw; /* all family ME firmware */ |
| @@ -949,28 +937,14 @@ static inline void radeon_ring_write(struct radeon_device *rdev, uint32_t v) | |||
| 949 | #define radeon_resume(rdev) (rdev)->asic->resume((rdev)) | 937 | #define radeon_resume(rdev) (rdev)->asic->resume((rdev)) |
| 950 | #define radeon_suspend(rdev) (rdev)->asic->suspend((rdev)) | 938 | #define radeon_suspend(rdev) (rdev)->asic->suspend((rdev)) |
| 951 | #define radeon_cs_parse(p) rdev->asic->cs_parse((p)) | 939 | #define radeon_cs_parse(p) rdev->asic->cs_parse((p)) |
| 952 | #define radeon_errata(rdev) (rdev)->asic->errata((rdev)) | ||
| 953 | #define radeon_vram_info(rdev) (rdev)->asic->vram_info((rdev)) | ||
| 954 | #define radeon_vga_set_state(rdev, state) (rdev)->asic->vga_set_state((rdev), (state)) | 940 | #define radeon_vga_set_state(rdev, state) (rdev)->asic->vga_set_state((rdev), (state)) |
| 955 | #define radeon_gpu_reset(rdev) (rdev)->asic->gpu_reset((rdev)) | 941 | #define radeon_gpu_reset(rdev) (rdev)->asic->gpu_reset((rdev)) |
| 956 | #define radeon_mc_init(rdev) (rdev)->asic->mc_init((rdev)) | ||
| 957 | #define radeon_mc_fini(rdev) (rdev)->asic->mc_fini((rdev)) | ||
| 958 | #define radeon_wb_init(rdev) (rdev)->asic->wb_init((rdev)) | ||
| 959 | #define radeon_wb_fini(rdev) (rdev)->asic->wb_fini((rdev)) | ||
| 960 | #define radeon_gpu_gart_init(rdev) (rdev)->asic->gart_init((rdev)) | ||
| 961 | #define radeon_gpu_gart_fini(rdev) (rdev)->asic->gart_fini((rdev)) | ||
| 962 | #define radeon_gart_enable(rdev) (rdev)->asic->gart_enable((rdev)) | ||
| 963 | #define radeon_gart_disable(rdev) (rdev)->asic->gart_disable((rdev)) | ||
| 964 | #define radeon_gart_tlb_flush(rdev) (rdev)->asic->gart_tlb_flush((rdev)) | 942 | #define radeon_gart_tlb_flush(rdev) (rdev)->asic->gart_tlb_flush((rdev)) |
| 965 | #define radeon_gart_set_page(rdev, i, p) (rdev)->asic->gart_set_page((rdev), (i), (p)) | 943 | #define radeon_gart_set_page(rdev, i, p) (rdev)->asic->gart_set_page((rdev), (i), (p)) |
| 966 | #define radeon_cp_init(rdev,rsize) (rdev)->asic->cp_init((rdev), (rsize)) | ||
| 967 | #define radeon_cp_fini(rdev) (rdev)->asic->cp_fini((rdev)) | ||
| 968 | #define radeon_cp_disable(rdev) (rdev)->asic->cp_disable((rdev)) | ||
| 969 | #define radeon_cp_commit(rdev) (rdev)->asic->cp_commit((rdev)) | 944 | #define radeon_cp_commit(rdev) (rdev)->asic->cp_commit((rdev)) |
| 970 | #define radeon_ring_start(rdev) (rdev)->asic->ring_start((rdev)) | 945 | #define radeon_ring_start(rdev) (rdev)->asic->ring_start((rdev)) |
| 971 | #define radeon_ring_test(rdev) (rdev)->asic->ring_test((rdev)) | 946 | #define radeon_ring_test(rdev) (rdev)->asic->ring_test((rdev)) |
| 972 | #define radeon_ring_ib_execute(rdev, ib) (rdev)->asic->ring_ib_execute((rdev), (ib)) | 947 | #define radeon_ring_ib_execute(rdev, ib) (rdev)->asic->ring_ib_execute((rdev), (ib)) |
| 973 | #define radeon_ib_test(rdev) (rdev)->asic->ib_test((rdev)) | ||
| 974 | #define radeon_irq_set(rdev) (rdev)->asic->irq_set((rdev)) | 948 | #define radeon_irq_set(rdev) (rdev)->asic->irq_set((rdev)) |
| 975 | #define radeon_irq_process(rdev) (rdev)->asic->irq_process((rdev)) | 949 | #define radeon_irq_process(rdev) (rdev)->asic->irq_process((rdev)) |
| 976 | #define radeon_get_vblank_counter(rdev, crtc) (rdev)->asic->get_vblank_counter((rdev), (crtc)) | 950 | #define radeon_get_vblank_counter(rdev, crtc) (rdev)->asic->get_vblank_counter((rdev), (crtc)) |
| @@ -996,6 +970,7 @@ extern void radeon_clocks_fini(struct radeon_device *rdev); | |||
| 996 | extern void radeon_scratch_init(struct radeon_device *rdev); | 970 | extern void radeon_scratch_init(struct radeon_device *rdev); |
| 997 | extern void radeon_surface_init(struct radeon_device *rdev); | 971 | extern void radeon_surface_init(struct radeon_device *rdev); |
| 998 | extern int radeon_cs_parser_init(struct radeon_cs_parser *p, void *data); | 972 | extern int radeon_cs_parser_init(struct radeon_cs_parser *p, void *data); |
| 973 | extern void radeon_legacy_set_clock_gating(struct radeon_device *rdev, int enable); | ||
| 999 | extern void radeon_atom_set_clock_gating(struct radeon_device *rdev, int enable); | 974 | extern void radeon_atom_set_clock_gating(struct radeon_device *rdev, int enable); |
| 1000 | 975 | ||
| 1001 | /* r100,rv100,rs100,rv200,rs200,r200,rv250,rs300,rv280 */ | 976 | /* r100,rv100,rs100,rv200,rs200,r200,rv250,rs300,rv280 */ |
| @@ -1031,11 +1006,27 @@ extern int r100_wb_init(struct radeon_device *rdev); | |||
| 1031 | extern void r100_hdp_reset(struct radeon_device *rdev); | 1006 | extern void r100_hdp_reset(struct radeon_device *rdev); |
| 1032 | extern int r100_rb2d_reset(struct radeon_device *rdev); | 1007 | extern int r100_rb2d_reset(struct radeon_device *rdev); |
| 1033 | extern int r100_cp_reset(struct radeon_device *rdev); | 1008 | extern int r100_cp_reset(struct radeon_device *rdev); |
| 1009 | extern void r100_vga_render_disable(struct radeon_device *rdev); | ||
| 1010 | extern int r100_cs_track_check_pkt3_indx_buffer(struct radeon_cs_parser *p, | ||
| 1011 | struct radeon_cs_packet *pkt, | ||
| 1012 | struct radeon_object *robj); | ||
| 1013 | extern int r100_cs_parse_packet0(struct radeon_cs_parser *p, | ||
| 1014 | struct radeon_cs_packet *pkt, | ||
| 1015 | const unsigned *auth, unsigned n, | ||
| 1016 | radeon_packet0_check_t check); | ||
| 1017 | extern int r100_cs_packet_parse(struct radeon_cs_parser *p, | ||
| 1018 | struct radeon_cs_packet *pkt, | ||
| 1019 | unsigned idx); | ||
| 1020 | |||
| 1021 | /* rv200,rv250,rv280 */ | ||
| 1022 | extern void r200_set_safe_registers(struct radeon_device *rdev); | ||
| 1034 | 1023 | ||
| 1035 | /* r300,r350,rv350,rv370,rv380 */ | 1024 | /* r300,r350,rv350,rv370,rv380 */ |
| 1036 | extern void r300_set_reg_safe(struct radeon_device *rdev); | 1025 | extern void r300_set_reg_safe(struct radeon_device *rdev); |
| 1037 | extern void r300_mc_program(struct radeon_device *rdev); | 1026 | extern void r300_mc_program(struct radeon_device *rdev); |
| 1038 | extern void r300_vram_info(struct radeon_device *rdev); | 1027 | extern void r300_vram_info(struct radeon_device *rdev); |
| 1028 | extern void r300_clock_startup(struct radeon_device *rdev); | ||
| 1029 | extern int r300_mc_wait_for_idle(struct radeon_device *rdev); | ||
| 1039 | extern int rv370_pcie_gart_init(struct radeon_device *rdev); | 1030 | extern int rv370_pcie_gart_init(struct radeon_device *rdev); |
| 1040 | extern void rv370_pcie_gart_fini(struct radeon_device *rdev); | 1031 | extern void rv370_pcie_gart_fini(struct radeon_device *rdev); |
| 1041 | extern int rv370_pcie_gart_enable(struct radeon_device *rdev); | 1032 | extern int rv370_pcie_gart_enable(struct radeon_device *rdev); |
| @@ -1066,6 +1057,18 @@ extern void rv515_clock_startup(struct radeon_device *rdev); | |||
| 1066 | extern void rv515_debugfs(struct radeon_device *rdev); | 1057 | extern void rv515_debugfs(struct radeon_device *rdev); |
| 1067 | extern int rv515_suspend(struct radeon_device *rdev); | 1058 | extern int rv515_suspend(struct radeon_device *rdev); |
| 1068 | 1059 | ||
| 1060 | /* rs400 */ | ||
| 1061 | extern int rs400_gart_init(struct radeon_device *rdev); | ||
| 1062 | extern int rs400_gart_enable(struct radeon_device *rdev); | ||
| 1063 | extern void rs400_gart_adjust_size(struct radeon_device *rdev); | ||
| 1064 | extern void rs400_gart_disable(struct radeon_device *rdev); | ||
| 1065 | extern void rs400_gart_fini(struct radeon_device *rdev); | ||
| 1066 | |||
| 1067 | /* rs600 */ | ||
| 1068 | extern void rs600_set_safe_registers(struct radeon_device *rdev); | ||
| 1069 | extern int rs600_irq_set(struct radeon_device *rdev); | ||
| 1070 | extern void rs600_irq_disable(struct radeon_device *rdev); | ||
| 1071 | |||
| 1069 | /* rs690, rs740 */ | 1072 | /* rs690, rs740 */ |
| 1070 | extern void rs690_line_buffer_adjust(struct radeon_device *rdev, | 1073 | extern void rs690_line_buffer_adjust(struct radeon_device *rdev, |
| 1071 | struct drm_display_mode *mode1, | 1074 | struct drm_display_mode *mode1, |
| @@ -1083,8 +1086,9 @@ extern int r600_pcie_gart_init(struct radeon_device *rdev); | |||
| 1083 | extern void r600_pcie_gart_tlb_flush(struct radeon_device *rdev); | 1086 | extern void r600_pcie_gart_tlb_flush(struct radeon_device *rdev); |
| 1084 | extern int r600_ib_test(struct radeon_device *rdev); | 1087 | extern int r600_ib_test(struct radeon_device *rdev); |
| 1085 | extern int r600_ring_test(struct radeon_device *rdev); | 1088 | extern int r600_ring_test(struct radeon_device *rdev); |
| 1086 | extern int r600_wb_init(struct radeon_device *rdev); | ||
| 1087 | extern void r600_wb_fini(struct radeon_device *rdev); | 1089 | extern void r600_wb_fini(struct radeon_device *rdev); |
| 1090 | extern int r600_wb_enable(struct radeon_device *rdev); | ||
| 1091 | extern void r600_wb_disable(struct radeon_device *rdev); | ||
| 1088 | extern void r600_scratch_init(struct radeon_device *rdev); | 1092 | extern void r600_scratch_init(struct radeon_device *rdev); |
| 1089 | extern int r600_blit_init(struct radeon_device *rdev); | 1093 | extern int r600_blit_init(struct radeon_device *rdev); |
| 1090 | extern void r600_blit_fini(struct radeon_device *rdev); | 1094 | extern void r600_blit_fini(struct radeon_device *rdev); |
diff --git a/drivers/gpu/drm/radeon/radeon_asic.h b/drivers/gpu/drm/radeon/radeon_asic.h index c8a4e7b5663d..c3532c7a6f3f 100644 --- a/drivers/gpu/drm/radeon/radeon_asic.h +++ b/drivers/gpu/drm/radeon/radeon_asic.h | |||
| @@ -41,28 +41,17 @@ void radeon_atom_set_clock_gating(struct radeon_device *rdev, int enable); | |||
| 41 | /* | 41 | /* |
| 42 | * r100,rv100,rs100,rv200,rs200,r200,rv250,rs300,rv280 | 42 | * r100,rv100,rs100,rv200,rs200,r200,rv250,rs300,rv280 |
| 43 | */ | 43 | */ |
| 44 | int r100_init(struct radeon_device *rdev); | 44 | extern int r100_init(struct radeon_device *rdev); |
| 45 | int r200_init(struct radeon_device *rdev); | 45 | extern void r100_fini(struct radeon_device *rdev); |
| 46 | extern int r100_suspend(struct radeon_device *rdev); | ||
| 47 | extern int r100_resume(struct radeon_device *rdev); | ||
| 46 | uint32_t r100_mm_rreg(struct radeon_device *rdev, uint32_t reg); | 48 | uint32_t r100_mm_rreg(struct radeon_device *rdev, uint32_t reg); |
| 47 | void r100_mm_wreg(struct radeon_device *rdev, uint32_t reg, uint32_t v); | 49 | void r100_mm_wreg(struct radeon_device *rdev, uint32_t reg, uint32_t v); |
| 48 | void r100_errata(struct radeon_device *rdev); | ||
| 49 | void r100_vram_info(struct radeon_device *rdev); | ||
| 50 | void r100_vga_set_state(struct radeon_device *rdev, bool state); | 50 | void r100_vga_set_state(struct radeon_device *rdev, bool state); |
| 51 | int r100_gpu_reset(struct radeon_device *rdev); | 51 | int r100_gpu_reset(struct radeon_device *rdev); |
| 52 | int r100_mc_init(struct radeon_device *rdev); | ||
| 53 | void r100_mc_fini(struct radeon_device *rdev); | ||
| 54 | u32 r100_get_vblank_counter(struct radeon_device *rdev, int crtc); | 52 | u32 r100_get_vblank_counter(struct radeon_device *rdev, int crtc); |
| 55 | int r100_wb_init(struct radeon_device *rdev); | ||
| 56 | void r100_wb_fini(struct radeon_device *rdev); | ||
| 57 | int r100_pci_gart_init(struct radeon_device *rdev); | ||
| 58 | void r100_pci_gart_fini(struct radeon_device *rdev); | ||
| 59 | int r100_pci_gart_enable(struct radeon_device *rdev); | ||
| 60 | void r100_pci_gart_disable(struct radeon_device *rdev); | ||
| 61 | void r100_pci_gart_tlb_flush(struct radeon_device *rdev); | 53 | void r100_pci_gart_tlb_flush(struct radeon_device *rdev); |
| 62 | int r100_pci_gart_set_page(struct radeon_device *rdev, int i, uint64_t addr); | 54 | int r100_pci_gart_set_page(struct radeon_device *rdev, int i, uint64_t addr); |
| 63 | int r100_cp_init(struct radeon_device *rdev, unsigned ring_size); | ||
| 64 | void r100_cp_fini(struct radeon_device *rdev); | ||
| 65 | void r100_cp_disable(struct radeon_device *rdev); | ||
| 66 | void r100_cp_commit(struct radeon_device *rdev); | 55 | void r100_cp_commit(struct radeon_device *rdev); |
| 67 | void r100_ring_start(struct radeon_device *rdev); | 56 | void r100_ring_start(struct radeon_device *rdev); |
| 68 | int r100_irq_set(struct radeon_device *rdev); | 57 | int r100_irq_set(struct radeon_device *rdev); |
| @@ -83,33 +72,21 @@ int r100_set_surface_reg(struct radeon_device *rdev, int reg, | |||
| 83 | int r100_clear_surface_reg(struct radeon_device *rdev, int reg); | 72 | int r100_clear_surface_reg(struct radeon_device *rdev, int reg); |
| 84 | void r100_bandwidth_update(struct radeon_device *rdev); | 73 | void r100_bandwidth_update(struct radeon_device *rdev); |
| 85 | void r100_ring_ib_execute(struct radeon_device *rdev, struct radeon_ib *ib); | 74 | void r100_ring_ib_execute(struct radeon_device *rdev, struct radeon_ib *ib); |
| 86 | int r100_ib_test(struct radeon_device *rdev); | ||
| 87 | int r100_ring_test(struct radeon_device *rdev); | 75 | int r100_ring_test(struct radeon_device *rdev); |
| 88 | 76 | ||
| 89 | static struct radeon_asic r100_asic = { | 77 | static struct radeon_asic r100_asic = { |
| 90 | .init = &r100_init, | 78 | .init = &r100_init, |
| 91 | .errata = &r100_errata, | 79 | .fini = &r100_fini, |
| 92 | .vram_info = &r100_vram_info, | 80 | .suspend = &r100_suspend, |
| 81 | .resume = &r100_resume, | ||
| 93 | .vga_set_state = &r100_vga_set_state, | 82 | .vga_set_state = &r100_vga_set_state, |
| 94 | .gpu_reset = &r100_gpu_reset, | 83 | .gpu_reset = &r100_gpu_reset, |
| 95 | .mc_init = &r100_mc_init, | ||
| 96 | .mc_fini = &r100_mc_fini, | ||
| 97 | .wb_init = &r100_wb_init, | ||
| 98 | .wb_fini = &r100_wb_fini, | ||
| 99 | .gart_init = &r100_pci_gart_init, | ||
| 100 | .gart_fini = &r100_pci_gart_fini, | ||
| 101 | .gart_enable = &r100_pci_gart_enable, | ||
| 102 | .gart_disable = &r100_pci_gart_disable, | ||
| 103 | .gart_tlb_flush = &r100_pci_gart_tlb_flush, | 84 | .gart_tlb_flush = &r100_pci_gart_tlb_flush, |
| 104 | .gart_set_page = &r100_pci_gart_set_page, | 85 | .gart_set_page = &r100_pci_gart_set_page, |
| 105 | .cp_init = &r100_cp_init, | ||
| 106 | .cp_fini = &r100_cp_fini, | ||
| 107 | .cp_disable = &r100_cp_disable, | ||
| 108 | .cp_commit = &r100_cp_commit, | 86 | .cp_commit = &r100_cp_commit, |
| 109 | .ring_start = &r100_ring_start, | 87 | .ring_start = &r100_ring_start, |
| 110 | .ring_test = &r100_ring_test, | 88 | .ring_test = &r100_ring_test, |
| 111 | .ring_ib_execute = &r100_ring_ib_execute, | 89 | .ring_ib_execute = &r100_ring_ib_execute, |
| 112 | .ib_test = &r100_ib_test, | ||
| 113 | .irq_set = &r100_irq_set, | 90 | .irq_set = &r100_irq_set, |
| 114 | .irq_process = &r100_irq_process, | 91 | .irq_process = &r100_irq_process, |
| 115 | .get_vblank_counter = &r100_get_vblank_counter, | 92 | .get_vblank_counter = &r100_get_vblank_counter, |
| @@ -131,55 +108,38 @@ static struct radeon_asic r100_asic = { | |||
| 131 | /* | 108 | /* |
| 132 | * r300,r350,rv350,rv380 | 109 | * r300,r350,rv350,rv380 |
| 133 | */ | 110 | */ |
| 134 | int r300_init(struct radeon_device *rdev); | 111 | extern int r300_init(struct radeon_device *rdev); |
| 135 | void r300_errata(struct radeon_device *rdev); | 112 | extern void r300_fini(struct radeon_device *rdev); |
| 136 | void r300_vram_info(struct radeon_device *rdev); | 113 | extern int r300_suspend(struct radeon_device *rdev); |
| 137 | int r300_gpu_reset(struct radeon_device *rdev); | 114 | extern int r300_resume(struct radeon_device *rdev); |
| 138 | int r300_mc_init(struct radeon_device *rdev); | 115 | extern int r300_gpu_reset(struct radeon_device *rdev); |
| 139 | void r300_mc_fini(struct radeon_device *rdev); | 116 | extern void r300_ring_start(struct radeon_device *rdev); |
| 140 | void r300_ring_start(struct radeon_device *rdev); | 117 | extern void r300_fence_ring_emit(struct radeon_device *rdev, |
| 141 | void r300_fence_ring_emit(struct radeon_device *rdev, | 118 | struct radeon_fence *fence); |
| 142 | struct radeon_fence *fence); | 119 | extern int r300_cs_parse(struct radeon_cs_parser *p); |
| 143 | int r300_cs_parse(struct radeon_cs_parser *p); | 120 | extern void rv370_pcie_gart_tlb_flush(struct radeon_device *rdev); |
| 144 | int rv370_pcie_gart_init(struct radeon_device *rdev); | 121 | extern int rv370_pcie_gart_set_page(struct radeon_device *rdev, int i, uint64_t addr); |
| 145 | void rv370_pcie_gart_fini(struct radeon_device *rdev); | 122 | extern uint32_t rv370_pcie_rreg(struct radeon_device *rdev, uint32_t reg); |
| 146 | int rv370_pcie_gart_enable(struct radeon_device *rdev); | 123 | extern void rv370_pcie_wreg(struct radeon_device *rdev, uint32_t reg, uint32_t v); |
| 147 | void rv370_pcie_gart_disable(struct radeon_device *rdev); | 124 | extern void rv370_set_pcie_lanes(struct radeon_device *rdev, int lanes); |
| 148 | void rv370_pcie_gart_tlb_flush(struct radeon_device *rdev); | 125 | extern int r300_copy_dma(struct radeon_device *rdev, |
| 149 | int rv370_pcie_gart_set_page(struct radeon_device *rdev, int i, uint64_t addr); | 126 | uint64_t src_offset, |
| 150 | uint32_t rv370_pcie_rreg(struct radeon_device *rdev, uint32_t reg); | 127 | uint64_t dst_offset, |
| 151 | void rv370_pcie_wreg(struct radeon_device *rdev, uint32_t reg, uint32_t v); | 128 | unsigned num_pages, |
| 152 | void rv370_set_pcie_lanes(struct radeon_device *rdev, int lanes); | 129 | struct radeon_fence *fence); |
| 153 | int r300_copy_dma(struct radeon_device *rdev, | ||
| 154 | uint64_t src_offset, | ||
| 155 | uint64_t dst_offset, | ||
| 156 | unsigned num_pages, | ||
| 157 | struct radeon_fence *fence); | ||
| 158 | |||
| 159 | static struct radeon_asic r300_asic = { | 130 | static struct radeon_asic r300_asic = { |
| 160 | .init = &r300_init, | 131 | .init = &r300_init, |
| 161 | .errata = &r300_errata, | 132 | .fini = &r300_fini, |
| 162 | .vram_info = &r300_vram_info, | 133 | .suspend = &r300_suspend, |
| 134 | .resume = &r300_resume, | ||
| 163 | .vga_set_state = &r100_vga_set_state, | 135 | .vga_set_state = &r100_vga_set_state, |
| 164 | .gpu_reset = &r300_gpu_reset, | 136 | .gpu_reset = &r300_gpu_reset, |
| 165 | .mc_init = &r300_mc_init, | ||
| 166 | .mc_fini = &r300_mc_fini, | ||
| 167 | .wb_init = &r100_wb_init, | ||
| 168 | .wb_fini = &r100_wb_fini, | ||
| 169 | .gart_init = &r100_pci_gart_init, | ||
| 170 | .gart_fini = &r100_pci_gart_fini, | ||
| 171 | .gart_enable = &r100_pci_gart_enable, | ||
| 172 | .gart_disable = &r100_pci_gart_disable, | ||
| 173 | .gart_tlb_flush = &r100_pci_gart_tlb_flush, | 137 | .gart_tlb_flush = &r100_pci_gart_tlb_flush, |
| 174 | .gart_set_page = &r100_pci_gart_set_page, | 138 | .gart_set_page = &r100_pci_gart_set_page, |
| 175 | .cp_init = &r100_cp_init, | ||
| 176 | .cp_fini = &r100_cp_fini, | ||
| 177 | .cp_disable = &r100_cp_disable, | ||
| 178 | .cp_commit = &r100_cp_commit, | 139 | .cp_commit = &r100_cp_commit, |
| 179 | .ring_start = &r300_ring_start, | 140 | .ring_start = &r300_ring_start, |
| 180 | .ring_test = &r100_ring_test, | 141 | .ring_test = &r100_ring_test, |
| 181 | .ring_ib_execute = &r100_ring_ib_execute, | 142 | .ring_ib_execute = &r100_ring_ib_execute, |
| 182 | .ib_test = &r100_ib_test, | ||
| 183 | .irq_set = &r100_irq_set, | 143 | .irq_set = &r100_irq_set, |
| 184 | .irq_process = &r100_irq_process, | 144 | .irq_process = &r100_irq_process, |
| 185 | .get_vblank_counter = &r100_get_vblank_counter, | 145 | .get_vblank_counter = &r100_get_vblank_counter, |
| @@ -209,26 +169,14 @@ static struct radeon_asic r420_asic = { | |||
| 209 | .fini = &r420_fini, | 169 | .fini = &r420_fini, |
| 210 | .suspend = &r420_suspend, | 170 | .suspend = &r420_suspend, |
| 211 | .resume = &r420_resume, | 171 | .resume = &r420_resume, |
| 212 | .errata = NULL, | ||
| 213 | .vram_info = NULL, | ||
| 214 | .vga_set_state = &r100_vga_set_state, | 172 | .vga_set_state = &r100_vga_set_state, |
| 215 | .gpu_reset = &r300_gpu_reset, | 173 | .gpu_reset = &r300_gpu_reset, |
| 216 | .mc_init = NULL, | ||
| 217 | .mc_fini = NULL, | ||
| 218 | .wb_init = NULL, | ||
| 219 | .wb_fini = NULL, | ||
| 220 | .gart_enable = NULL, | ||
| 221 | .gart_disable = NULL, | ||
| 222 | .gart_tlb_flush = &rv370_pcie_gart_tlb_flush, | 174 | .gart_tlb_flush = &rv370_pcie_gart_tlb_flush, |
| 223 | .gart_set_page = &rv370_pcie_gart_set_page, | 175 | .gart_set_page = &rv370_pcie_gart_set_page, |
| 224 | .cp_init = NULL, | ||
| 225 | .cp_fini = NULL, | ||
| 226 | .cp_disable = NULL, | ||
| 227 | .cp_commit = &r100_cp_commit, | 176 | .cp_commit = &r100_cp_commit, |
| 228 | .ring_start = &r300_ring_start, | 177 | .ring_start = &r300_ring_start, |
| 229 | .ring_test = &r100_ring_test, | 178 | .ring_test = &r100_ring_test, |
| 230 | .ring_ib_execute = &r100_ring_ib_execute, | 179 | .ring_ib_execute = &r100_ring_ib_execute, |
| 231 | .ib_test = NULL, | ||
| 232 | .irq_set = &r100_irq_set, | 180 | .irq_set = &r100_irq_set, |
| 233 | .irq_process = &r100_irq_process, | 181 | .irq_process = &r100_irq_process, |
| 234 | .get_vblank_counter = &r100_get_vblank_counter, | 182 | .get_vblank_counter = &r100_get_vblank_counter, |
| @@ -250,42 +198,27 @@ static struct radeon_asic r420_asic = { | |||
| 250 | /* | 198 | /* |
| 251 | * rs400,rs480 | 199 | * rs400,rs480 |
| 252 | */ | 200 | */ |
| 253 | void rs400_errata(struct radeon_device *rdev); | 201 | extern int rs400_init(struct radeon_device *rdev); |
| 254 | void rs400_vram_info(struct radeon_device *rdev); | 202 | extern void rs400_fini(struct radeon_device *rdev); |
| 255 | int rs400_mc_init(struct radeon_device *rdev); | 203 | extern int rs400_suspend(struct radeon_device *rdev); |
| 256 | void rs400_mc_fini(struct radeon_device *rdev); | 204 | extern int rs400_resume(struct radeon_device *rdev); |
| 257 | int rs400_gart_init(struct radeon_device *rdev); | ||
| 258 | void rs400_gart_fini(struct radeon_device *rdev); | ||
| 259 | int rs400_gart_enable(struct radeon_device *rdev); | ||
| 260 | void rs400_gart_disable(struct radeon_device *rdev); | ||
| 261 | void rs400_gart_tlb_flush(struct radeon_device *rdev); | 205 | void rs400_gart_tlb_flush(struct radeon_device *rdev); |
| 262 | int rs400_gart_set_page(struct radeon_device *rdev, int i, uint64_t addr); | 206 | int rs400_gart_set_page(struct radeon_device *rdev, int i, uint64_t addr); |
| 263 | uint32_t rs400_mc_rreg(struct radeon_device *rdev, uint32_t reg); | 207 | uint32_t rs400_mc_rreg(struct radeon_device *rdev, uint32_t reg); |
| 264 | void rs400_mc_wreg(struct radeon_device *rdev, uint32_t reg, uint32_t v); | 208 | void rs400_mc_wreg(struct radeon_device *rdev, uint32_t reg, uint32_t v); |
| 265 | static struct radeon_asic rs400_asic = { | 209 | static struct radeon_asic rs400_asic = { |
| 266 | .init = &r300_init, | 210 | .init = &rs400_init, |
| 267 | .errata = &rs400_errata, | 211 | .fini = &rs400_fini, |
| 268 | .vram_info = &rs400_vram_info, | 212 | .suspend = &rs400_suspend, |
| 213 | .resume = &rs400_resume, | ||
| 269 | .vga_set_state = &r100_vga_set_state, | 214 | .vga_set_state = &r100_vga_set_state, |
| 270 | .gpu_reset = &r300_gpu_reset, | 215 | .gpu_reset = &r300_gpu_reset, |
| 271 | .mc_init = &rs400_mc_init, | ||
| 272 | .mc_fini = &rs400_mc_fini, | ||
| 273 | .wb_init = &r100_wb_init, | ||
| 274 | .wb_fini = &r100_wb_fini, | ||
| 275 | .gart_init = &rs400_gart_init, | ||
| 276 | .gart_fini = &rs400_gart_fini, | ||
| 277 | .gart_enable = &rs400_gart_enable, | ||
| 278 | .gart_disable = &rs400_gart_disable, | ||
| 279 | .gart_tlb_flush = &rs400_gart_tlb_flush, | 216 | .gart_tlb_flush = &rs400_gart_tlb_flush, |
| 280 | .gart_set_page = &rs400_gart_set_page, | 217 | .gart_set_page = &rs400_gart_set_page, |
| 281 | .cp_init = &r100_cp_init, | ||
| 282 | .cp_fini = &r100_cp_fini, | ||
| 283 | .cp_disable = &r100_cp_disable, | ||
| 284 | .cp_commit = &r100_cp_commit, | 218 | .cp_commit = &r100_cp_commit, |
| 285 | .ring_start = &r300_ring_start, | 219 | .ring_start = &r300_ring_start, |
| 286 | .ring_test = &r100_ring_test, | 220 | .ring_test = &r100_ring_test, |
| 287 | .ring_ib_execute = &r100_ring_ib_execute, | 221 | .ring_ib_execute = &r100_ring_ib_execute, |
| 288 | .ib_test = &r100_ib_test, | ||
| 289 | .irq_set = &r100_irq_set, | 222 | .irq_set = &r100_irq_set, |
| 290 | .irq_process = &r100_irq_process, | 223 | .irq_process = &r100_irq_process, |
| 291 | .get_vblank_counter = &r100_get_vblank_counter, | 224 | .get_vblank_counter = &r100_get_vblank_counter, |
| @@ -307,18 +240,13 @@ static struct radeon_asic rs400_asic = { | |||
| 307 | /* | 240 | /* |
| 308 | * rs600. | 241 | * rs600. |
| 309 | */ | 242 | */ |
| 310 | int rs600_init(struct radeon_device *rdev); | 243 | extern int rs600_init(struct radeon_device *rdev); |
| 311 | void rs600_errata(struct radeon_device *rdev); | 244 | extern void rs600_fini(struct radeon_device *rdev); |
| 312 | void rs600_vram_info(struct radeon_device *rdev); | 245 | extern int rs600_suspend(struct radeon_device *rdev); |
| 313 | int rs600_mc_init(struct radeon_device *rdev); | 246 | extern int rs600_resume(struct radeon_device *rdev); |
| 314 | void rs600_mc_fini(struct radeon_device *rdev); | ||
| 315 | int rs600_irq_set(struct radeon_device *rdev); | 247 | int rs600_irq_set(struct radeon_device *rdev); |
| 316 | int rs600_irq_process(struct radeon_device *rdev); | 248 | int rs600_irq_process(struct radeon_device *rdev); |
| 317 | u32 rs600_get_vblank_counter(struct radeon_device *rdev, int crtc); | 249 | u32 rs600_get_vblank_counter(struct radeon_device *rdev, int crtc); |
| 318 | int rs600_gart_init(struct radeon_device *rdev); | ||
| 319 | void rs600_gart_fini(struct radeon_device *rdev); | ||
| 320 | int rs600_gart_enable(struct radeon_device *rdev); | ||
| 321 | void rs600_gart_disable(struct radeon_device *rdev); | ||
| 322 | void rs600_gart_tlb_flush(struct radeon_device *rdev); | 250 | void rs600_gart_tlb_flush(struct radeon_device *rdev); |
| 323 | int rs600_gart_set_page(struct radeon_device *rdev, int i, uint64_t addr); | 251 | int rs600_gart_set_page(struct radeon_device *rdev, int i, uint64_t addr); |
| 324 | uint32_t rs600_mc_rreg(struct radeon_device *rdev, uint32_t reg); | 252 | uint32_t rs600_mc_rreg(struct radeon_device *rdev, uint32_t reg); |
| @@ -326,28 +254,17 @@ void rs600_mc_wreg(struct radeon_device *rdev, uint32_t reg, uint32_t v); | |||
| 326 | void rs600_bandwidth_update(struct radeon_device *rdev); | 254 | void rs600_bandwidth_update(struct radeon_device *rdev); |
| 327 | static struct radeon_asic rs600_asic = { | 255 | static struct radeon_asic rs600_asic = { |
| 328 | .init = &rs600_init, | 256 | .init = &rs600_init, |
| 329 | .errata = &rs600_errata, | 257 | .fini = &rs600_fini, |
| 330 | .vram_info = &rs600_vram_info, | 258 | .suspend = &rs600_suspend, |
| 259 | .resume = &rs600_resume, | ||
| 331 | .vga_set_state = &r100_vga_set_state, | 260 | .vga_set_state = &r100_vga_set_state, |
| 332 | .gpu_reset = &r300_gpu_reset, | 261 | .gpu_reset = &r300_gpu_reset, |
| 333 | .mc_init = &rs600_mc_init, | ||
| 334 | .mc_fini = &rs600_mc_fini, | ||
| 335 | .wb_init = &r100_wb_init, | ||
| 336 | .wb_fini = &r100_wb_fini, | ||
| 337 | .gart_init = &rs600_gart_init, | ||
| 338 | .gart_fini = &rs600_gart_fini, | ||
| 339 | .gart_enable = &rs600_gart_enable, | ||
| 340 | .gart_disable = &rs600_gart_disable, | ||
| 341 | .gart_tlb_flush = &rs600_gart_tlb_flush, | 262 | .gart_tlb_flush = &rs600_gart_tlb_flush, |
| 342 | .gart_set_page = &rs600_gart_set_page, | 263 | .gart_set_page = &rs600_gart_set_page, |
| 343 | .cp_init = &r100_cp_init, | ||
| 344 | .cp_fini = &r100_cp_fini, | ||
| 345 | .cp_disable = &r100_cp_disable, | ||
| 346 | .cp_commit = &r100_cp_commit, | 264 | .cp_commit = &r100_cp_commit, |
| 347 | .ring_start = &r300_ring_start, | 265 | .ring_start = &r300_ring_start, |
| 348 | .ring_test = &r100_ring_test, | 266 | .ring_test = &r100_ring_test, |
| 349 | .ring_ib_execute = &r100_ring_ib_execute, | 267 | .ring_ib_execute = &r100_ring_ib_execute, |
| 350 | .ib_test = &r100_ib_test, | ||
| 351 | .irq_set = &rs600_irq_set, | 268 | .irq_set = &rs600_irq_set, |
| 352 | .irq_process = &rs600_irq_process, | 269 | .irq_process = &rs600_irq_process, |
| 353 | .get_vblank_counter = &rs600_get_vblank_counter, | 270 | .get_vblank_counter = &rs600_get_vblank_counter, |
| @@ -367,37 +284,26 @@ static struct radeon_asic rs600_asic = { | |||
| 367 | /* | 284 | /* |
| 368 | * rs690,rs740 | 285 | * rs690,rs740 |
| 369 | */ | 286 | */ |
| 370 | void rs690_errata(struct radeon_device *rdev); | 287 | int rs690_init(struct radeon_device *rdev); |
| 371 | void rs690_vram_info(struct radeon_device *rdev); | 288 | void rs690_fini(struct radeon_device *rdev); |
| 372 | int rs690_mc_init(struct radeon_device *rdev); | 289 | int rs690_resume(struct radeon_device *rdev); |
| 373 | void rs690_mc_fini(struct radeon_device *rdev); | 290 | int rs690_suspend(struct radeon_device *rdev); |
| 374 | uint32_t rs690_mc_rreg(struct radeon_device *rdev, uint32_t reg); | 291 | uint32_t rs690_mc_rreg(struct radeon_device *rdev, uint32_t reg); |
| 375 | void rs690_mc_wreg(struct radeon_device *rdev, uint32_t reg, uint32_t v); | 292 | void rs690_mc_wreg(struct radeon_device *rdev, uint32_t reg, uint32_t v); |
| 376 | void rs690_bandwidth_update(struct radeon_device *rdev); | 293 | void rs690_bandwidth_update(struct radeon_device *rdev); |
| 377 | static struct radeon_asic rs690_asic = { | 294 | static struct radeon_asic rs690_asic = { |
| 378 | .init = &rs600_init, | 295 | .init = &rs690_init, |
| 379 | .errata = &rs690_errata, | 296 | .fini = &rs690_fini, |
| 380 | .vram_info = &rs690_vram_info, | 297 | .suspend = &rs690_suspend, |
| 298 | .resume = &rs690_resume, | ||
| 381 | .vga_set_state = &r100_vga_set_state, | 299 | .vga_set_state = &r100_vga_set_state, |
| 382 | .gpu_reset = &r300_gpu_reset, | 300 | .gpu_reset = &r300_gpu_reset, |
| 383 | .mc_init = &rs690_mc_init, | ||
| 384 | .mc_fini = &rs690_mc_fini, | ||
| 385 | .wb_init = &r100_wb_init, | ||
| 386 | .wb_fini = &r100_wb_fini, | ||
| 387 | .gart_init = &rs400_gart_init, | ||
| 388 | .gart_fini = &rs400_gart_fini, | ||
| 389 | .gart_enable = &rs400_gart_enable, | ||
| 390 | .gart_disable = &rs400_gart_disable, | ||
| 391 | .gart_tlb_flush = &rs400_gart_tlb_flush, | 301 | .gart_tlb_flush = &rs400_gart_tlb_flush, |
| 392 | .gart_set_page = &rs400_gart_set_page, | 302 | .gart_set_page = &rs400_gart_set_page, |
| 393 | .cp_init = &r100_cp_init, | ||
| 394 | .cp_fini = &r100_cp_fini, | ||
| 395 | .cp_disable = &r100_cp_disable, | ||
| 396 | .cp_commit = &r100_cp_commit, | 303 | .cp_commit = &r100_cp_commit, |
| 397 | .ring_start = &r300_ring_start, | 304 | .ring_start = &r300_ring_start, |
| 398 | .ring_test = &r100_ring_test, | 305 | .ring_test = &r100_ring_test, |
| 399 | .ring_ib_execute = &r100_ring_ib_execute, | 306 | .ring_ib_execute = &r100_ring_ib_execute, |
| 400 | .ib_test = &r100_ib_test, | ||
| 401 | .irq_set = &rs600_irq_set, | 307 | .irq_set = &rs600_irq_set, |
| 402 | .irq_process = &rs600_irq_process, | 308 | .irq_process = &rs600_irq_process, |
| 403 | .get_vblank_counter = &rs600_get_vblank_counter, | 309 | .get_vblank_counter = &rs600_get_vblank_counter, |
| @@ -435,28 +341,14 @@ static struct radeon_asic rv515_asic = { | |||
| 435 | .fini = &rv515_fini, | 341 | .fini = &rv515_fini, |
| 436 | .suspend = &rv515_suspend, | 342 | .suspend = &rv515_suspend, |
| 437 | .resume = &rv515_resume, | 343 | .resume = &rv515_resume, |
| 438 | .errata = NULL, | ||
| 439 | .vram_info = NULL, | ||
| 440 | .vga_set_state = &r100_vga_set_state, | 344 | .vga_set_state = &r100_vga_set_state, |
| 441 | .gpu_reset = &rv515_gpu_reset, | 345 | .gpu_reset = &rv515_gpu_reset, |
| 442 | .mc_init = NULL, | ||
| 443 | .mc_fini = NULL, | ||
| 444 | .wb_init = NULL, | ||
| 445 | .wb_fini = NULL, | ||
| 446 | .gart_init = &rv370_pcie_gart_init, | ||
| 447 | .gart_fini = &rv370_pcie_gart_fini, | ||
| 448 | .gart_enable = NULL, | ||
| 449 | .gart_disable = NULL, | ||
| 450 | .gart_tlb_flush = &rv370_pcie_gart_tlb_flush, | 346 | .gart_tlb_flush = &rv370_pcie_gart_tlb_flush, |
| 451 | .gart_set_page = &rv370_pcie_gart_set_page, | 347 | .gart_set_page = &rv370_pcie_gart_set_page, |
| 452 | .cp_init = NULL, | ||
| 453 | .cp_fini = NULL, | ||
| 454 | .cp_disable = NULL, | ||
| 455 | .cp_commit = &r100_cp_commit, | 348 | .cp_commit = &r100_cp_commit, |
| 456 | .ring_start = &rv515_ring_start, | 349 | .ring_start = &rv515_ring_start, |
| 457 | .ring_test = &r100_ring_test, | 350 | .ring_test = &r100_ring_test, |
| 458 | .ring_ib_execute = &r100_ring_ib_execute, | 351 | .ring_ib_execute = &r100_ring_ib_execute, |
| 459 | .ib_test = NULL, | ||
| 460 | .irq_set = &rs600_irq_set, | 352 | .irq_set = &rs600_irq_set, |
| 461 | .irq_process = &rs600_irq_process, | 353 | .irq_process = &rs600_irq_process, |
| 462 | .get_vblank_counter = &rs600_get_vblank_counter, | 354 | .get_vblank_counter = &rs600_get_vblank_counter, |
| @@ -485,28 +377,14 @@ static struct radeon_asic r520_asic = { | |||
| 485 | .fini = &rv515_fini, | 377 | .fini = &rv515_fini, |
| 486 | .suspend = &rv515_suspend, | 378 | .suspend = &rv515_suspend, |
| 487 | .resume = &r520_resume, | 379 | .resume = &r520_resume, |
| 488 | .errata = NULL, | ||
| 489 | .vram_info = NULL, | ||
| 490 | .vga_set_state = &r100_vga_set_state, | 380 | .vga_set_state = &r100_vga_set_state, |
| 491 | .gpu_reset = &rv515_gpu_reset, | 381 | .gpu_reset = &rv515_gpu_reset, |
| 492 | .mc_init = NULL, | ||
| 493 | .mc_fini = NULL, | ||
| 494 | .wb_init = NULL, | ||
| 495 | .wb_fini = NULL, | ||
| 496 | .gart_init = NULL, | ||
| 497 | .gart_fini = NULL, | ||
| 498 | .gart_enable = NULL, | ||
| 499 | .gart_disable = NULL, | ||
| 500 | .gart_tlb_flush = &rv370_pcie_gart_tlb_flush, | 382 | .gart_tlb_flush = &rv370_pcie_gart_tlb_flush, |
| 501 | .gart_set_page = &rv370_pcie_gart_set_page, | 383 | .gart_set_page = &rv370_pcie_gart_set_page, |
| 502 | .cp_init = NULL, | ||
| 503 | .cp_fini = NULL, | ||
| 504 | .cp_disable = NULL, | ||
| 505 | .cp_commit = &r100_cp_commit, | 384 | .cp_commit = &r100_cp_commit, |
| 506 | .ring_start = &rv515_ring_start, | 385 | .ring_start = &rv515_ring_start, |
| 507 | .ring_test = &r100_ring_test, | 386 | .ring_test = &r100_ring_test, |
| 508 | .ring_ib_execute = &r100_ring_ib_execute, | 387 | .ring_ib_execute = &r100_ring_ib_execute, |
| 509 | .ib_test = NULL, | ||
| 510 | .irq_set = &rs600_irq_set, | 388 | .irq_set = &rs600_irq_set, |
| 511 | .irq_process = &rs600_irq_process, | 389 | .irq_process = &rs600_irq_process, |
| 512 | .get_vblank_counter = &rs600_get_vblank_counter, | 390 | .get_vblank_counter = &rs600_get_vblank_counter, |
| @@ -554,37 +432,23 @@ int r600_set_surface_reg(struct radeon_device *rdev, int reg, | |||
| 554 | uint32_t offset, uint32_t obj_size); | 432 | uint32_t offset, uint32_t obj_size); |
| 555 | int r600_clear_surface_reg(struct radeon_device *rdev, int reg); | 433 | int r600_clear_surface_reg(struct radeon_device *rdev, int reg); |
| 556 | void r600_ring_ib_execute(struct radeon_device *rdev, struct radeon_ib *ib); | 434 | void r600_ring_ib_execute(struct radeon_device *rdev, struct radeon_ib *ib); |
| 557 | int r600_ib_test(struct radeon_device *rdev); | ||
| 558 | int r600_ring_test(struct radeon_device *rdev); | 435 | int r600_ring_test(struct radeon_device *rdev); |
| 559 | int r600_copy_blit(struct radeon_device *rdev, | 436 | int r600_copy_blit(struct radeon_device *rdev, |
| 560 | uint64_t src_offset, uint64_t dst_offset, | 437 | uint64_t src_offset, uint64_t dst_offset, |
| 561 | unsigned num_pages, struct radeon_fence *fence); | 438 | unsigned num_pages, struct radeon_fence *fence); |
| 562 | 439 | ||
| 563 | static struct radeon_asic r600_asic = { | 440 | static struct radeon_asic r600_asic = { |
| 564 | .errata = NULL, | ||
| 565 | .init = &r600_init, | 441 | .init = &r600_init, |
| 566 | .fini = &r600_fini, | 442 | .fini = &r600_fini, |
| 567 | .suspend = &r600_suspend, | 443 | .suspend = &r600_suspend, |
| 568 | .resume = &r600_resume, | 444 | .resume = &r600_resume, |
| 569 | .cp_commit = &r600_cp_commit, | 445 | .cp_commit = &r600_cp_commit, |
| 570 | .vram_info = NULL, | ||
| 571 | .vga_set_state = &r600_vga_set_state, | 446 | .vga_set_state = &r600_vga_set_state, |
| 572 | .gpu_reset = &r600_gpu_reset, | 447 | .gpu_reset = &r600_gpu_reset, |
| 573 | .mc_init = NULL, | ||
| 574 | .mc_fini = NULL, | ||
| 575 | .wb_init = &r600_wb_init, | ||
| 576 | .wb_fini = &r600_wb_fini, | ||
| 577 | .gart_enable = NULL, | ||
| 578 | .gart_disable = NULL, | ||
| 579 | .gart_tlb_flush = &r600_pcie_gart_tlb_flush, | 448 | .gart_tlb_flush = &r600_pcie_gart_tlb_flush, |
| 580 | .gart_set_page = &rs600_gart_set_page, | 449 | .gart_set_page = &rs600_gart_set_page, |
| 581 | .cp_init = NULL, | ||
| 582 | .cp_fini = NULL, | ||
| 583 | .cp_disable = NULL, | ||
| 584 | .ring_start = NULL, | ||
| 585 | .ring_test = &r600_ring_test, | 450 | .ring_test = &r600_ring_test, |
| 586 | .ring_ib_execute = &r600_ring_ib_execute, | 451 | .ring_ib_execute = &r600_ring_ib_execute, |
| 587 | .ib_test = &r600_ib_test, | ||
| 588 | .irq_set = &r600_irq_set, | 452 | .irq_set = &r600_irq_set, |
| 589 | .irq_process = &r600_irq_process, | 453 | .irq_process = &r600_irq_process, |
| 590 | .fence_ring_emit = &r600_fence_ring_emit, | 454 | .fence_ring_emit = &r600_fence_ring_emit, |
| @@ -611,30 +475,17 @@ int rv770_resume(struct radeon_device *rdev); | |||
| 611 | int rv770_gpu_reset(struct radeon_device *rdev); | 475 | int rv770_gpu_reset(struct radeon_device *rdev); |
| 612 | 476 | ||
| 613 | static struct radeon_asic rv770_asic = { | 477 | static struct radeon_asic rv770_asic = { |
| 614 | .errata = NULL, | ||
| 615 | .init = &rv770_init, | 478 | .init = &rv770_init, |
| 616 | .fini = &rv770_fini, | 479 | .fini = &rv770_fini, |
| 617 | .suspend = &rv770_suspend, | 480 | .suspend = &rv770_suspend, |
| 618 | .resume = &rv770_resume, | 481 | .resume = &rv770_resume, |
| 619 | .cp_commit = &r600_cp_commit, | 482 | .cp_commit = &r600_cp_commit, |
| 620 | .vram_info = NULL, | ||
| 621 | .gpu_reset = &rv770_gpu_reset, | 483 | .gpu_reset = &rv770_gpu_reset, |
| 622 | .vga_set_state = &r600_vga_set_state, | 484 | .vga_set_state = &r600_vga_set_state, |
| 623 | .mc_init = NULL, | ||
| 624 | .mc_fini = NULL, | ||
| 625 | .wb_init = &r600_wb_init, | ||
| 626 | .wb_fini = &r600_wb_fini, | ||
| 627 | .gart_enable = NULL, | ||
| 628 | .gart_disable = NULL, | ||
| 629 | .gart_tlb_flush = &r600_pcie_gart_tlb_flush, | 485 | .gart_tlb_flush = &r600_pcie_gart_tlb_flush, |
| 630 | .gart_set_page = &rs600_gart_set_page, | 486 | .gart_set_page = &rs600_gart_set_page, |
| 631 | .cp_init = NULL, | ||
| 632 | .cp_fini = NULL, | ||
| 633 | .cp_disable = NULL, | ||
| 634 | .ring_start = NULL, | ||
| 635 | .ring_test = &r600_ring_test, | 487 | .ring_test = &r600_ring_test, |
| 636 | .ring_ib_execute = &r600_ring_ib_execute, | 488 | .ring_ib_execute = &r600_ring_ib_execute, |
| 637 | .ib_test = &r600_ib_test, | ||
| 638 | .irq_set = &r600_irq_set, | 489 | .irq_set = &r600_irq_set, |
| 639 | .irq_process = &r600_irq_process, | 490 | .irq_process = &r600_irq_process, |
| 640 | .fence_ring_emit = &r600_fence_ring_emit, | 491 | .fence_ring_emit = &r600_fence_ring_emit, |
diff --git a/drivers/gpu/drm/radeon/radeon_bios.c b/drivers/gpu/drm/radeon/radeon_bios.c index 96e37a6e7ce4..34a9b9119518 100644 --- a/drivers/gpu/drm/radeon/radeon_bios.c +++ b/drivers/gpu/drm/radeon/radeon_bios.c | |||
| @@ -33,12 +33,50 @@ | |||
| 33 | /* | 33 | /* |
| 34 | * BIOS. | 34 | * BIOS. |
| 35 | */ | 35 | */ |
| 36 | |||
| 37 | /* If you boot an IGP board with a discrete card as the primary, | ||
| 38 | * the IGP rom is not accessible via the rom bar as the IGP rom is | ||
| 39 | * part of the system bios. On boot, the system bios puts a | ||
| 40 | * copy of the igp rom at the start of vram if a discrete card is | ||
| 41 | * present. | ||
| 42 | */ | ||
| 43 | static bool igp_read_bios_from_vram(struct radeon_device *rdev) | ||
| 44 | { | ||
| 45 | uint8_t __iomem *bios; | ||
| 46 | resource_size_t vram_base; | ||
| 47 | resource_size_t size = 256 * 1024; /* ??? */ | ||
| 48 | |||
| 49 | rdev->bios = NULL; | ||
| 50 | vram_base = drm_get_resource_start(rdev->ddev, 0); | ||
| 51 | bios = ioremap(vram_base, size); | ||
| 52 | if (!bios) { | ||
| 53 | DRM_ERROR("Unable to mmap vram\n"); | ||
| 54 | return false; | ||
| 55 | } | ||
| 56 | |||
| 57 | if (size == 0 || bios[0] != 0x55 || bios[1] != 0xaa) { | ||
| 58 | iounmap(bios); | ||
| 59 | DRM_ERROR("bad rom signature\n"); | ||
| 60 | return false; | ||
| 61 | } | ||
| 62 | rdev->bios = kmalloc(size, GFP_KERNEL); | ||
| 63 | if (rdev->bios == NULL) { | ||
| 64 | iounmap(bios); | ||
| 65 | DRM_ERROR("kmalloc failed\n"); | ||
| 66 | return false; | ||
| 67 | } | ||
| 68 | memcpy(rdev->bios, bios, size); | ||
| 69 | iounmap(bios); | ||
| 70 | return true; | ||
| 71 | } | ||
| 72 | |||
| 36 | static bool radeon_read_bios(struct radeon_device *rdev) | 73 | static bool radeon_read_bios(struct radeon_device *rdev) |
| 37 | { | 74 | { |
| 38 | uint8_t __iomem *bios; | 75 | uint8_t __iomem *bios; |
| 39 | size_t size; | 76 | size_t size; |
| 40 | 77 | ||
| 41 | rdev->bios = NULL; | 78 | rdev->bios = NULL; |
| 79 | /* XXX: some cards may return 0 for rom size? ddx has a workaround */ | ||
| 42 | bios = pci_map_rom(rdev->pdev, &size); | 80 | bios = pci_map_rom(rdev->pdev, &size); |
| 43 | if (!bios) { | 81 | if (!bios) { |
| 44 | return false; | 82 | return false; |
| @@ -341,7 +379,9 @@ static bool legacy_read_disabled_bios(struct radeon_device *rdev) | |||
| 341 | 379 | ||
| 342 | static bool radeon_read_disabled_bios(struct radeon_device *rdev) | 380 | static bool radeon_read_disabled_bios(struct radeon_device *rdev) |
| 343 | { | 381 | { |
| 344 | if (rdev->family >= CHIP_RV770) | 382 | if (rdev->flags & RADEON_IS_IGP) |
| 383 | return igp_read_bios_from_vram(rdev); | ||
| 384 | else if (rdev->family >= CHIP_RV770) | ||
| 345 | return r700_read_disabled_bios(rdev); | 385 | return r700_read_disabled_bios(rdev); |
| 346 | else if (rdev->family >= CHIP_R600) | 386 | else if (rdev->family >= CHIP_R600) |
| 347 | return r600_read_disabled_bios(rdev); | 387 | return r600_read_disabled_bios(rdev); |
| @@ -356,7 +396,12 @@ bool radeon_get_bios(struct radeon_device *rdev) | |||
| 356 | bool r; | 396 | bool r; |
| 357 | uint16_t tmp; | 397 | uint16_t tmp; |
| 358 | 398 | ||
| 359 | r = radeon_read_bios(rdev); | 399 | if (rdev->flags & RADEON_IS_IGP) { |
| 400 | r = igp_read_bios_from_vram(rdev); | ||
| 401 | if (r == false) | ||
| 402 | r = radeon_read_bios(rdev); | ||
| 403 | } else | ||
| 404 | r = radeon_read_bios(rdev); | ||
| 360 | if (r == false) { | 405 | if (r == false) { |
| 361 | r = radeon_read_disabled_bios(rdev); | 406 | r = radeon_read_disabled_bios(rdev); |
| 362 | } | 407 | } |
diff --git a/drivers/gpu/drm/radeon/radeon_clocks.c b/drivers/gpu/drm/radeon/radeon_clocks.c index 152eef13197a..f5c32a766b10 100644 --- a/drivers/gpu/drm/radeon/radeon_clocks.c +++ b/drivers/gpu/drm/radeon/radeon_clocks.c | |||
| @@ -411,7 +411,7 @@ void radeon_legacy_set_clock_gating(struct radeon_device *rdev, int enable) | |||
| 411 | R300_PIXCLK_TRANS_ALWAYS_ONb | | 411 | R300_PIXCLK_TRANS_ALWAYS_ONb | |
| 412 | R300_PIXCLK_TVO_ALWAYS_ONb | | 412 | R300_PIXCLK_TVO_ALWAYS_ONb | |
| 413 | R300_P2G2CLK_ALWAYS_ONb | | 413 | R300_P2G2CLK_ALWAYS_ONb | |
| 414 | R300_P2G2CLK_ALWAYS_ONb); | 414 | R300_P2G2CLK_DAC_ALWAYS_ONb); |
| 415 | WREG32_PLL(RADEON_PIXCLKS_CNTL, tmp); | 415 | WREG32_PLL(RADEON_PIXCLKS_CNTL, tmp); |
| 416 | } else if (rdev->family >= CHIP_RV350) { | 416 | } else if (rdev->family >= CHIP_RV350) { |
| 417 | tmp = RREG32_PLL(R300_SCLK_CNTL2); | 417 | tmp = RREG32_PLL(R300_SCLK_CNTL2); |
| @@ -464,7 +464,7 @@ void radeon_legacy_set_clock_gating(struct radeon_device *rdev, int enable) | |||
| 464 | R300_PIXCLK_TRANS_ALWAYS_ONb | | 464 | R300_PIXCLK_TRANS_ALWAYS_ONb | |
| 465 | R300_PIXCLK_TVO_ALWAYS_ONb | | 465 | R300_PIXCLK_TVO_ALWAYS_ONb | |
| 466 | R300_P2G2CLK_ALWAYS_ONb | | 466 | R300_P2G2CLK_ALWAYS_ONb | |
| 467 | R300_P2G2CLK_ALWAYS_ONb); | 467 | R300_P2G2CLK_DAC_ALWAYS_ONb); |
| 468 | WREG32_PLL(RADEON_PIXCLKS_CNTL, tmp); | 468 | WREG32_PLL(RADEON_PIXCLKS_CNTL, tmp); |
| 469 | 469 | ||
| 470 | tmp = RREG32_PLL(RADEON_MCLK_MISC); | 470 | tmp = RREG32_PLL(RADEON_MCLK_MISC); |
| @@ -654,7 +654,7 @@ void radeon_legacy_set_clock_gating(struct radeon_device *rdev, int enable) | |||
| 654 | R300_PIXCLK_TRANS_ALWAYS_ONb | | 654 | R300_PIXCLK_TRANS_ALWAYS_ONb | |
| 655 | R300_PIXCLK_TVO_ALWAYS_ONb | | 655 | R300_PIXCLK_TVO_ALWAYS_ONb | |
| 656 | R300_P2G2CLK_ALWAYS_ONb | | 656 | R300_P2G2CLK_ALWAYS_ONb | |
| 657 | R300_P2G2CLK_ALWAYS_ONb | | 657 | R300_P2G2CLK_DAC_ALWAYS_ONb | |
| 658 | R300_DISP_DAC_PIXCLK_DAC2_BLANK_OFF); | 658 | R300_DISP_DAC_PIXCLK_DAC2_BLANK_OFF); |
| 659 | WREG32_PLL(RADEON_PIXCLKS_CNTL, tmp); | 659 | WREG32_PLL(RADEON_PIXCLKS_CNTL, tmp); |
| 660 | } else if (rdev->family >= CHIP_RV350) { | 660 | } else if (rdev->family >= CHIP_RV350) { |
| @@ -705,7 +705,7 @@ void radeon_legacy_set_clock_gating(struct radeon_device *rdev, int enable) | |||
| 705 | R300_PIXCLK_TRANS_ALWAYS_ONb | | 705 | R300_PIXCLK_TRANS_ALWAYS_ONb | |
| 706 | R300_PIXCLK_TVO_ALWAYS_ONb | | 706 | R300_PIXCLK_TVO_ALWAYS_ONb | |
| 707 | R300_P2G2CLK_ALWAYS_ONb | | 707 | R300_P2G2CLK_ALWAYS_ONb | |
| 708 | R300_P2G2CLK_ALWAYS_ONb | | 708 | R300_P2G2CLK_DAC_ALWAYS_ONb | |
| 709 | R300_DISP_DAC_PIXCLK_DAC2_BLANK_OFF); | 709 | R300_DISP_DAC_PIXCLK_DAC2_BLANK_OFF); |
| 710 | WREG32_PLL(RADEON_PIXCLKS_CNTL, tmp); | 710 | WREG32_PLL(RADEON_PIXCLKS_CNTL, tmp); |
| 711 | } else { | 711 | } else { |
diff --git a/drivers/gpu/drm/radeon/radeon_device.c b/drivers/gpu/drm/radeon/radeon_device.c index ec835d56d30a..3d667031de6e 100644 --- a/drivers/gpu/drm/radeon/radeon_device.c +++ b/drivers/gpu/drm/radeon/radeon_device.c | |||
| @@ -322,10 +322,6 @@ int radeon_asic_init(struct radeon_device *rdev) | |||
| 322 | case CHIP_RV380: | 322 | case CHIP_RV380: |
| 323 | rdev->asic = &r300_asic; | 323 | rdev->asic = &r300_asic; |
| 324 | if (rdev->flags & RADEON_IS_PCIE) { | 324 | if (rdev->flags & RADEON_IS_PCIE) { |
| 325 | rdev->asic->gart_init = &rv370_pcie_gart_init; | ||
| 326 | rdev->asic->gart_fini = &rv370_pcie_gart_fini; | ||
| 327 | rdev->asic->gart_enable = &rv370_pcie_gart_enable; | ||
| 328 | rdev->asic->gart_disable = &rv370_pcie_gart_disable; | ||
| 329 | rdev->asic->gart_tlb_flush = &rv370_pcie_gart_tlb_flush; | 325 | rdev->asic->gart_tlb_flush = &rv370_pcie_gart_tlb_flush; |
| 330 | rdev->asic->gart_set_page = &rv370_pcie_gart_set_page; | 326 | rdev->asic->gart_set_page = &rv370_pcie_gart_set_page; |
| 331 | } | 327 | } |
| @@ -485,7 +481,6 @@ void radeon_combios_fini(struct radeon_device *rdev) | |||
| 485 | static unsigned int radeon_vga_set_decode(void *cookie, bool state) | 481 | static unsigned int radeon_vga_set_decode(void *cookie, bool state) |
| 486 | { | 482 | { |
| 487 | struct radeon_device *rdev = cookie; | 483 | struct radeon_device *rdev = cookie; |
| 488 | |||
| 489 | radeon_vga_set_state(rdev, state); | 484 | radeon_vga_set_state(rdev, state); |
| 490 | if (state) | 485 | if (state) |
| 491 | return VGA_RSRC_LEGACY_IO | VGA_RSRC_LEGACY_MEM | | 486 | return VGA_RSRC_LEGACY_IO | VGA_RSRC_LEGACY_MEM | |
| @@ -493,6 +488,29 @@ static unsigned int radeon_vga_set_decode(void *cookie, bool state) | |||
| 493 | else | 488 | else |
| 494 | return VGA_RSRC_NORMAL_IO | VGA_RSRC_NORMAL_MEM; | 489 | return VGA_RSRC_NORMAL_IO | VGA_RSRC_NORMAL_MEM; |
| 495 | } | 490 | } |
| 491 | |||
| 492 | void radeon_agp_disable(struct radeon_device *rdev) | ||
| 493 | { | ||
| 494 | rdev->flags &= ~RADEON_IS_AGP; | ||
| 495 | if (rdev->family >= CHIP_R600) { | ||
| 496 | DRM_INFO("Forcing AGP to PCIE mode\n"); | ||
| 497 | rdev->flags |= RADEON_IS_PCIE; | ||
| 498 | } else if (rdev->family >= CHIP_RV515 || | ||
| 499 | rdev->family == CHIP_RV380 || | ||
| 500 | rdev->family == CHIP_RV410 || | ||
| 501 | rdev->family == CHIP_R423) { | ||
| 502 | DRM_INFO("Forcing AGP to PCIE mode\n"); | ||
| 503 | rdev->flags |= RADEON_IS_PCIE; | ||
| 504 | rdev->asic->gart_tlb_flush = &rv370_pcie_gart_tlb_flush; | ||
| 505 | rdev->asic->gart_set_page = &rv370_pcie_gart_set_page; | ||
| 506 | } else { | ||
| 507 | DRM_INFO("Forcing AGP to PCI mode\n"); | ||
| 508 | rdev->flags |= RADEON_IS_PCI; | ||
| 509 | rdev->asic->gart_tlb_flush = &r100_pci_gart_tlb_flush; | ||
| 510 | rdev->asic->gart_set_page = &r100_pci_gart_set_page; | ||
| 511 | } | ||
| 512 | } | ||
| 513 | |||
| 496 | /* | 514 | /* |
| 497 | * Radeon device. | 515 | * Radeon device. |
| 498 | */ | 516 | */ |
| @@ -531,32 +549,7 @@ int radeon_device_init(struct radeon_device *rdev, | |||
| 531 | } | 549 | } |
| 532 | 550 | ||
| 533 | if (radeon_agpmode == -1) { | 551 | if (radeon_agpmode == -1) { |
| 534 | rdev->flags &= ~RADEON_IS_AGP; | 552 | radeon_agp_disable(rdev); |
| 535 | if (rdev->family >= CHIP_R600) { | ||
| 536 | DRM_INFO("Forcing AGP to PCIE mode\n"); | ||
| 537 | rdev->flags |= RADEON_IS_PCIE; | ||
| 538 | } else if (rdev->family >= CHIP_RV515 || | ||
| 539 | rdev->family == CHIP_RV380 || | ||
| 540 | rdev->family == CHIP_RV410 || | ||
| 541 | rdev->family == CHIP_R423) { | ||
| 542 | DRM_INFO("Forcing AGP to PCIE mode\n"); | ||
| 543 | rdev->flags |= RADEON_IS_PCIE; | ||
| 544 | rdev->asic->gart_init = &rv370_pcie_gart_init; | ||
| 545 | rdev->asic->gart_fini = &rv370_pcie_gart_fini; | ||
| 546 | rdev->asic->gart_enable = &rv370_pcie_gart_enable; | ||
| 547 | rdev->asic->gart_disable = &rv370_pcie_gart_disable; | ||
| 548 | rdev->asic->gart_tlb_flush = &rv370_pcie_gart_tlb_flush; | ||
| 549 | rdev->asic->gart_set_page = &rv370_pcie_gart_set_page; | ||
| 550 | } else { | ||
| 551 | DRM_INFO("Forcing AGP to PCI mode\n"); | ||
| 552 | rdev->flags |= RADEON_IS_PCI; | ||
| 553 | rdev->asic->gart_init = &r100_pci_gart_init; | ||
| 554 | rdev->asic->gart_fini = &r100_pci_gart_fini; | ||
| 555 | rdev->asic->gart_enable = &r100_pci_gart_enable; | ||
| 556 | rdev->asic->gart_disable = &r100_pci_gart_disable; | ||
| 557 | rdev->asic->gart_tlb_flush = &r100_pci_gart_tlb_flush; | ||
| 558 | rdev->asic->gart_set_page = &r100_pci_gart_set_page; | ||
| 559 | } | ||
| 560 | } | 553 | } |
| 561 | 554 | ||
| 562 | /* set DMA mask + need_dma32 flags. | 555 | /* set DMA mask + need_dma32 flags. |
| @@ -588,111 +581,27 @@ int radeon_device_init(struct radeon_device *rdev, | |||
| 588 | DRM_INFO("register mmio base: 0x%08X\n", (uint32_t)rdev->rmmio_base); | 581 | DRM_INFO("register mmio base: 0x%08X\n", (uint32_t)rdev->rmmio_base); |
| 589 | DRM_INFO("register mmio size: %u\n", (unsigned)rdev->rmmio_size); | 582 | DRM_INFO("register mmio size: %u\n", (unsigned)rdev->rmmio_size); |
| 590 | 583 | ||
| 591 | rdev->new_init_path = false; | ||
| 592 | r = radeon_init(rdev); | ||
| 593 | if (r) { | ||
| 594 | return r; | ||
| 595 | } | ||
| 596 | |||
| 597 | /* if we have > 1 VGA cards, then disable the radeon VGA resources */ | 584 | /* if we have > 1 VGA cards, then disable the radeon VGA resources */ |
| 598 | r = vga_client_register(rdev->pdev, rdev, NULL, radeon_vga_set_decode); | 585 | r = vga_client_register(rdev->pdev, rdev, NULL, radeon_vga_set_decode); |
| 599 | if (r) { | 586 | if (r) { |
| 600 | return -EINVAL; | 587 | return -EINVAL; |
| 601 | } | 588 | } |
| 602 | 589 | ||
| 603 | if (!rdev->new_init_path) { | 590 | r = radeon_init(rdev); |
| 604 | /* Setup errata flags */ | 591 | if (r) |
| 605 | radeon_errata(rdev); | 592 | return r; |
| 606 | /* Initialize scratch registers */ | ||
| 607 | radeon_scratch_init(rdev); | ||
| 608 | /* Initialize surface registers */ | ||
| 609 | radeon_surface_init(rdev); | ||
| 610 | |||
| 611 | /* BIOS*/ | ||
| 612 | if (!radeon_get_bios(rdev)) { | ||
| 613 | if (ASIC_IS_AVIVO(rdev)) | ||
| 614 | return -EINVAL; | ||
| 615 | } | ||
| 616 | if (rdev->is_atom_bios) { | ||
| 617 | r = radeon_atombios_init(rdev); | ||
| 618 | if (r) { | ||
| 619 | return r; | ||
| 620 | } | ||
| 621 | } else { | ||
| 622 | r = radeon_combios_init(rdev); | ||
| 623 | if (r) { | ||
| 624 | return r; | ||
| 625 | } | ||
| 626 | } | ||
| 627 | /* Reset gpu before posting otherwise ATOM will enter infinite loop */ | ||
| 628 | if (radeon_gpu_reset(rdev)) { | ||
| 629 | /* FIXME: what do we want to do here ? */ | ||
| 630 | } | ||
| 631 | /* check if cards are posted or not */ | ||
| 632 | if (!radeon_card_posted(rdev) && rdev->bios) { | ||
| 633 | DRM_INFO("GPU not posted. posting now...\n"); | ||
| 634 | if (rdev->is_atom_bios) { | ||
| 635 | atom_asic_init(rdev->mode_info.atom_context); | ||
| 636 | } else { | ||
| 637 | radeon_combios_asic_init(rdev->ddev); | ||
| 638 | } | ||
| 639 | } | ||
| 640 | /* Get clock & vram information */ | ||
| 641 | radeon_get_clock_info(rdev->ddev); | ||
| 642 | radeon_vram_info(rdev); | ||
| 643 | /* Initialize clocks */ | ||
| 644 | r = radeon_clocks_init(rdev); | ||
| 645 | if (r) { | ||
| 646 | return r; | ||
| 647 | } | ||
| 648 | 593 | ||
| 649 | /* Initialize memory controller (also test AGP) */ | 594 | if (rdev->flags & RADEON_IS_AGP && !rdev->accel_working) { |
| 650 | r = radeon_mc_init(rdev); | 595 | /* Acceleration not working on AGP card try again |
| 651 | if (r) { | 596 | * with fallback to PCI or PCIE GART |
| 652 | return r; | 597 | */ |
| 653 | } | 598 | radeon_gpu_reset(rdev); |
| 654 | /* Fence driver */ | 599 | radeon_fini(rdev); |
| 655 | r = radeon_fence_driver_init(rdev); | 600 | radeon_agp_disable(rdev); |
| 656 | if (r) { | 601 | r = radeon_init(rdev); |
| 657 | return r; | ||
| 658 | } | ||
| 659 | r = radeon_irq_kms_init(rdev); | ||
| 660 | if (r) { | ||
| 661 | return r; | ||
| 662 | } | ||
| 663 | /* Memory manager */ | ||
| 664 | r = radeon_object_init(rdev); | ||
| 665 | if (r) { | ||
| 666 | return r; | ||
| 667 | } | ||
| 668 | r = radeon_gpu_gart_init(rdev); | ||
| 669 | if (r) | 602 | if (r) |
| 670 | return r; | 603 | return r; |
| 671 | /* Initialize GART (initialize after TTM so we can allocate | ||
| 672 | * memory through TTM but finalize after TTM) */ | ||
| 673 | r = radeon_gart_enable(rdev); | ||
| 674 | if (r) | ||
| 675 | return 0; | ||
| 676 | r = radeon_gem_init(rdev); | ||
| 677 | if (r) | ||
| 678 | return 0; | ||
| 679 | |||
| 680 | /* 1M ring buffer */ | ||
| 681 | r = radeon_cp_init(rdev, 1024 * 1024); | ||
| 682 | if (r) | ||
| 683 | return 0; | ||
| 684 | r = radeon_wb_init(rdev); | ||
| 685 | if (r) | ||
| 686 | DRM_ERROR("radeon: failled initializing WB (%d).\n", r); | ||
| 687 | r = radeon_ib_pool_init(rdev); | ||
| 688 | if (r) | ||
| 689 | return 0; | ||
| 690 | r = radeon_ib_test(rdev); | ||
| 691 | if (r) | ||
| 692 | return 0; | ||
| 693 | rdev->accel_working = true; | ||
| 694 | } | 604 | } |
| 695 | DRM_INFO("radeon: kernel modesetting successfully initialized.\n"); | ||
| 696 | if (radeon_testing) { | 605 | if (radeon_testing) { |
| 697 | radeon_test_moves(rdev); | 606 | radeon_test_moves(rdev); |
| 698 | } | 607 | } |
| @@ -706,32 +615,8 @@ void radeon_device_fini(struct radeon_device *rdev) | |||
| 706 | { | 615 | { |
| 707 | DRM_INFO("radeon: finishing device.\n"); | 616 | DRM_INFO("radeon: finishing device.\n"); |
| 708 | rdev->shutdown = true; | 617 | rdev->shutdown = true; |
| 709 | /* Order matter so becarefull if you rearrange anythings */ | 618 | radeon_fini(rdev); |
| 710 | if (!rdev->new_init_path) { | 619 | vga_client_register(rdev->pdev, NULL, NULL, NULL); |
| 711 | radeon_ib_pool_fini(rdev); | ||
| 712 | radeon_cp_fini(rdev); | ||
| 713 | radeon_wb_fini(rdev); | ||
| 714 | radeon_gpu_gart_fini(rdev); | ||
| 715 | radeon_gem_fini(rdev); | ||
| 716 | radeon_mc_fini(rdev); | ||
| 717 | #if __OS_HAS_AGP | ||
| 718 | radeon_agp_fini(rdev); | ||
| 719 | #endif | ||
| 720 | radeon_irq_kms_fini(rdev); | ||
| 721 | vga_client_register(rdev->pdev, NULL, NULL, NULL); | ||
| 722 | radeon_fence_driver_fini(rdev); | ||
| 723 | radeon_clocks_fini(rdev); | ||
| 724 | radeon_object_fini(rdev); | ||
| 725 | if (rdev->is_atom_bios) { | ||
| 726 | radeon_atombios_fini(rdev); | ||
| 727 | } else { | ||
| 728 | radeon_combios_fini(rdev); | ||
| 729 | } | ||
| 730 | kfree(rdev->bios); | ||
| 731 | rdev->bios = NULL; | ||
| 732 | } else { | ||
| 733 | radeon_fini(rdev); | ||
| 734 | } | ||
| 735 | iounmap(rdev->rmmio); | 620 | iounmap(rdev->rmmio); |
| 736 | rdev->rmmio = NULL; | 621 | rdev->rmmio = NULL; |
| 737 | } | 622 | } |
| @@ -771,14 +656,7 @@ int radeon_suspend_kms(struct drm_device *dev, pm_message_t state) | |||
| 771 | 656 | ||
| 772 | radeon_save_bios_scratch_regs(rdev); | 657 | radeon_save_bios_scratch_regs(rdev); |
| 773 | 658 | ||
| 774 | if (!rdev->new_init_path) { | 659 | radeon_suspend(rdev); |
| 775 | radeon_cp_disable(rdev); | ||
| 776 | radeon_gart_disable(rdev); | ||
| 777 | rdev->irq.sw_int = false; | ||
| 778 | radeon_irq_set(rdev); | ||
| 779 | } else { | ||
| 780 | radeon_suspend(rdev); | ||
| 781 | } | ||
| 782 | /* evict remaining vram memory */ | 660 | /* evict remaining vram memory */ |
| 783 | radeon_object_evict_vram(rdev); | 661 | radeon_object_evict_vram(rdev); |
| 784 | 662 | ||
| @@ -797,7 +675,6 @@ int radeon_suspend_kms(struct drm_device *dev, pm_message_t state) | |||
| 797 | int radeon_resume_kms(struct drm_device *dev) | 675 | int radeon_resume_kms(struct drm_device *dev) |
| 798 | { | 676 | { |
| 799 | struct radeon_device *rdev = dev->dev_private; | 677 | struct radeon_device *rdev = dev->dev_private; |
| 800 | int r; | ||
| 801 | 678 | ||
| 802 | acquire_console_sem(); | 679 | acquire_console_sem(); |
| 803 | pci_set_power_state(dev->pdev, PCI_D0); | 680 | pci_set_power_state(dev->pdev, PCI_D0); |
| @@ -807,43 +684,7 @@ int radeon_resume_kms(struct drm_device *dev) | |||
| 807 | return -1; | 684 | return -1; |
| 808 | } | 685 | } |
| 809 | pci_set_master(dev->pdev); | 686 | pci_set_master(dev->pdev); |
| 810 | /* Reset gpu before posting otherwise ATOM will enter infinite loop */ | 687 | radeon_resume(rdev); |
| 811 | if (!rdev->new_init_path) { | ||
| 812 | if (radeon_gpu_reset(rdev)) { | ||
| 813 | /* FIXME: what do we want to do here ? */ | ||
| 814 | } | ||
| 815 | /* post card */ | ||
| 816 | if (rdev->is_atom_bios) { | ||
| 817 | atom_asic_init(rdev->mode_info.atom_context); | ||
| 818 | } else { | ||
| 819 | radeon_combios_asic_init(rdev->ddev); | ||
| 820 | } | ||
| 821 | /* Initialize clocks */ | ||
| 822 | r = radeon_clocks_init(rdev); | ||
| 823 | if (r) { | ||
| 824 | release_console_sem(); | ||
| 825 | return r; | ||
| 826 | } | ||
| 827 | /* Enable IRQ */ | ||
| 828 | rdev->irq.sw_int = true; | ||
| 829 | radeon_irq_set(rdev); | ||
| 830 | /* Initialize GPU Memory Controller */ | ||
| 831 | r = radeon_mc_init(rdev); | ||
| 832 | if (r) { | ||
| 833 | goto out; | ||
| 834 | } | ||
| 835 | r = radeon_gart_enable(rdev); | ||
| 836 | if (r) { | ||
| 837 | goto out; | ||
| 838 | } | ||
| 839 | r = radeon_cp_init(rdev, rdev->cp.ring_size); | ||
| 840 | if (r) { | ||
| 841 | goto out; | ||
| 842 | } | ||
| 843 | } else { | ||
| 844 | radeon_resume(rdev); | ||
| 845 | } | ||
| 846 | out: | ||
| 847 | radeon_restore_bios_scratch_regs(rdev); | 688 | radeon_restore_bios_scratch_regs(rdev); |
| 848 | fb_set_suspend(rdev->fbdev_info, 0); | 689 | fb_set_suspend(rdev->fbdev_info, 0); |
| 849 | release_console_sem(); | 690 | release_console_sem(); |
diff --git a/drivers/gpu/drm/radeon/radeon_display.c b/drivers/gpu/drm/radeon/radeon_display.c index 5d8141b13765..3655d91993a6 100644 --- a/drivers/gpu/drm/radeon/radeon_display.c +++ b/drivers/gpu/drm/radeon/radeon_display.c | |||
| @@ -106,24 +106,33 @@ void radeon_crtc_load_lut(struct drm_crtc *crtc) | |||
| 106 | legacy_crtc_load_lut(crtc); | 106 | legacy_crtc_load_lut(crtc); |
| 107 | } | 107 | } |
| 108 | 108 | ||
| 109 | /** Sets the color ramps on behalf of RandR */ | 109 | /** Sets the color ramps on behalf of fbcon */ |
| 110 | void radeon_crtc_fb_gamma_set(struct drm_crtc *crtc, u16 red, u16 green, | 110 | void radeon_crtc_fb_gamma_set(struct drm_crtc *crtc, u16 red, u16 green, |
| 111 | u16 blue, int regno) | 111 | u16 blue, int regno) |
| 112 | { | 112 | { |
| 113 | struct radeon_crtc *radeon_crtc = to_radeon_crtc(crtc); | 113 | struct radeon_crtc *radeon_crtc = to_radeon_crtc(crtc); |
| 114 | 114 | ||
| 115 | if (regno == 0) | ||
| 116 | DRM_DEBUG("gamma set %d\n", radeon_crtc->crtc_id); | ||
| 117 | radeon_crtc->lut_r[regno] = red >> 6; | 115 | radeon_crtc->lut_r[regno] = red >> 6; |
| 118 | radeon_crtc->lut_g[regno] = green >> 6; | 116 | radeon_crtc->lut_g[regno] = green >> 6; |
| 119 | radeon_crtc->lut_b[regno] = blue >> 6; | 117 | radeon_crtc->lut_b[regno] = blue >> 6; |
| 120 | } | 118 | } |
| 121 | 119 | ||
| 120 | /** Gets the color ramps on behalf of fbcon */ | ||
| 121 | void radeon_crtc_fb_gamma_get(struct drm_crtc *crtc, u16 *red, u16 *green, | ||
| 122 | u16 *blue, int regno) | ||
| 123 | { | ||
| 124 | struct radeon_crtc *radeon_crtc = to_radeon_crtc(crtc); | ||
| 125 | |||
| 126 | *red = radeon_crtc->lut_r[regno] << 6; | ||
| 127 | *green = radeon_crtc->lut_g[regno] << 6; | ||
| 128 | *blue = radeon_crtc->lut_b[regno] << 6; | ||
| 129 | } | ||
| 130 | |||
| 122 | static void radeon_crtc_gamma_set(struct drm_crtc *crtc, u16 *red, u16 *green, | 131 | static void radeon_crtc_gamma_set(struct drm_crtc *crtc, u16 *red, u16 *green, |
| 123 | u16 *blue, uint32_t size) | 132 | u16 *blue, uint32_t size) |
| 124 | { | 133 | { |
| 125 | struct radeon_crtc *radeon_crtc = to_radeon_crtc(crtc); | 134 | struct radeon_crtc *radeon_crtc = to_radeon_crtc(crtc); |
| 126 | int i, j; | 135 | int i; |
| 127 | 136 | ||
| 128 | if (size != 256) { | 137 | if (size != 256) { |
| 129 | return; | 138 | return; |
| @@ -132,23 +141,11 @@ static void radeon_crtc_gamma_set(struct drm_crtc *crtc, u16 *red, u16 *green, | |||
| 132 | return; | 141 | return; |
| 133 | } | 142 | } |
| 134 | 143 | ||
| 135 | if (crtc->fb->depth == 16) { | 144 | /* userspace palettes are always correct as is */ |
| 136 | for (i = 0; i < 64; i++) { | 145 | for (i = 0; i < 256; i++) { |
| 137 | if (i <= 31) { | 146 | radeon_crtc->lut_r[i] = red[i] >> 6; |
| 138 | for (j = 0; j < 8; j++) { | 147 | radeon_crtc->lut_g[i] = green[i] >> 6; |
| 139 | radeon_crtc->lut_r[i * 8 + j] = red[i] >> 6; | 148 | radeon_crtc->lut_b[i] = blue[i] >> 6; |
| 140 | radeon_crtc->lut_b[i * 8 + j] = blue[i] >> 6; | ||
| 141 | } | ||
| 142 | } | ||
| 143 | for (j = 0; j < 4; j++) | ||
| 144 | radeon_crtc->lut_g[i * 4 + j] = green[i] >> 6; | ||
| 145 | } | ||
| 146 | } else { | ||
| 147 | for (i = 0; i < 256; i++) { | ||
| 148 | radeon_crtc->lut_r[i] = red[i] >> 6; | ||
| 149 | radeon_crtc->lut_g[i] = green[i] >> 6; | ||
| 150 | radeon_crtc->lut_b[i] = blue[i] >> 6; | ||
| 151 | } | ||
| 152 | } | 149 | } |
| 153 | 150 | ||
| 154 | radeon_crtc_load_lut(crtc); | 151 | radeon_crtc_load_lut(crtc); |
| @@ -724,7 +721,11 @@ int radeon_modeset_init(struct radeon_device *rdev) | |||
| 724 | if (ret) { | 721 | if (ret) { |
| 725 | return ret; | 722 | return ret; |
| 726 | } | 723 | } |
| 727 | /* allocate crtcs - TODO single crtc */ | 724 | |
| 725 | if (rdev->flags & RADEON_SINGLE_CRTC) | ||
| 726 | num_crtc = 1; | ||
| 727 | |||
| 728 | /* allocate crtcs */ | ||
| 728 | for (i = 0; i < num_crtc; i++) { | 729 | for (i = 0; i < num_crtc; i++) { |
| 729 | radeon_crtc_init(rdev->ddev, i); | 730 | radeon_crtc_init(rdev->ddev, i); |
| 730 | } | 731 | } |
diff --git a/drivers/gpu/drm/radeon/radeon_encoders.c b/drivers/gpu/drm/radeon/radeon_encoders.c index 621646752cd2..a65ab1a0dad2 100644 --- a/drivers/gpu/drm/radeon/radeon_encoders.c +++ b/drivers/gpu/drm/radeon/radeon_encoders.c | |||
| @@ -1345,6 +1345,7 @@ radeon_atombios_set_dig_info(struct radeon_encoder *radeon_encoder) | |||
| 1345 | void | 1345 | void |
| 1346 | radeon_add_atom_encoder(struct drm_device *dev, uint32_t encoder_id, uint32_t supported_device) | 1346 | radeon_add_atom_encoder(struct drm_device *dev, uint32_t encoder_id, uint32_t supported_device) |
| 1347 | { | 1347 | { |
| 1348 | struct radeon_device *rdev = dev->dev_private; | ||
| 1348 | struct drm_encoder *encoder; | 1349 | struct drm_encoder *encoder; |
| 1349 | struct radeon_encoder *radeon_encoder; | 1350 | struct radeon_encoder *radeon_encoder; |
| 1350 | 1351 | ||
| @@ -1364,7 +1365,10 @@ radeon_add_atom_encoder(struct drm_device *dev, uint32_t encoder_id, uint32_t su | |||
| 1364 | return; | 1365 | return; |
| 1365 | 1366 | ||
| 1366 | encoder = &radeon_encoder->base; | 1367 | encoder = &radeon_encoder->base; |
| 1367 | encoder->possible_crtcs = 0x3; | 1368 | if (rdev->flags & RADEON_SINGLE_CRTC) |
| 1369 | encoder->possible_crtcs = 0x1; | ||
| 1370 | else | ||
| 1371 | encoder->possible_crtcs = 0x3; | ||
| 1368 | encoder->possible_clones = 0; | 1372 | encoder->possible_clones = 0; |
| 1369 | 1373 | ||
| 1370 | radeon_encoder->enc_priv = NULL; | 1374 | radeon_encoder->enc_priv = NULL; |
diff --git a/drivers/gpu/drm/radeon/radeon_fb.c b/drivers/gpu/drm/radeon/radeon_fb.c index 1ba704eedefb..b38c4c8e2c61 100644 --- a/drivers/gpu/drm/radeon/radeon_fb.c +++ b/drivers/gpu/drm/radeon/radeon_fb.c | |||
| @@ -55,6 +55,7 @@ static struct fb_ops radeonfb_ops = { | |||
| 55 | .fb_imageblit = cfb_imageblit, | 55 | .fb_imageblit = cfb_imageblit, |
| 56 | .fb_pan_display = drm_fb_helper_pan_display, | 56 | .fb_pan_display = drm_fb_helper_pan_display, |
| 57 | .fb_blank = drm_fb_helper_blank, | 57 | .fb_blank = drm_fb_helper_blank, |
| 58 | .fb_setcmap = drm_fb_helper_setcmap, | ||
| 58 | }; | 59 | }; |
| 59 | 60 | ||
| 60 | /** | 61 | /** |
| @@ -123,6 +124,7 @@ static int radeon_align_pitch(struct radeon_device *rdev, int width, int bpp, bo | |||
| 123 | 124 | ||
| 124 | static struct drm_fb_helper_funcs radeon_fb_helper_funcs = { | 125 | static struct drm_fb_helper_funcs radeon_fb_helper_funcs = { |
| 125 | .gamma_set = radeon_crtc_fb_gamma_set, | 126 | .gamma_set = radeon_crtc_fb_gamma_set, |
| 127 | .gamma_get = radeon_crtc_fb_gamma_get, | ||
| 126 | }; | 128 | }; |
| 127 | 129 | ||
| 128 | int radeonfb_create(struct drm_device *dev, | 130 | int radeonfb_create(struct drm_device *dev, |
| @@ -146,9 +148,15 @@ int radeonfb_create(struct drm_device *dev, | |||
| 146 | unsigned long tmp; | 148 | unsigned long tmp; |
| 147 | bool fb_tiled = false; /* useful for testing */ | 149 | bool fb_tiled = false; /* useful for testing */ |
| 148 | u32 tiling_flags = 0; | 150 | u32 tiling_flags = 0; |
| 151 | int crtc_count; | ||
| 149 | 152 | ||
| 150 | mode_cmd.width = surface_width; | 153 | mode_cmd.width = surface_width; |
| 151 | mode_cmd.height = surface_height; | 154 | mode_cmd.height = surface_height; |
| 155 | |||
| 156 | /* avivo can't scanout real 24bpp */ | ||
| 157 | if ((surface_bpp == 24) && ASIC_IS_AVIVO(rdev)) | ||
| 158 | surface_bpp = 32; | ||
| 159 | |||
| 152 | mode_cmd.bpp = surface_bpp; | 160 | mode_cmd.bpp = surface_bpp; |
| 153 | /* need to align pitch with crtc limits */ | 161 | /* need to align pitch with crtc limits */ |
| 154 | mode_cmd.pitch = radeon_align_pitch(rdev, mode_cmd.width, mode_cmd.bpp, fb_tiled) * ((mode_cmd.bpp + 1) / 8); | 162 | mode_cmd.pitch = radeon_align_pitch(rdev, mode_cmd.width, mode_cmd.bpp, fb_tiled) * ((mode_cmd.bpp + 1) / 8); |
| @@ -217,7 +225,11 @@ int radeonfb_create(struct drm_device *dev, | |||
| 217 | rfbdev = info->par; | 225 | rfbdev = info->par; |
| 218 | rfbdev->helper.funcs = &radeon_fb_helper_funcs; | 226 | rfbdev->helper.funcs = &radeon_fb_helper_funcs; |
| 219 | rfbdev->helper.dev = dev; | 227 | rfbdev->helper.dev = dev; |
| 220 | ret = drm_fb_helper_init_crtc_count(&rfbdev->helper, 2, | 228 | if (rdev->flags & RADEON_SINGLE_CRTC) |
| 229 | crtc_count = 1; | ||
| 230 | else | ||
| 231 | crtc_count = 2; | ||
| 232 | ret = drm_fb_helper_init_crtc_count(&rfbdev->helper, crtc_count, | ||
| 221 | RADEONFB_CONN_LIMIT); | 233 | RADEONFB_CONN_LIMIT); |
| 222 | if (ret) | 234 | if (ret) |
| 223 | goto out_unref; | 235 | goto out_unref; |
| @@ -234,7 +246,7 @@ int radeonfb_create(struct drm_device *dev, | |||
| 234 | 246 | ||
| 235 | strcpy(info->fix.id, "radeondrmfb"); | 247 | strcpy(info->fix.id, "radeondrmfb"); |
| 236 | 248 | ||
| 237 | drm_fb_helper_fill_fix(info, fb->pitch); | 249 | drm_fb_helper_fill_fix(info, fb->pitch, fb->depth); |
| 238 | 250 | ||
| 239 | info->flags = FBINFO_DEFAULT; | 251 | info->flags = FBINFO_DEFAULT; |
| 240 | info->fbops = &radeonfb_ops; | 252 | info->fbops = &radeonfb_ops; |
| @@ -309,7 +321,7 @@ int radeon_parse_options(char *options) | |||
| 309 | 321 | ||
| 310 | int radeonfb_probe(struct drm_device *dev) | 322 | int radeonfb_probe(struct drm_device *dev) |
| 311 | { | 323 | { |
| 312 | return drm_fb_helper_single_fb_probe(dev, &radeonfb_create); | 324 | return drm_fb_helper_single_fb_probe(dev, 32, &radeonfb_create); |
| 313 | } | 325 | } |
| 314 | 326 | ||
| 315 | int radeonfb_remove(struct drm_device *dev, struct drm_framebuffer *fb) | 327 | int radeonfb_remove(struct drm_device *dev, struct drm_framebuffer *fb) |
diff --git a/drivers/gpu/drm/radeon/radeon_irq_kms.c b/drivers/gpu/drm/radeon/radeon_irq_kms.c index 1841145a7c4f..8e0a8759e428 100644 --- a/drivers/gpu/drm/radeon/radeon_irq_kms.c +++ b/drivers/gpu/drm/radeon/radeon_irq_kms.c | |||
| @@ -83,8 +83,12 @@ void radeon_driver_irq_uninstall_kms(struct drm_device *dev) | |||
| 83 | int radeon_irq_kms_init(struct radeon_device *rdev) | 83 | int radeon_irq_kms_init(struct radeon_device *rdev) |
| 84 | { | 84 | { |
| 85 | int r = 0; | 85 | int r = 0; |
| 86 | int num_crtc = 2; | ||
| 86 | 87 | ||
| 87 | r = drm_vblank_init(rdev->ddev, 2); | 88 | if (rdev->flags & RADEON_SINGLE_CRTC) |
| 89 | num_crtc = 1; | ||
| 90 | |||
| 91 | r = drm_vblank_init(rdev->ddev, num_crtc); | ||
| 88 | if (r) { | 92 | if (r) { |
| 89 | return r; | 93 | return r; |
| 90 | } | 94 | } |
diff --git a/drivers/gpu/drm/radeon/radeon_legacy_crtc.c b/drivers/gpu/drm/radeon/radeon_legacy_crtc.c index 2b997a15fb1f..36410f85d705 100644 --- a/drivers/gpu/drm/radeon/radeon_legacy_crtc.c +++ b/drivers/gpu/drm/radeon/radeon_legacy_crtc.c | |||
| @@ -1053,6 +1053,7 @@ static const struct drm_crtc_helper_funcs legacy_helper_funcs = { | |||
| 1053 | .mode_set_base = radeon_crtc_set_base, | 1053 | .mode_set_base = radeon_crtc_set_base, |
| 1054 | .prepare = radeon_crtc_prepare, | 1054 | .prepare = radeon_crtc_prepare, |
| 1055 | .commit = radeon_crtc_commit, | 1055 | .commit = radeon_crtc_commit, |
| 1056 | .load_lut = radeon_crtc_load_lut, | ||
| 1056 | }; | 1057 | }; |
| 1057 | 1058 | ||
| 1058 | 1059 | ||
diff --git a/drivers/gpu/drm/radeon/radeon_legacy_encoders.c b/drivers/gpu/drm/radeon/radeon_legacy_encoders.c index b1547f700d73..6ceb958fd194 100644 --- a/drivers/gpu/drm/radeon/radeon_legacy_encoders.c +++ b/drivers/gpu/drm/radeon/radeon_legacy_encoders.c | |||
| @@ -881,7 +881,7 @@ static void radeon_legacy_tv_dac_mode_set(struct drm_encoder *encoder, | |||
| 881 | R420_TV_DAC_DACADJ_MASK | | 881 | R420_TV_DAC_DACADJ_MASK | |
| 882 | R420_TV_DAC_RDACPD | | 882 | R420_TV_DAC_RDACPD | |
| 883 | R420_TV_DAC_GDACPD | | 883 | R420_TV_DAC_GDACPD | |
| 884 | R420_TV_DAC_GDACPD | | 884 | R420_TV_DAC_BDACPD | |
| 885 | R420_TV_DAC_TVENABLE); | 885 | R420_TV_DAC_TVENABLE); |
| 886 | } else { | 886 | } else { |
| 887 | tv_dac_cntl &= ~(RADEON_TV_DAC_STD_MASK | | 887 | tv_dac_cntl &= ~(RADEON_TV_DAC_STD_MASK | |
| @@ -889,7 +889,7 @@ static void radeon_legacy_tv_dac_mode_set(struct drm_encoder *encoder, | |||
| 889 | RADEON_TV_DAC_DACADJ_MASK | | 889 | RADEON_TV_DAC_DACADJ_MASK | |
| 890 | RADEON_TV_DAC_RDACPD | | 890 | RADEON_TV_DAC_RDACPD | |
| 891 | RADEON_TV_DAC_GDACPD | | 891 | RADEON_TV_DAC_GDACPD | |
| 892 | RADEON_TV_DAC_GDACPD); | 892 | RADEON_TV_DAC_BDACPD); |
| 893 | } | 893 | } |
| 894 | 894 | ||
| 895 | /* FIXME TV */ | 895 | /* FIXME TV */ |
| @@ -1318,7 +1318,10 @@ radeon_add_legacy_encoder(struct drm_device *dev, uint32_t encoder_id, uint32_t | |||
| 1318 | return; | 1318 | return; |
| 1319 | 1319 | ||
| 1320 | encoder = &radeon_encoder->base; | 1320 | encoder = &radeon_encoder->base; |
| 1321 | encoder->possible_crtcs = 0x3; | 1321 | if (rdev->flags & RADEON_SINGLE_CRTC) |
| 1322 | encoder->possible_crtcs = 0x1; | ||
| 1323 | else | ||
| 1324 | encoder->possible_crtcs = 0x3; | ||
| 1322 | encoder->possible_clones = 0; | 1325 | encoder->possible_clones = 0; |
| 1323 | 1326 | ||
| 1324 | radeon_encoder->enc_priv = NULL; | 1327 | radeon_encoder->enc_priv = NULL; |
diff --git a/drivers/gpu/drm/radeon/radeon_mode.h b/drivers/gpu/drm/radeon/radeon_mode.h index 570a58729daf..e61226817ccf 100644 --- a/drivers/gpu/drm/radeon/radeon_mode.h +++ b/drivers/gpu/drm/radeon/radeon_mode.h | |||
| @@ -407,6 +407,8 @@ extern void | |||
| 407 | radeon_combios_encoder_dpms_scratch_regs(struct drm_encoder *encoder, bool on); | 407 | radeon_combios_encoder_dpms_scratch_regs(struct drm_encoder *encoder, bool on); |
| 408 | extern void radeon_crtc_fb_gamma_set(struct drm_crtc *crtc, u16 red, u16 green, | 408 | extern void radeon_crtc_fb_gamma_set(struct drm_crtc *crtc, u16 red, u16 green, |
| 409 | u16 blue, int regno); | 409 | u16 blue, int regno); |
| 410 | extern void radeon_crtc_fb_gamma_get(struct drm_crtc *crtc, u16 *red, u16 *green, | ||
| 411 | u16 *blue, int regno); | ||
| 410 | struct drm_framebuffer *radeon_framebuffer_create(struct drm_device *dev, | 412 | struct drm_framebuffer *radeon_framebuffer_create(struct drm_device *dev, |
| 411 | struct drm_mode_fb_cmd *mode_cmd, | 413 | struct drm_mode_fb_cmd *mode_cmd, |
| 412 | struct drm_gem_object *obj); | 414 | struct drm_gem_object *obj); |
diff --git a/drivers/gpu/drm/radeon/radeon_object.c b/drivers/gpu/drm/radeon/radeon_object.c index 73af463b7a59..1f056dadc5c2 100644 --- a/drivers/gpu/drm/radeon/radeon_object.c +++ b/drivers/gpu/drm/radeon/radeon_object.c | |||
| @@ -400,11 +400,9 @@ void radeon_object_list_add_object(struct radeon_object_list *lobj, | |||
| 400 | int radeon_object_list_reserve(struct list_head *head) | 400 | int radeon_object_list_reserve(struct list_head *head) |
| 401 | { | 401 | { |
| 402 | struct radeon_object_list *lobj; | 402 | struct radeon_object_list *lobj; |
| 403 | struct list_head *i; | ||
| 404 | int r; | 403 | int r; |
| 405 | 404 | ||
| 406 | list_for_each(i, head) { | 405 | list_for_each_entry(lobj, head, list){ |
| 407 | lobj = list_entry(i, struct radeon_object_list, list); | ||
| 408 | if (!lobj->robj->pin_count) { | 406 | if (!lobj->robj->pin_count) { |
| 409 | r = radeon_object_reserve(lobj->robj, true); | 407 | r = radeon_object_reserve(lobj->robj, true); |
| 410 | if (unlikely(r != 0)) { | 408 | if (unlikely(r != 0)) { |
| @@ -420,13 +418,10 @@ int radeon_object_list_reserve(struct list_head *head) | |||
| 420 | void radeon_object_list_unreserve(struct list_head *head) | 418 | void radeon_object_list_unreserve(struct list_head *head) |
| 421 | { | 419 | { |
| 422 | struct radeon_object_list *lobj; | 420 | struct radeon_object_list *lobj; |
| 423 | struct list_head *i; | ||
| 424 | 421 | ||
| 425 | list_for_each(i, head) { | 422 | list_for_each_entry(lobj, head, list) { |
| 426 | lobj = list_entry(i, struct radeon_object_list, list); | ||
| 427 | if (!lobj->robj->pin_count) { | 423 | if (!lobj->robj->pin_count) { |
| 428 | radeon_object_unreserve(lobj->robj); | 424 | radeon_object_unreserve(lobj->robj); |
| 429 | } else { | ||
| 430 | } | 425 | } |
| 431 | } | 426 | } |
| 432 | } | 427 | } |
| @@ -436,7 +431,6 @@ int radeon_object_list_validate(struct list_head *head, void *fence) | |||
| 436 | struct radeon_object_list *lobj; | 431 | struct radeon_object_list *lobj; |
| 437 | struct radeon_object *robj; | 432 | struct radeon_object *robj; |
| 438 | struct radeon_fence *old_fence = NULL; | 433 | struct radeon_fence *old_fence = NULL; |
| 439 | struct list_head *i; | ||
| 440 | int r; | 434 | int r; |
| 441 | 435 | ||
| 442 | r = radeon_object_list_reserve(head); | 436 | r = radeon_object_list_reserve(head); |
| @@ -444,8 +438,7 @@ int radeon_object_list_validate(struct list_head *head, void *fence) | |||
| 444 | radeon_object_list_unreserve(head); | 438 | radeon_object_list_unreserve(head); |
| 445 | return r; | 439 | return r; |
| 446 | } | 440 | } |
| 447 | list_for_each(i, head) { | 441 | list_for_each_entry(lobj, head, list) { |
| 448 | lobj = list_entry(i, struct radeon_object_list, list); | ||
| 449 | robj = lobj->robj; | 442 | robj = lobj->robj; |
| 450 | if (!robj->pin_count) { | 443 | if (!robj->pin_count) { |
| 451 | if (lobj->wdomain) { | 444 | if (lobj->wdomain) { |
| @@ -482,10 +475,8 @@ void radeon_object_list_unvalidate(struct list_head *head) | |||
| 482 | { | 475 | { |
| 483 | struct radeon_object_list *lobj; | 476 | struct radeon_object_list *lobj; |
| 484 | struct radeon_fence *old_fence = NULL; | 477 | struct radeon_fence *old_fence = NULL; |
| 485 | struct list_head *i; | ||
| 486 | 478 | ||
| 487 | list_for_each(i, head) { | 479 | list_for_each_entry(lobj, head, list) { |
| 488 | lobj = list_entry(i, struct radeon_object_list, list); | ||
| 489 | old_fence = (struct radeon_fence *)lobj->robj->tobj.sync_obj; | 480 | old_fence = (struct radeon_fence *)lobj->robj->tobj.sync_obj; |
| 490 | lobj->robj->tobj.sync_obj = NULL; | 481 | lobj->robj->tobj.sync_obj = NULL; |
| 491 | if (old_fence) { | 482 | if (old_fence) { |
diff --git a/drivers/gpu/drm/radeon/rs100d.h b/drivers/gpu/drm/radeon/rs100d.h new file mode 100644 index 000000000000..48a913a06cfd --- /dev/null +++ b/drivers/gpu/drm/radeon/rs100d.h | |||
| @@ -0,0 +1,40 @@ | |||
| 1 | /* | ||
| 2 | * Copyright 2008 Advanced Micro Devices, Inc. | ||
| 3 | * Copyright 2008 Red Hat Inc. | ||
| 4 | * Copyright 2009 Jerome Glisse. | ||
| 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: Dave Airlie | ||
| 25 | * Alex Deucher | ||
| 26 | * Jerome Glisse | ||
| 27 | */ | ||
| 28 | #ifndef __RS100D_H__ | ||
| 29 | #define __RS100D_H__ | ||
| 30 | |||
| 31 | /* Registers */ | ||
| 32 | #define R_00015C_NB_TOM 0x00015C | ||
| 33 | #define S_00015C_MC_FB_START(x) (((x) & 0xFFFF) << 0) | ||
| 34 | #define G_00015C_MC_FB_START(x) (((x) >> 0) & 0xFFFF) | ||
| 35 | #define C_00015C_MC_FB_START 0xFFFF0000 | ||
| 36 | #define S_00015C_MC_FB_TOP(x) (((x) & 0xFFFF) << 16) | ||
| 37 | #define G_00015C_MC_FB_TOP(x) (((x) >> 16) & 0xFFFF) | ||
| 38 | #define C_00015C_MC_FB_TOP 0x0000FFFF | ||
| 39 | |||
| 40 | #endif | ||
diff --git a/drivers/gpu/drm/radeon/rs400.c b/drivers/gpu/drm/radeon/rs400.c index a3fbdad938c7..a769c296f6a6 100644 --- a/drivers/gpu/drm/radeon/rs400.c +++ b/drivers/gpu/drm/radeon/rs400.c | |||
| @@ -27,27 +27,12 @@ | |||
| 27 | */ | 27 | */ |
| 28 | #include <linux/seq_file.h> | 28 | #include <linux/seq_file.h> |
| 29 | #include <drm/drmP.h> | 29 | #include <drm/drmP.h> |
| 30 | #include "radeon_reg.h" | ||
| 31 | #include "radeon.h" | 30 | #include "radeon.h" |
| 31 | #include "rs400d.h" | ||
| 32 | 32 | ||
| 33 | /* rs400,rs480 depends on : */ | 33 | /* This files gather functions specifics to : rs400,rs480 */ |
| 34 | void r100_hdp_reset(struct radeon_device *rdev); | 34 | static int rs400_debugfs_pcie_gart_info_init(struct radeon_device *rdev); |
| 35 | void r100_mc_disable_clients(struct radeon_device *rdev); | ||
| 36 | int r300_mc_wait_for_idle(struct radeon_device *rdev); | ||
| 37 | void r420_pipes_init(struct radeon_device *rdev); | ||
| 38 | 35 | ||
| 39 | /* This files gather functions specifics to : | ||
| 40 | * rs400,rs480 | ||
| 41 | * | ||
| 42 | * Some of these functions might be used by newer ASICs. | ||
| 43 | */ | ||
| 44 | void rs400_gpu_init(struct radeon_device *rdev); | ||
| 45 | int rs400_debugfs_pcie_gart_info_init(struct radeon_device *rdev); | ||
| 46 | |||
| 47 | |||
| 48 | /* | ||
| 49 | * GART functions. | ||
| 50 | */ | ||
| 51 | void rs400_gart_adjust_size(struct radeon_device *rdev) | 36 | void rs400_gart_adjust_size(struct radeon_device *rdev) |
| 52 | { | 37 | { |
| 53 | /* Check gart size */ | 38 | /* Check gart size */ |
| @@ -238,61 +223,6 @@ int rs400_gart_set_page(struct radeon_device *rdev, int i, uint64_t addr) | |||
| 238 | return 0; | 223 | return 0; |
| 239 | } | 224 | } |
| 240 | 225 | ||
| 241 | |||
| 242 | /* | ||
| 243 | * MC functions. | ||
| 244 | */ | ||
| 245 | int rs400_mc_init(struct radeon_device *rdev) | ||
| 246 | { | ||
| 247 | uint32_t tmp; | ||
| 248 | int r; | ||
| 249 | |||
| 250 | if (r100_debugfs_rbbm_init(rdev)) { | ||
| 251 | DRM_ERROR("Failed to register debugfs file for RBBM !\n"); | ||
| 252 | } | ||
| 253 | |||
| 254 | rs400_gpu_init(rdev); | ||
| 255 | rs400_gart_disable(rdev); | ||
| 256 | rdev->mc.gtt_location = rdev->mc.mc_vram_size; | ||
| 257 | rdev->mc.gtt_location += (rdev->mc.gtt_size - 1); | ||
| 258 | rdev->mc.gtt_location &= ~(rdev->mc.gtt_size - 1); | ||
| 259 | r = radeon_mc_setup(rdev); | ||
| 260 | if (r) { | ||
| 261 | return r; | ||
| 262 | } | ||
| 263 | |||
| 264 | r100_mc_disable_clients(rdev); | ||
| 265 | if (r300_mc_wait_for_idle(rdev)) { | ||
| 266 | printk(KERN_WARNING "Failed to wait MC idle while " | ||
| 267 | "programming pipes. Bad things might happen.\n"); | ||
| 268 | } | ||
| 269 | |||
| 270 | tmp = rdev->mc.vram_location + rdev->mc.mc_vram_size - 1; | ||
| 271 | tmp = REG_SET(RADEON_MC_FB_TOP, tmp >> 16); | ||
| 272 | tmp |= REG_SET(RADEON_MC_FB_START, rdev->mc.vram_location >> 16); | ||
| 273 | WREG32(RADEON_MC_FB_LOCATION, tmp); | ||
| 274 | tmp = RREG32(RADEON_HOST_PATH_CNTL) | RADEON_HP_LIN_RD_CACHE_DIS; | ||
| 275 | WREG32(RADEON_HOST_PATH_CNTL, tmp | RADEON_HDP_SOFT_RESET | RADEON_HDP_READ_BUFFER_INVALIDATE); | ||
| 276 | (void)RREG32(RADEON_HOST_PATH_CNTL); | ||
| 277 | WREG32(RADEON_HOST_PATH_CNTL, tmp); | ||
| 278 | (void)RREG32(RADEON_HOST_PATH_CNTL); | ||
| 279 | |||
| 280 | return 0; | ||
| 281 | } | ||
| 282 | |||
| 283 | void rs400_mc_fini(struct radeon_device *rdev) | ||
| 284 | { | ||
| 285 | } | ||
| 286 | |||
| 287 | |||
| 288 | /* | ||
| 289 | * Global GPU functions | ||
| 290 | */ | ||
| 291 | void rs400_errata(struct radeon_device *rdev) | ||
| 292 | { | ||
| 293 | rdev->pll_errata = 0; | ||
| 294 | } | ||
| 295 | |||
| 296 | void rs400_gpu_init(struct radeon_device *rdev) | 226 | void rs400_gpu_init(struct radeon_device *rdev) |
| 297 | { | 227 | { |
| 298 | /* FIXME: HDP same place on rs400 ? */ | 228 | /* FIXME: HDP same place on rs400 ? */ |
| @@ -305,10 +235,6 @@ void rs400_gpu_init(struct radeon_device *rdev) | |||
| 305 | } | 235 | } |
| 306 | } | 236 | } |
| 307 | 237 | ||
| 308 | |||
| 309 | /* | ||
| 310 | * VRAM info. | ||
| 311 | */ | ||
| 312 | void rs400_vram_info(struct radeon_device *rdev) | 238 | void rs400_vram_info(struct radeon_device *rdev) |
| 313 | { | 239 | { |
| 314 | rs400_gart_adjust_size(rdev); | 240 | rs400_gart_adjust_size(rdev); |
| @@ -319,10 +245,6 @@ void rs400_vram_info(struct radeon_device *rdev) | |||
| 319 | r100_vram_init_sizes(rdev); | 245 | r100_vram_init_sizes(rdev); |
| 320 | } | 246 | } |
| 321 | 247 | ||
| 322 | |||
| 323 | /* | ||
| 324 | * Indirect registers accessor | ||
| 325 | */ | ||
| 326 | uint32_t rs400_mc_rreg(struct radeon_device *rdev, uint32_t reg) | 248 | uint32_t rs400_mc_rreg(struct radeon_device *rdev, uint32_t reg) |
| 327 | { | 249 | { |
| 328 | uint32_t r; | 250 | uint32_t r; |
| @@ -340,10 +262,6 @@ void rs400_mc_wreg(struct radeon_device *rdev, uint32_t reg, uint32_t v) | |||
| 340 | WREG32(RS480_NB_MC_INDEX, 0xff); | 262 | WREG32(RS480_NB_MC_INDEX, 0xff); |
| 341 | } | 263 | } |
| 342 | 264 | ||
| 343 | |||
| 344 | /* | ||
| 345 | * Debugfs info | ||
| 346 | */ | ||
| 347 | #if defined(CONFIG_DEBUG_FS) | 265 | #if defined(CONFIG_DEBUG_FS) |
| 348 | static int rs400_debugfs_gart_info(struct seq_file *m, void *data) | 266 | static int rs400_debugfs_gart_info(struct seq_file *m, void *data) |
| 349 | { | 267 | { |
| @@ -419,7 +337,7 @@ static struct drm_info_list rs400_gart_info_list[] = { | |||
| 419 | }; | 337 | }; |
| 420 | #endif | 338 | #endif |
| 421 | 339 | ||
| 422 | int rs400_debugfs_pcie_gart_info_init(struct radeon_device *rdev) | 340 | static int rs400_debugfs_pcie_gart_info_init(struct radeon_device *rdev) |
| 423 | { | 341 | { |
| 424 | #if defined(CONFIG_DEBUG_FS) | 342 | #if defined(CONFIG_DEBUG_FS) |
| 425 | return radeon_debugfs_add_files(rdev, rs400_gart_info_list, 1); | 343 | return radeon_debugfs_add_files(rdev, rs400_gart_info_list, 1); |
| @@ -427,3 +345,188 @@ int rs400_debugfs_pcie_gart_info_init(struct radeon_device *rdev) | |||
| 427 | return 0; | 345 | return 0; |
| 428 | #endif | 346 | #endif |
| 429 | } | 347 | } |
| 348 | |||
| 349 | static int rs400_mc_init(struct radeon_device *rdev) | ||
| 350 | { | ||
| 351 | int r; | ||
| 352 | u32 tmp; | ||
| 353 | |||
| 354 | /* Setup GPU memory space */ | ||
| 355 | tmp = G_00015C_MC_FB_START(RREG32(R_00015C_NB_TOM)); | ||
| 356 | rdev->mc.vram_location = G_00015C_MC_FB_START(tmp) << 16; | ||
| 357 | rdev->mc.gtt_location = 0xFFFFFFFFUL; | ||
| 358 | r = radeon_mc_setup(rdev); | ||
| 359 | if (r) | ||
| 360 | return r; | ||
| 361 | return 0; | ||
| 362 | } | ||
| 363 | |||
| 364 | void rs400_mc_program(struct radeon_device *rdev) | ||
| 365 | { | ||
| 366 | struct r100_mc_save save; | ||
| 367 | |||
| 368 | /* Stops all mc clients */ | ||
| 369 | r100_mc_stop(rdev, &save); | ||
| 370 | |||
| 371 | /* Wait for mc idle */ | ||
| 372 | if (r300_mc_wait_for_idle(rdev)) | ||
| 373 | dev_warn(rdev->dev, "Wait MC idle timeout before updating MC.\n"); | ||
| 374 | WREG32(R_000148_MC_FB_LOCATION, | ||
| 375 | S_000148_MC_FB_START(rdev->mc.vram_start >> 16) | | ||
| 376 | S_000148_MC_FB_TOP(rdev->mc.vram_end >> 16)); | ||
| 377 | |||
| 378 | r100_mc_resume(rdev, &save); | ||
| 379 | } | ||
| 380 | |||
| 381 | static int rs400_startup(struct radeon_device *rdev) | ||
| 382 | { | ||
| 383 | int r; | ||
| 384 | |||
| 385 | rs400_mc_program(rdev); | ||
| 386 | /* Resume clock */ | ||
| 387 | r300_clock_startup(rdev); | ||
| 388 | /* Initialize GPU configuration (# pipes, ...) */ | ||
| 389 | rs400_gpu_init(rdev); | ||
| 390 | /* Initialize GART (initialize after TTM so we can allocate | ||
| 391 | * memory through TTM but finalize after TTM) */ | ||
| 392 | r = rs400_gart_enable(rdev); | ||
| 393 | if (r) | ||
| 394 | return r; | ||
| 395 | /* Enable IRQ */ | ||
| 396 | rdev->irq.sw_int = true; | ||
| 397 | r100_irq_set(rdev); | ||
| 398 | /* 1M ring buffer */ | ||
| 399 | r = r100_cp_init(rdev, 1024 * 1024); | ||
| 400 | if (r) { | ||
| 401 | dev_err(rdev->dev, "failled initializing CP (%d).\n", r); | ||
| 402 | return r; | ||
| 403 | } | ||
| 404 | r = r100_wb_init(rdev); | ||
| 405 | if (r) | ||
| 406 | dev_err(rdev->dev, "failled initializing WB (%d).\n", r); | ||
| 407 | r = r100_ib_init(rdev); | ||
| 408 | if (r) { | ||
| 409 | dev_err(rdev->dev, "failled initializing IB (%d).\n", r); | ||
| 410 | return r; | ||
| 411 | } | ||
| 412 | return 0; | ||
| 413 | } | ||
| 414 | |||
| 415 | int rs400_resume(struct radeon_device *rdev) | ||
| 416 | { | ||
| 417 | /* Make sur GART are not working */ | ||
| 418 | rs400_gart_disable(rdev); | ||
| 419 | /* Resume clock before doing reset */ | ||
| 420 | r300_clock_startup(rdev); | ||
| 421 | /* Reset gpu before posting otherwise ATOM will enter infinite loop */ | ||
| 422 | if (radeon_gpu_reset(rdev)) { | ||
| 423 | dev_warn(rdev->dev, "GPU reset failed ! (0xE40=0x%08X, 0x7C0=0x%08X)\n", | ||
| 424 | RREG32(R_000E40_RBBM_STATUS), | ||
| 425 | RREG32(R_0007C0_CP_STAT)); | ||
| 426 | } | ||
| 427 | /* post */ | ||
| 428 | radeon_combios_asic_init(rdev->ddev); | ||
| 429 | /* Resume clock after posting */ | ||
| 430 | r300_clock_startup(rdev); | ||
| 431 | return rs400_startup(rdev); | ||
| 432 | } | ||
| 433 | |||
| 434 | int rs400_suspend(struct radeon_device *rdev) | ||
| 435 | { | ||
| 436 | r100_cp_disable(rdev); | ||
| 437 | r100_wb_disable(rdev); | ||
| 438 | r100_irq_disable(rdev); | ||
| 439 | rs400_gart_disable(rdev); | ||
| 440 | return 0; | ||
| 441 | } | ||
| 442 | |||
| 443 | void rs400_fini(struct radeon_device *rdev) | ||
| 444 | { | ||
| 445 | rs400_suspend(rdev); | ||
| 446 | r100_cp_fini(rdev); | ||
| 447 | r100_wb_fini(rdev); | ||
| 448 | r100_ib_fini(rdev); | ||
| 449 | radeon_gem_fini(rdev); | ||
| 450 | rs400_gart_fini(rdev); | ||
| 451 | radeon_irq_kms_fini(rdev); | ||
| 452 | radeon_fence_driver_fini(rdev); | ||
| 453 | radeon_object_fini(rdev); | ||
| 454 | radeon_atombios_fini(rdev); | ||
| 455 | kfree(rdev->bios); | ||
| 456 | rdev->bios = NULL; | ||
| 457 | } | ||
| 458 | |||
| 459 | int rs400_init(struct radeon_device *rdev) | ||
| 460 | { | ||
| 461 | int r; | ||
| 462 | |||
| 463 | /* Disable VGA */ | ||
| 464 | r100_vga_render_disable(rdev); | ||
| 465 | /* Initialize scratch registers */ | ||
| 466 | radeon_scratch_init(rdev); | ||
| 467 | /* Initialize surface registers */ | ||
| 468 | radeon_surface_init(rdev); | ||
| 469 | /* TODO: disable VGA need to use VGA request */ | ||
| 470 | /* BIOS*/ | ||
| 471 | if (!radeon_get_bios(rdev)) { | ||
| 472 | if (ASIC_IS_AVIVO(rdev)) | ||
| 473 | return -EINVAL; | ||
| 474 | } | ||
| 475 | if (rdev->is_atom_bios) { | ||
| 476 | dev_err(rdev->dev, "Expecting combios for RS400/RS480 GPU\n"); | ||
| 477 | return -EINVAL; | ||
| 478 | } else { | ||
| 479 | r = radeon_combios_init(rdev); | ||
| 480 | if (r) | ||
| 481 | return r; | ||
| 482 | } | ||
| 483 | /* Reset gpu before posting otherwise ATOM will enter infinite loop */ | ||
| 484 | if (radeon_gpu_reset(rdev)) { | ||
| 485 | dev_warn(rdev->dev, | ||
| 486 | "GPU reset failed ! (0xE40=0x%08X, 0x7C0=0x%08X)\n", | ||
| 487 | RREG32(R_000E40_RBBM_STATUS), | ||
| 488 | RREG32(R_0007C0_CP_STAT)); | ||
| 489 | } | ||
| 490 | /* check if cards are posted or not */ | ||
| 491 | if (!radeon_card_posted(rdev) && rdev->bios) { | ||
| 492 | DRM_INFO("GPU not posted. posting now...\n"); | ||
| 493 | radeon_combios_asic_init(rdev->ddev); | ||
| 494 | } | ||
| 495 | /* Initialize clocks */ | ||
| 496 | radeon_get_clock_info(rdev->ddev); | ||
| 497 | /* Get vram informations */ | ||
| 498 | rs400_vram_info(rdev); | ||
| 499 | /* Initialize memory controller (also test AGP) */ | ||
| 500 | r = rs400_mc_init(rdev); | ||
| 501 | if (r) | ||
| 502 | return r; | ||
| 503 | /* Fence driver */ | ||
| 504 | r = radeon_fence_driver_init(rdev); | ||
| 505 | if (r) | ||
| 506 | return r; | ||
| 507 | r = radeon_irq_kms_init(rdev); | ||
| 508 | if (r) | ||
| 509 | return r; | ||
| 510 | /* Memory manager */ | ||
| 511 | r = radeon_object_init(rdev); | ||
| 512 | if (r) | ||
| 513 | return r; | ||
| 514 | r = rs400_gart_init(rdev); | ||
| 515 | if (r) | ||
| 516 | return r; | ||
| 517 | r300_set_reg_safe(rdev); | ||
| 518 | rdev->accel_working = true; | ||
| 519 | r = rs400_startup(rdev); | ||
| 520 | if (r) { | ||
| 521 | /* Somethings want wront with the accel init stop accel */ | ||
| 522 | dev_err(rdev->dev, "Disabling GPU acceleration\n"); | ||
| 523 | rs400_suspend(rdev); | ||
| 524 | r100_cp_fini(rdev); | ||
| 525 | r100_wb_fini(rdev); | ||
| 526 | r100_ib_fini(rdev); | ||
| 527 | rs400_gart_fini(rdev); | ||
| 528 | radeon_irq_kms_fini(rdev); | ||
| 529 | rdev->accel_working = false; | ||
| 530 | } | ||
| 531 | return 0; | ||
| 532 | } | ||
diff --git a/drivers/gpu/drm/radeon/rs400d.h b/drivers/gpu/drm/radeon/rs400d.h new file mode 100644 index 000000000000..6d8bac58ced9 --- /dev/null +++ b/drivers/gpu/drm/radeon/rs400d.h | |||
| @@ -0,0 +1,160 @@ | |||
| 1 | /* | ||
| 2 | * Copyright 2008 Advanced Micro Devices, Inc. | ||
| 3 | * Copyright 2008 Red Hat Inc. | ||
| 4 | * Copyright 2009 Jerome Glisse. | ||
| 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: Dave Airlie | ||
| 25 | * Alex Deucher | ||
| 26 | * Jerome Glisse | ||
| 27 | */ | ||
| 28 | #ifndef __RS400D_H__ | ||
| 29 | #define __RS400D_H__ | ||
| 30 | |||
| 31 | /* Registers */ | ||
| 32 | #define R_000148_MC_FB_LOCATION 0x000148 | ||
| 33 | #define S_000148_MC_FB_START(x) (((x) & 0xFFFF) << 0) | ||
| 34 | #define G_000148_MC_FB_START(x) (((x) >> 0) & 0xFFFF) | ||
| 35 | #define C_000148_MC_FB_START 0xFFFF0000 | ||
| 36 | #define S_000148_MC_FB_TOP(x) (((x) & 0xFFFF) << 16) | ||
| 37 | #define G_000148_MC_FB_TOP(x) (((x) >> 16) & 0xFFFF) | ||
| 38 | #define C_000148_MC_FB_TOP 0x0000FFFF | ||
| 39 | #define R_00015C_NB_TOM 0x00015C | ||
| 40 | #define S_00015C_MC_FB_START(x) (((x) & 0xFFFF) << 0) | ||
| 41 | #define G_00015C_MC_FB_START(x) (((x) >> 0) & 0xFFFF) | ||
| 42 | #define C_00015C_MC_FB_START 0xFFFF0000 | ||
| 43 | #define S_00015C_MC_FB_TOP(x) (((x) & 0xFFFF) << 16) | ||
| 44 | #define G_00015C_MC_FB_TOP(x) (((x) >> 16) & 0xFFFF) | ||
| 45 | #define C_00015C_MC_FB_TOP 0x0000FFFF | ||
| 46 | #define R_0007C0_CP_STAT 0x0007C0 | ||
| 47 | #define S_0007C0_MRU_BUSY(x) (((x) & 0x1) << 0) | ||
| 48 | #define G_0007C0_MRU_BUSY(x) (((x) >> 0) & 0x1) | ||
| 49 | #define C_0007C0_MRU_BUSY 0xFFFFFFFE | ||
| 50 | #define S_0007C0_MWU_BUSY(x) (((x) & 0x1) << 1) | ||
| 51 | #define G_0007C0_MWU_BUSY(x) (((x) >> 1) & 0x1) | ||
| 52 | #define C_0007C0_MWU_BUSY 0xFFFFFFFD | ||
| 53 | #define S_0007C0_RSIU_BUSY(x) (((x) & 0x1) << 2) | ||
| 54 | #define G_0007C0_RSIU_BUSY(x) (((x) >> 2) & 0x1) | ||
| 55 | #define C_0007C0_RSIU_BUSY 0xFFFFFFFB | ||
| 56 | #define S_0007C0_RCIU_BUSY(x) (((x) & 0x1) << 3) | ||
| 57 | #define G_0007C0_RCIU_BUSY(x) (((x) >> 3) & 0x1) | ||
| 58 | #define C_0007C0_RCIU_BUSY 0xFFFFFFF7 | ||
| 59 | #define S_0007C0_CSF_PRIMARY_BUSY(x) (((x) & 0x1) << 9) | ||
| 60 | #define G_0007C0_CSF_PRIMARY_BUSY(x) (((x) >> 9) & 0x1) | ||
| 61 | #define C_0007C0_CSF_PRIMARY_BUSY 0xFFFFFDFF | ||
| 62 | #define S_0007C0_CSF_INDIRECT_BUSY(x) (((x) & 0x1) << 10) | ||
| 63 | #define G_0007C0_CSF_INDIRECT_BUSY(x) (((x) >> 10) & 0x1) | ||
| 64 | #define C_0007C0_CSF_INDIRECT_BUSY 0xFFFFFBFF | ||
| 65 | #define S_0007C0_CSQ_PRIMARY_BUSY(x) (((x) & 0x1) << 11) | ||
| 66 | #define G_0007C0_CSQ_PRIMARY_BUSY(x) (((x) >> 11) & 0x1) | ||
| 67 | #define C_0007C0_CSQ_PRIMARY_BUSY 0xFFFFF7FF | ||
| 68 | #define S_0007C0_CSQ_INDIRECT_BUSY(x) (((x) & 0x1) << 12) | ||
| 69 | #define G_0007C0_CSQ_INDIRECT_BUSY(x) (((x) >> 12) & 0x1) | ||
| 70 | #define C_0007C0_CSQ_INDIRECT_BUSY 0xFFFFEFFF | ||
| 71 | #define S_0007C0_CSI_BUSY(x) (((x) & 0x1) << 13) | ||
| 72 | #define G_0007C0_CSI_BUSY(x) (((x) >> 13) & 0x1) | ||
| 73 | #define C_0007C0_CSI_BUSY 0xFFFFDFFF | ||
| 74 | #define S_0007C0_CSF_INDIRECT2_BUSY(x) (((x) & 0x1) << 14) | ||
| 75 | #define G_0007C0_CSF_INDIRECT2_BUSY(x) (((x) >> 14) & 0x1) | ||
| 76 | #define C_0007C0_CSF_INDIRECT2_BUSY 0xFFFFBFFF | ||
| 77 | #define S_0007C0_CSQ_INDIRECT2_BUSY(x) (((x) & 0x1) << 15) | ||
| 78 | #define G_0007C0_CSQ_INDIRECT2_BUSY(x) (((x) >> 15) & 0x1) | ||
| 79 | #define C_0007C0_CSQ_INDIRECT2_BUSY 0xFFFF7FFF | ||
| 80 | #define S_0007C0_GUIDMA_BUSY(x) (((x) & 0x1) << 28) | ||
| 81 | #define G_0007C0_GUIDMA_BUSY(x) (((x) >> 28) & 0x1) | ||
| 82 | #define C_0007C0_GUIDMA_BUSY 0xEFFFFFFF | ||
| 83 | #define S_0007C0_VIDDMA_BUSY(x) (((x) & 0x1) << 29) | ||
| 84 | #define G_0007C0_VIDDMA_BUSY(x) (((x) >> 29) & 0x1) | ||
| 85 | #define C_0007C0_VIDDMA_BUSY 0xDFFFFFFF | ||
| 86 | #define S_0007C0_CMDSTRM_BUSY(x) (((x) & 0x1) << 30) | ||
| 87 | #define G_0007C0_CMDSTRM_BUSY(x) (((x) >> 30) & 0x1) | ||
| 88 | #define C_0007C0_CMDSTRM_BUSY 0xBFFFFFFF | ||
| 89 | #define S_0007C0_CP_BUSY(x) (((x) & 0x1) << 31) | ||
| 90 | #define G_0007C0_CP_BUSY(x) (((x) >> 31) & 0x1) | ||
| 91 | #define C_0007C0_CP_BUSY 0x7FFFFFFF | ||
| 92 | #define R_000E40_RBBM_STATUS 0x000E40 | ||
| 93 | #define S_000E40_CMDFIFO_AVAIL(x) (((x) & 0x7F) << 0) | ||
| 94 | #define G_000E40_CMDFIFO_AVAIL(x) (((x) >> 0) & 0x7F) | ||
| 95 | #define C_000E40_CMDFIFO_AVAIL 0xFFFFFF80 | ||
| 96 | #define S_000E40_HIRQ_ON_RBB(x) (((x) & 0x1) << 8) | ||
| 97 | #define G_000E40_HIRQ_ON_RBB(x) (((x) >> 8) & 0x1) | ||
| 98 | #define C_000E40_HIRQ_ON_RBB 0xFFFFFEFF | ||
| 99 | #define S_000E40_CPRQ_ON_RBB(x) (((x) & 0x1) << 9) | ||
| 100 | #define G_000E40_CPRQ_ON_RBB(x) (((x) >> 9) & 0x1) | ||
| 101 | #define C_000E40_CPRQ_ON_RBB 0xFFFFFDFF | ||
| 102 | #define S_000E40_CFRQ_ON_RBB(x) (((x) & 0x1) << 10) | ||
| 103 | #define G_000E40_CFRQ_ON_RBB(x) (((x) >> 10) & 0x1) | ||
| 104 | #define C_000E40_CFRQ_ON_RBB 0xFFFFFBFF | ||
| 105 | #define S_000E40_HIRQ_IN_RTBUF(x) (((x) & 0x1) << 11) | ||
| 106 | #define G_000E40_HIRQ_IN_RTBUF(x) (((x) >> 11) & 0x1) | ||
| 107 | #define C_000E40_HIRQ_IN_RTBUF 0xFFFFF7FF | ||
| 108 | #define S_000E40_CPRQ_IN_RTBUF(x) (((x) & 0x1) << 12) | ||
| 109 | #define G_000E40_CPRQ_IN_RTBUF(x) (((x) >> 12) & 0x1) | ||
| 110 | #define C_000E40_CPRQ_IN_RTBUF 0xFFFFEFFF | ||
| 111 | #define S_000E40_CFRQ_IN_RTBUF(x) (((x) & 0x1) << 13) | ||
| 112 | #define G_000E40_CFRQ_IN_RTBUF(x) (((x) >> 13) & 0x1) | ||
| 113 | #define C_000E40_CFRQ_IN_RTBUF 0xFFFFDFFF | ||
| 114 | #define S_000E40_CF_PIPE_BUSY(x) (((x) & 0x1) << 14) | ||
| 115 | #define G_000E40_CF_PIPE_BUSY(x) (((x) >> 14) & 0x1) | ||
| 116 | #define C_000E40_CF_PIPE_BUSY 0xFFFFBFFF | ||
| 117 | #define S_000E40_ENG_EV_BUSY(x) (((x) & 0x1) << 15) | ||
| 118 | #define G_000E40_ENG_EV_BUSY(x) (((x) >> 15) & 0x1) | ||
| 119 | #define C_000E40_ENG_EV_BUSY 0xFFFF7FFF | ||
| 120 | #define S_000E40_CP_CMDSTRM_BUSY(x) (((x) & 0x1) << 16) | ||
| 121 | #define G_000E40_CP_CMDSTRM_BUSY(x) (((x) >> 16) & 0x1) | ||
| 122 | #define C_000E40_CP_CMDSTRM_BUSY 0xFFFEFFFF | ||
| 123 | #define S_000E40_E2_BUSY(x) (((x) & 0x1) << 17) | ||
| 124 | #define G_000E40_E2_BUSY(x) (((x) >> 17) & 0x1) | ||
| 125 | #define C_000E40_E2_BUSY 0xFFFDFFFF | ||
| 126 | #define S_000E40_RB2D_BUSY(x) (((x) & 0x1) << 18) | ||
| 127 | #define G_000E40_RB2D_BUSY(x) (((x) >> 18) & 0x1) | ||
| 128 | #define C_000E40_RB2D_BUSY 0xFFFBFFFF | ||
| 129 | #define S_000E40_RB3D_BUSY(x) (((x) & 0x1) << 19) | ||
| 130 | #define G_000E40_RB3D_BUSY(x) (((x) >> 19) & 0x1) | ||
| 131 | #define C_000E40_RB3D_BUSY 0xFFF7FFFF | ||
| 132 | #define S_000E40_VAP_BUSY(x) (((x) & 0x1) << 20) | ||
| 133 | #define G_000E40_VAP_BUSY(x) (((x) >> 20) & 0x1) | ||
| 134 | #define C_000E40_VAP_BUSY 0xFFEFFFFF | ||
| 135 | #define S_000E40_RE_BUSY(x) (((x) & 0x1) << 21) | ||
| 136 | #define G_000E40_RE_BUSY(x) (((x) >> 21) & 0x1) | ||
| 137 | #define C_000E40_RE_BUSY 0xFFDFFFFF | ||
| 138 | #define S_000E40_TAM_BUSY(x) (((x) & 0x1) << 22) | ||
| 139 | #define G_000E40_TAM_BUSY(x) (((x) >> 22) & 0x1) | ||
| 140 | #define C_000E40_TAM_BUSY 0xFFBFFFFF | ||
| 141 | #define S_000E40_TDM_BUSY(x) (((x) & 0x1) << 23) | ||
| 142 | #define G_000E40_TDM_BUSY(x) (((x) >> 23) & 0x1) | ||
| 143 | #define C_000E40_TDM_BUSY 0xFF7FFFFF | ||
| 144 | #define S_000E40_PB_BUSY(x) (((x) & 0x1) << 24) | ||
| 145 | #define G_000E40_PB_BUSY(x) (((x) >> 24) & 0x1) | ||
| 146 | #define C_000E40_PB_BUSY 0xFEFFFFFF | ||
| 147 | #define S_000E40_TIM_BUSY(x) (((x) & 0x1) << 25) | ||
| 148 | #define G_000E40_TIM_BUSY(x) (((x) >> 25) & 0x1) | ||
| 149 | #define C_000E40_TIM_BUSY 0xFDFFFFFF | ||
| 150 | #define S_000E40_GA_BUSY(x) (((x) & 0x1) << 26) | ||
| 151 | #define G_000E40_GA_BUSY(x) (((x) >> 26) & 0x1) | ||
| 152 | #define C_000E40_GA_BUSY 0xFBFFFFFF | ||
| 153 | #define S_000E40_CBA2D_BUSY(x) (((x) & 0x1) << 27) | ||
| 154 | #define G_000E40_CBA2D_BUSY(x) (((x) >> 27) & 0x1) | ||
| 155 | #define C_000E40_CBA2D_BUSY 0xF7FFFFFF | ||
| 156 | #define S_000E40_GUI_ACTIVE(x) (((x) & 0x1) << 31) | ||
| 157 | #define G_000E40_GUI_ACTIVE(x) (((x) >> 31) & 0x1) | ||
| 158 | #define C_000E40_GUI_ACTIVE 0x7FFFFFFF | ||
| 159 | |||
| 160 | #endif | ||
diff --git a/drivers/gpu/drm/radeon/rs600.c b/drivers/gpu/drm/radeon/rs600.c index 4a4fe1cb131c..10dfa78762da 100644 --- a/drivers/gpu/drm/radeon/rs600.c +++ b/drivers/gpu/drm/radeon/rs600.c | |||
| @@ -25,27 +25,26 @@ | |||
| 25 | * Alex Deucher | 25 | * Alex Deucher |
| 26 | * Jerome Glisse | 26 | * Jerome Glisse |
| 27 | */ | 27 | */ |
| 28 | /* RS600 / Radeon X1250/X1270 integrated GPU | ||
| 29 | * | ||
| 30 | * This file gather function specific to RS600 which is the IGP of | ||
| 31 | * the X1250/X1270 family supporting intel CPU (while RS690/RS740 | ||
| 32 | * is the X1250/X1270 supporting AMD CPU). The display engine are | ||
| 33 | * the avivo one, bios is an atombios, 3D block are the one of the | ||
| 34 | * R4XX family. The GART is different from the RS400 one and is very | ||
| 35 | * close to the one of the R600 family (R600 likely being an evolution | ||
| 36 | * of the RS600 GART block). | ||
| 37 | */ | ||
| 28 | #include "drmP.h" | 38 | #include "drmP.h" |
| 29 | #include "radeon_reg.h" | ||
| 30 | #include "radeon.h" | 39 | #include "radeon.h" |
| 40 | #include "atom.h" | ||
| 41 | #include "rs600d.h" | ||
| 31 | 42 | ||
| 32 | #include "rs600_reg_safe.h" | 43 | #include "rs600_reg_safe.h" |
| 33 | 44 | ||
| 34 | /* rs600 depends on : */ | ||
| 35 | void r100_hdp_reset(struct radeon_device *rdev); | ||
| 36 | int r100_gui_wait_for_idle(struct radeon_device *rdev); | ||
| 37 | int r300_mc_wait_for_idle(struct radeon_device *rdev); | ||
| 38 | void r420_pipes_init(struct radeon_device *rdev); | ||
| 39 | |||
| 40 | /* This files gather functions specifics to : | ||
| 41 | * rs600 | ||
| 42 | * | ||
| 43 | * Some of these functions might be used by newer ASICs. | ||
| 44 | */ | ||
| 45 | void rs600_gpu_init(struct radeon_device *rdev); | 45 | void rs600_gpu_init(struct radeon_device *rdev); |
| 46 | int rs600_mc_wait_for_idle(struct radeon_device *rdev); | 46 | int rs600_mc_wait_for_idle(struct radeon_device *rdev); |
| 47 | 47 | ||
| 48 | |||
| 49 | /* | 48 | /* |
| 50 | * GART. | 49 | * GART. |
| 51 | */ | 50 | */ |
| @@ -53,18 +52,18 @@ void rs600_gart_tlb_flush(struct radeon_device *rdev) | |||
| 53 | { | 52 | { |
| 54 | uint32_t tmp; | 53 | uint32_t tmp; |
| 55 | 54 | ||
| 56 | tmp = RREG32_MC(RS600_MC_PT0_CNTL); | 55 | tmp = RREG32_MC(R_000100_MC_PT0_CNTL); |
| 57 | tmp &= ~(RS600_INVALIDATE_ALL_L1_TLBS | RS600_INVALIDATE_L2_CACHE); | 56 | tmp &= C_000100_INVALIDATE_ALL_L1_TLBS & C_000100_INVALIDATE_L2_CACHE; |
| 58 | WREG32_MC(RS600_MC_PT0_CNTL, tmp); | 57 | WREG32_MC(R_000100_MC_PT0_CNTL, tmp); |
| 59 | 58 | ||
| 60 | tmp = RREG32_MC(RS600_MC_PT0_CNTL); | 59 | tmp = RREG32_MC(R_000100_MC_PT0_CNTL); |
| 61 | tmp |= RS600_INVALIDATE_ALL_L1_TLBS | RS600_INVALIDATE_L2_CACHE; | 60 | tmp |= S_000100_INVALIDATE_ALL_L1_TLBS(1) & S_000100_INVALIDATE_L2_CACHE(1); |
| 62 | WREG32_MC(RS600_MC_PT0_CNTL, tmp); | 61 | WREG32_MC(R_000100_MC_PT0_CNTL, tmp); |
| 63 | 62 | ||
| 64 | tmp = RREG32_MC(RS600_MC_PT0_CNTL); | 63 | tmp = RREG32_MC(R_000100_MC_PT0_CNTL); |
| 65 | tmp &= ~(RS600_INVALIDATE_ALL_L1_TLBS | RS600_INVALIDATE_L2_CACHE); | 64 | tmp &= C_000100_INVALIDATE_ALL_L1_TLBS & C_000100_INVALIDATE_L2_CACHE; |
| 66 | WREG32_MC(RS600_MC_PT0_CNTL, tmp); | 65 | WREG32_MC(R_000100_MC_PT0_CNTL, tmp); |
| 67 | tmp = RREG32_MC(RS600_MC_PT0_CNTL); | 66 | tmp = RREG32_MC(R_000100_MC_PT0_CNTL); |
| 68 | } | 67 | } |
| 69 | 68 | ||
| 70 | int rs600_gart_init(struct radeon_device *rdev) | 69 | int rs600_gart_init(struct radeon_device *rdev) |
| @@ -86,7 +85,7 @@ int rs600_gart_init(struct radeon_device *rdev) | |||
| 86 | 85 | ||
| 87 | int rs600_gart_enable(struct radeon_device *rdev) | 86 | int rs600_gart_enable(struct radeon_device *rdev) |
| 88 | { | 87 | { |
| 89 | uint32_t tmp; | 88 | u32 tmp; |
| 90 | int r, i; | 89 | int r, i; |
| 91 | 90 | ||
| 92 | if (rdev->gart.table.vram.robj == NULL) { | 91 | if (rdev->gart.table.vram.robj == NULL) { |
| @@ -96,46 +95,50 @@ int rs600_gart_enable(struct radeon_device *rdev) | |||
| 96 | r = radeon_gart_table_vram_pin(rdev); | 95 | r = radeon_gart_table_vram_pin(rdev); |
| 97 | if (r) | 96 | if (r) |
| 98 | return r; | 97 | return r; |
| 98 | /* Enable bus master */ | ||
| 99 | tmp = RREG32(R_00004C_BUS_CNTL) & C_00004C_BUS_MASTER_DIS; | ||
| 100 | WREG32(R_00004C_BUS_CNTL, tmp); | ||
| 99 | /* FIXME: setup default page */ | 101 | /* FIXME: setup default page */ |
| 100 | WREG32_MC(RS600_MC_PT0_CNTL, | 102 | WREG32_MC(R_000100_MC_PT0_CNTL, |
| 101 | (RS600_EFFECTIVE_L2_CACHE_SIZE(6) | | 103 | (S_000100_EFFECTIVE_L2_CACHE_SIZE(6) | |
| 102 | RS600_EFFECTIVE_L2_QUEUE_SIZE(6))); | 104 | S_000100_EFFECTIVE_L2_QUEUE_SIZE(6))); |
| 103 | for (i = 0; i < 19; i++) { | 105 | for (i = 0; i < 19; i++) { |
| 104 | WREG32_MC(RS600_MC_PT0_CLIENT0_CNTL + i, | 106 | WREG32_MC(R_00016C_MC_PT0_CLIENT0_CNTL + i, |
| 105 | (RS600_ENABLE_TRANSLATION_MODE_OVERRIDE | | 107 | S_00016C_ENABLE_TRANSLATION_MODE_OVERRIDE(1) | |
| 106 | RS600_SYSTEM_ACCESS_MODE_IN_SYS | | 108 | S_00016C_SYSTEM_ACCESS_MODE_MASK( |
| 107 | RS600_SYSTEM_APERTURE_UNMAPPED_ACCESS_DEFAULT_PAGE | | 109 | V_00016C_SYSTEM_ACCESS_MODE_IN_SYS) | |
| 108 | RS600_EFFECTIVE_L1_CACHE_SIZE(3) | | 110 | S_00016C_SYSTEM_APERTURE_UNMAPPED_ACCESS( |
| 109 | RS600_ENABLE_FRAGMENT_PROCESSING | | 111 | V_00016C_SYSTEM_APERTURE_UNMAPPED_DEFAULT_PAGE) | |
| 110 | RS600_EFFECTIVE_L1_QUEUE_SIZE(3))); | 112 | S_00016C_EFFECTIVE_L1_CACHE_SIZE(1) | |
| 113 | S_00016C_ENABLE_FRAGMENT_PROCESSING(1) | | ||
| 114 | S_00016C_EFFECTIVE_L1_QUEUE_SIZE(1)); | ||
| 111 | } | 115 | } |
| 112 | 116 | ||
| 113 | /* System context map to GART space */ | 117 | /* System context map to GART space */ |
| 114 | WREG32_MC(RS600_MC_PT0_SYSTEM_APERTURE_LOW_ADDR, rdev->mc.gtt_location); | 118 | WREG32_MC(R_000112_MC_PT0_SYSTEM_APERTURE_LOW_ADDR, rdev->mc.gtt_start); |
| 115 | tmp = rdev->mc.gtt_location + rdev->mc.gtt_size - 1; | 119 | WREG32_MC(R_000114_MC_PT0_SYSTEM_APERTURE_HIGH_ADDR, rdev->mc.gtt_end); |
| 116 | WREG32_MC(RS600_MC_PT0_SYSTEM_APERTURE_HIGH_ADDR, tmp); | ||
| 117 | 120 | ||
| 118 | /* enable first context */ | 121 | /* enable first context */ |
| 119 | WREG32_MC(RS600_MC_PT0_CONTEXT0_FLAT_START_ADDR, rdev->mc.gtt_location); | 122 | WREG32_MC(R_00013C_MC_PT0_CONTEXT0_FLAT_START_ADDR, rdev->mc.gtt_start); |
| 120 | tmp = rdev->mc.gtt_location + rdev->mc.gtt_size - 1; | 123 | WREG32_MC(R_00014C_MC_PT0_CONTEXT0_FLAT_END_ADDR, rdev->mc.gtt_end); |
| 121 | WREG32_MC(RS600_MC_PT0_CONTEXT0_FLAT_END_ADDR, tmp); | 124 | WREG32_MC(R_000102_MC_PT0_CONTEXT0_CNTL, |
| 122 | WREG32_MC(RS600_MC_PT0_CONTEXT0_CNTL, | 125 | S_000102_ENABLE_PAGE_TABLE(1) | |
| 123 | (RS600_ENABLE_PAGE_TABLE | RS600_PAGE_TABLE_TYPE_FLAT)); | 126 | S_000102_PAGE_TABLE_DEPTH(V_000102_PAGE_TABLE_FLAT)); |
| 124 | /* disable all other contexts */ | 127 | /* disable all other contexts */ |
| 125 | for (i = 1; i < 8; i++) { | 128 | for (i = 1; i < 8; i++) { |
| 126 | WREG32_MC(RS600_MC_PT0_CONTEXT0_CNTL + i, 0); | 129 | WREG32_MC(R_000102_MC_PT0_CONTEXT0_CNTL + i, 0); |
| 127 | } | 130 | } |
| 128 | 131 | ||
| 129 | /* setup the page table */ | 132 | /* setup the page table */ |
| 130 | WREG32_MC(RS600_MC_PT0_CONTEXT0_FLAT_BASE_ADDR, | 133 | WREG32_MC(R_00012C_MC_PT0_CONTEXT0_FLAT_BASE_ADDR, |
| 131 | rdev->gart.table_addr); | 134 | rdev->gart.table_addr); |
| 132 | WREG32_MC(RS600_MC_PT0_CONTEXT0_DEFAULT_READ_ADDR, 0); | 135 | WREG32_MC(R_00011C_MC_PT0_CONTEXT0_DEFAULT_READ_ADDR, 0); |
| 133 | 136 | ||
| 134 | /* enable page tables */ | 137 | /* enable page tables */ |
| 135 | tmp = RREG32_MC(RS600_MC_PT0_CNTL); | 138 | tmp = RREG32_MC(R_000100_MC_PT0_CNTL); |
| 136 | WREG32_MC(RS600_MC_PT0_CNTL, (tmp | RS600_ENABLE_PT)); | 139 | WREG32_MC(R_000100_MC_PT0_CNTL, (tmp | S_000100_ENABLE_PT(1))); |
| 137 | tmp = RREG32_MC(RS600_MC_CNTL1); | 140 | tmp = RREG32_MC(R_000009_MC_CNTL1); |
| 138 | WREG32_MC(RS600_MC_CNTL1, (tmp | RS600_ENABLE_PAGE_TABLES)); | 141 | WREG32_MC(R_000009_MC_CNTL1, (tmp | S_000009_ENABLE_PAGE_TABLES(1))); |
| 139 | rs600_gart_tlb_flush(rdev); | 142 | rs600_gart_tlb_flush(rdev); |
| 140 | rdev->gart.ready = true; | 143 | rdev->gart.ready = true; |
| 141 | return 0; | 144 | return 0; |
| @@ -146,10 +149,9 @@ void rs600_gart_disable(struct radeon_device *rdev) | |||
| 146 | uint32_t tmp; | 149 | uint32_t tmp; |
| 147 | 150 | ||
| 148 | /* FIXME: disable out of gart access */ | 151 | /* FIXME: disable out of gart access */ |
| 149 | WREG32_MC(RS600_MC_PT0_CNTL, 0); | 152 | WREG32_MC(R_000100_MC_PT0_CNTL, 0); |
| 150 | tmp = RREG32_MC(RS600_MC_CNTL1); | 153 | tmp = RREG32_MC(R_000009_MC_CNTL1); |
| 151 | tmp &= ~RS600_ENABLE_PAGE_TABLES; | 154 | WREG32_MC(R_000009_MC_CNTL1, tmp & C_000009_ENABLE_PAGE_TABLES); |
| 152 | WREG32_MC(RS600_MC_CNTL1, tmp); | ||
| 153 | if (rdev->gart.table.vram.robj) { | 155 | if (rdev->gart.table.vram.robj) { |
| 154 | radeon_object_kunmap(rdev->gart.table.vram.robj); | 156 | radeon_object_kunmap(rdev->gart.table.vram.robj); |
| 155 | radeon_object_unpin(rdev->gart.table.vram.robj); | 157 | radeon_object_unpin(rdev->gart.table.vram.robj); |
| @@ -183,129 +185,61 @@ int rs600_gart_set_page(struct radeon_device *rdev, int i, uint64_t addr) | |||
| 183 | return 0; | 185 | return 0; |
| 184 | } | 186 | } |
| 185 | 187 | ||
| 186 | |||
| 187 | /* | ||
| 188 | * MC. | ||
| 189 | */ | ||
| 190 | void rs600_mc_disable_clients(struct radeon_device *rdev) | ||
| 191 | { | ||
| 192 | unsigned tmp; | ||
| 193 | |||
| 194 | if (r100_gui_wait_for_idle(rdev)) { | ||
| 195 | printk(KERN_WARNING "Failed to wait GUI idle while " | ||
| 196 | "programming pipes. Bad things might happen.\n"); | ||
| 197 | } | ||
| 198 | |||
| 199 | rv515_vga_render_disable(rdev); | ||
| 200 | |||
| 201 | tmp = RREG32(AVIVO_D1VGA_CONTROL); | ||
| 202 | WREG32(AVIVO_D1VGA_CONTROL, tmp & ~AVIVO_DVGA_CONTROL_MODE_ENABLE); | ||
| 203 | tmp = RREG32(AVIVO_D2VGA_CONTROL); | ||
| 204 | WREG32(AVIVO_D2VGA_CONTROL, tmp & ~AVIVO_DVGA_CONTROL_MODE_ENABLE); | ||
| 205 | |||
| 206 | tmp = RREG32(AVIVO_D1CRTC_CONTROL); | ||
| 207 | WREG32(AVIVO_D1CRTC_CONTROL, tmp & ~AVIVO_CRTC_EN); | ||
| 208 | tmp = RREG32(AVIVO_D2CRTC_CONTROL); | ||
| 209 | WREG32(AVIVO_D2CRTC_CONTROL, tmp & ~AVIVO_CRTC_EN); | ||
| 210 | |||
| 211 | /* make sure all previous write got through */ | ||
| 212 | tmp = RREG32(AVIVO_D2CRTC_CONTROL); | ||
| 213 | |||
| 214 | mdelay(1); | ||
| 215 | } | ||
| 216 | |||
| 217 | int rs600_mc_init(struct radeon_device *rdev) | ||
| 218 | { | ||
| 219 | uint32_t tmp; | ||
| 220 | int r; | ||
| 221 | |||
| 222 | if (r100_debugfs_rbbm_init(rdev)) { | ||
| 223 | DRM_ERROR("Failed to register debugfs file for RBBM !\n"); | ||
| 224 | } | ||
| 225 | |||
| 226 | rs600_gpu_init(rdev); | ||
| 227 | rs600_gart_disable(rdev); | ||
| 228 | |||
| 229 | /* Setup GPU memory space */ | ||
| 230 | rdev->mc.vram_location = 0xFFFFFFFFUL; | ||
| 231 | rdev->mc.gtt_location = 0xFFFFFFFFUL; | ||
| 232 | r = radeon_mc_setup(rdev); | ||
| 233 | if (r) { | ||
| 234 | return r; | ||
| 235 | } | ||
| 236 | |||
| 237 | /* Program GPU memory space */ | ||
| 238 | /* Enable bus master */ | ||
| 239 | tmp = RREG32(RADEON_BUS_CNTL) & ~RS600_BUS_MASTER_DIS; | ||
| 240 | WREG32(RADEON_BUS_CNTL, tmp); | ||
| 241 | /* FIXME: What does AGP means for such chipset ? */ | ||
| 242 | WREG32_MC(RS600_MC_AGP_LOCATION, 0x0FFFFFFF); | ||
| 243 | /* FIXME: are this AGP reg in indirect MC range ? */ | ||
| 244 | WREG32_MC(RS600_MC_AGP_BASE, 0); | ||
| 245 | WREG32_MC(RS600_MC_AGP_BASE_2, 0); | ||
| 246 | rs600_mc_disable_clients(rdev); | ||
| 247 | if (rs600_mc_wait_for_idle(rdev)) { | ||
| 248 | printk(KERN_WARNING "Failed to wait MC idle while " | ||
| 249 | "programming pipes. Bad things might happen.\n"); | ||
| 250 | } | ||
| 251 | tmp = rdev->mc.vram_location + rdev->mc.mc_vram_size - 1; | ||
| 252 | tmp = REG_SET(RS600_MC_FB_TOP, tmp >> 16); | ||
| 253 | tmp |= REG_SET(RS600_MC_FB_START, rdev->mc.vram_location >> 16); | ||
| 254 | WREG32_MC(RS600_MC_FB_LOCATION, tmp); | ||
| 255 | WREG32(RS690_HDP_FB_LOCATION, rdev->mc.vram_location >> 16); | ||
| 256 | return 0; | ||
| 257 | } | ||
| 258 | |||
| 259 | void rs600_mc_fini(struct radeon_device *rdev) | ||
| 260 | { | ||
| 261 | } | ||
| 262 | |||
| 263 | |||
| 264 | /* | ||
| 265 | * Interrupts | ||
| 266 | */ | ||
| 267 | int rs600_irq_set(struct radeon_device *rdev) | 188 | int rs600_irq_set(struct radeon_device *rdev) |
| 268 | { | 189 | { |
| 269 | uint32_t tmp = 0; | 190 | uint32_t tmp = 0; |
| 270 | uint32_t mode_int = 0; | 191 | uint32_t mode_int = 0; |
| 271 | 192 | ||
| 272 | if (rdev->irq.sw_int) { | 193 | if (rdev->irq.sw_int) { |
| 273 | tmp |= RADEON_SW_INT_ENABLE; | 194 | tmp |= S_000040_SW_INT_EN(1); |
| 274 | } | 195 | } |
| 275 | if (rdev->irq.crtc_vblank_int[0]) { | 196 | if (rdev->irq.crtc_vblank_int[0]) { |
| 276 | mode_int |= AVIVO_D1MODE_INT_MASK; | 197 | mode_int |= S_006540_D1MODE_VBLANK_INT_MASK(1); |
| 277 | } | 198 | } |
| 278 | if (rdev->irq.crtc_vblank_int[1]) { | 199 | if (rdev->irq.crtc_vblank_int[1]) { |
| 279 | mode_int |= AVIVO_D2MODE_INT_MASK; | 200 | mode_int |= S_006540_D2MODE_VBLANK_INT_MASK(1); |
| 280 | } | 201 | } |
| 281 | WREG32(RADEON_GEN_INT_CNTL, tmp); | 202 | WREG32(R_000040_GEN_INT_CNTL, tmp); |
| 282 | WREG32(AVIVO_DxMODE_INT_MASK, mode_int); | 203 | WREG32(R_006540_DxMODE_INT_MASK, mode_int); |
| 283 | return 0; | 204 | return 0; |
| 284 | } | 205 | } |
| 285 | 206 | ||
| 286 | static inline uint32_t rs600_irq_ack(struct radeon_device *rdev, u32 *r500_disp_int) | 207 | static inline uint32_t rs600_irq_ack(struct radeon_device *rdev, u32 *r500_disp_int) |
| 287 | { | 208 | { |
| 288 | uint32_t irqs = RREG32(RADEON_GEN_INT_STATUS); | 209 | uint32_t irqs = RREG32(R_000044_GEN_INT_STATUS); |
| 289 | uint32_t irq_mask = RADEON_SW_INT_TEST; | 210 | uint32_t irq_mask = ~C_000044_SW_INT; |
| 290 | 211 | ||
| 291 | if (irqs & AVIVO_DISPLAY_INT_STATUS) { | 212 | if (G_000044_DISPLAY_INT_STAT(irqs)) { |
| 292 | *r500_disp_int = RREG32(AVIVO_DISP_INTERRUPT_STATUS); | 213 | *r500_disp_int = RREG32(R_007EDC_DISP_INTERRUPT_STATUS); |
| 293 | if (*r500_disp_int & AVIVO_D1_VBLANK_INTERRUPT) { | 214 | if (G_007EDC_LB_D1_VBLANK_INTERRUPT(*r500_disp_int)) { |
| 294 | WREG32(AVIVO_D1MODE_VBLANK_STATUS, AVIVO_VBLANK_ACK); | 215 | WREG32(R_006534_D1MODE_VBLANK_STATUS, |
| 216 | S_006534_D1MODE_VBLANK_ACK(1)); | ||
| 295 | } | 217 | } |
| 296 | if (*r500_disp_int & AVIVO_D2_VBLANK_INTERRUPT) { | 218 | if (G_007EDC_LB_D2_VBLANK_INTERRUPT(*r500_disp_int)) { |
| 297 | WREG32(AVIVO_D2MODE_VBLANK_STATUS, AVIVO_VBLANK_ACK); | 219 | WREG32(R_006D34_D2MODE_VBLANK_STATUS, |
| 220 | S_006D34_D2MODE_VBLANK_ACK(1)); | ||
| 298 | } | 221 | } |
| 299 | } else { | 222 | } else { |
| 300 | *r500_disp_int = 0; | 223 | *r500_disp_int = 0; |
| 301 | } | 224 | } |
| 302 | 225 | ||
| 303 | if (irqs) { | 226 | if (irqs) { |
| 304 | WREG32(RADEON_GEN_INT_STATUS, irqs); | 227 | WREG32(R_000044_GEN_INT_STATUS, irqs); |
| 305 | } | 228 | } |
| 306 | return irqs & irq_mask; | 229 | return irqs & irq_mask; |
| 307 | } | 230 | } |
| 308 | 231 | ||
| 232 | void rs600_irq_disable(struct radeon_device *rdev) | ||
| 233 | { | ||
| 234 | u32 tmp; | ||
| 235 | |||
| 236 | WREG32(R_000040_GEN_INT_CNTL, 0); | ||
| 237 | WREG32(R_006540_DxMODE_INT_MASK, 0); | ||
| 238 | /* Wait and acknowledge irq */ | ||
| 239 | mdelay(1); | ||
| 240 | rs600_irq_ack(rdev, &tmp); | ||
| 241 | } | ||
| 242 | |||
| 309 | int rs600_irq_process(struct radeon_device *rdev) | 243 | int rs600_irq_process(struct radeon_device *rdev) |
| 310 | { | 244 | { |
| 311 | uint32_t status; | 245 | uint32_t status; |
| @@ -317,16 +251,13 @@ int rs600_irq_process(struct radeon_device *rdev) | |||
| 317 | } | 251 | } |
| 318 | while (status || r500_disp_int) { | 252 | while (status || r500_disp_int) { |
| 319 | /* SW interrupt */ | 253 | /* SW interrupt */ |
| 320 | if (status & RADEON_SW_INT_TEST) { | 254 | if (G_000040_SW_INT_EN(status)) |
| 321 | radeon_fence_process(rdev); | 255 | radeon_fence_process(rdev); |
| 322 | } | ||
| 323 | /* Vertical blank interrupts */ | 256 | /* Vertical blank interrupts */ |
| 324 | if (r500_disp_int & AVIVO_D1_VBLANK_INTERRUPT) { | 257 | if (G_007EDC_LB_D1_VBLANK_INTERRUPT(r500_disp_int)) |
| 325 | drm_handle_vblank(rdev->ddev, 0); | 258 | drm_handle_vblank(rdev->ddev, 0); |
| 326 | } | 259 | if (G_007EDC_LB_D2_VBLANK_INTERRUPT(r500_disp_int)) |
| 327 | if (r500_disp_int & AVIVO_D2_VBLANK_INTERRUPT) { | ||
| 328 | drm_handle_vblank(rdev->ddev, 1); | 260 | drm_handle_vblank(rdev->ddev, 1); |
| 329 | } | ||
| 330 | status = rs600_irq_ack(rdev, &r500_disp_int); | 261 | status = rs600_irq_ack(rdev, &r500_disp_int); |
| 331 | } | 262 | } |
| 332 | return IRQ_HANDLED; | 263 | return IRQ_HANDLED; |
| @@ -335,53 +266,34 @@ int rs600_irq_process(struct radeon_device *rdev) | |||
| 335 | u32 rs600_get_vblank_counter(struct radeon_device *rdev, int crtc) | 266 | u32 rs600_get_vblank_counter(struct radeon_device *rdev, int crtc) |
| 336 | { | 267 | { |
| 337 | if (crtc == 0) | 268 | if (crtc == 0) |
| 338 | return RREG32(AVIVO_D1CRTC_FRAME_COUNT); | 269 | return RREG32(R_0060A4_D1CRTC_STATUS_FRAME_COUNT); |
| 339 | else | 270 | else |
| 340 | return RREG32(AVIVO_D2CRTC_FRAME_COUNT); | 271 | return RREG32(R_0068A4_D2CRTC_STATUS_FRAME_COUNT); |
| 341 | } | 272 | } |
| 342 | 273 | ||
| 343 | |||
| 344 | /* | ||
| 345 | * Global GPU functions | ||
| 346 | */ | ||
| 347 | int rs600_mc_wait_for_idle(struct radeon_device *rdev) | 274 | int rs600_mc_wait_for_idle(struct radeon_device *rdev) |
| 348 | { | 275 | { |
| 349 | unsigned i; | 276 | unsigned i; |
| 350 | uint32_t tmp; | ||
| 351 | 277 | ||
| 352 | for (i = 0; i < rdev->usec_timeout; i++) { | 278 | for (i = 0; i < rdev->usec_timeout; i++) { |
| 353 | /* read MC_STATUS */ | 279 | if (G_000000_MC_IDLE(RREG32_MC(R_000000_MC_STATUS))) |
| 354 | tmp = RREG32_MC(RS600_MC_STATUS); | ||
| 355 | if (tmp & RS600_MC_STATUS_IDLE) { | ||
| 356 | return 0; | 280 | return 0; |
| 357 | } | 281 | udelay(1); |
| 358 | DRM_UDELAY(1); | ||
| 359 | } | 282 | } |
| 360 | return -1; | 283 | return -1; |
| 361 | } | 284 | } |
| 362 | 285 | ||
| 363 | void rs600_errata(struct radeon_device *rdev) | ||
| 364 | { | ||
| 365 | rdev->pll_errata = 0; | ||
| 366 | } | ||
| 367 | |||
| 368 | void rs600_gpu_init(struct radeon_device *rdev) | 286 | void rs600_gpu_init(struct radeon_device *rdev) |
| 369 | { | 287 | { |
| 370 | /* FIXME: HDP same place on rs600 ? */ | 288 | /* FIXME: HDP same place on rs600 ? */ |
| 371 | r100_hdp_reset(rdev); | 289 | r100_hdp_reset(rdev); |
| 372 | rv515_vga_render_disable(rdev); | ||
| 373 | /* FIXME: is this correct ? */ | 290 | /* FIXME: is this correct ? */ |
| 374 | r420_pipes_init(rdev); | 291 | r420_pipes_init(rdev); |
| 375 | if (rs600_mc_wait_for_idle(rdev)) { | 292 | /* Wait for mc idle */ |
| 376 | printk(KERN_WARNING "Failed to wait MC idle while " | 293 | if (rs600_mc_wait_for_idle(rdev)) |
| 377 | "programming pipes. Bad things might happen.\n"); | 294 | dev_warn(rdev->dev, "Wait MC idle timeout before updating MC.\n"); |
| 378 | } | ||
| 379 | } | 295 | } |
| 380 | 296 | ||
| 381 | |||
| 382 | /* | ||
| 383 | * VRAM info. | ||
| 384 | */ | ||
| 385 | void rs600_vram_info(struct radeon_device *rdev) | 297 | void rs600_vram_info(struct radeon_device *rdev) |
| 386 | { | 298 | { |
| 387 | /* FIXME: to do or is these values sane ? */ | 299 | /* FIXME: to do or is these values sane ? */ |
| @@ -394,31 +306,206 @@ void rs600_bandwidth_update(struct radeon_device *rdev) | |||
| 394 | /* FIXME: implement, should this be like rs690 ? */ | 306 | /* FIXME: implement, should this be like rs690 ? */ |
| 395 | } | 307 | } |
| 396 | 308 | ||
| 397 | |||
| 398 | /* | ||
| 399 | * Indirect registers accessor | ||
| 400 | */ | ||
| 401 | uint32_t rs600_mc_rreg(struct radeon_device *rdev, uint32_t reg) | 309 | uint32_t rs600_mc_rreg(struct radeon_device *rdev, uint32_t reg) |
| 402 | { | 310 | { |
| 403 | uint32_t r; | 311 | WREG32(R_000070_MC_IND_INDEX, S_000070_MC_IND_ADDR(reg) | |
| 404 | 312 | S_000070_MC_IND_CITF_ARB0(1)); | |
| 405 | WREG32(RS600_MC_INDEX, | 313 | return RREG32(R_000074_MC_IND_DATA); |
| 406 | ((reg & RS600_MC_ADDR_MASK) | RS600_MC_IND_CITF_ARB0)); | ||
| 407 | r = RREG32(RS600_MC_DATA); | ||
| 408 | return r; | ||
| 409 | } | 314 | } |
| 410 | 315 | ||
| 411 | void rs600_mc_wreg(struct radeon_device *rdev, uint32_t reg, uint32_t v) | 316 | void rs600_mc_wreg(struct radeon_device *rdev, uint32_t reg, uint32_t v) |
| 412 | { | 317 | { |
| 413 | WREG32(RS600_MC_INDEX, | 318 | WREG32(R_000070_MC_IND_INDEX, S_000070_MC_IND_ADDR(reg) | |
| 414 | RS600_MC_IND_WR_EN | RS600_MC_IND_CITF_ARB0 | | 319 | S_000070_MC_IND_CITF_ARB0(1) | S_000070_MC_IND_WR_EN(1)); |
| 415 | ((reg) & RS600_MC_ADDR_MASK)); | 320 | WREG32(R_000074_MC_IND_DATA, v); |
| 416 | WREG32(RS600_MC_DATA, v); | ||
| 417 | } | 321 | } |
| 418 | 322 | ||
| 419 | int rs600_init(struct radeon_device *rdev) | 323 | void rs600_debugfs(struct radeon_device *rdev) |
| 324 | { | ||
| 325 | if (r100_debugfs_rbbm_init(rdev)) | ||
| 326 | DRM_ERROR("Failed to register debugfs file for RBBM !\n"); | ||
| 327 | } | ||
| 328 | |||
| 329 | void rs600_set_safe_registers(struct radeon_device *rdev) | ||
| 420 | { | 330 | { |
| 421 | rdev->config.r300.reg_safe_bm = rs600_reg_safe_bm; | 331 | rdev->config.r300.reg_safe_bm = rs600_reg_safe_bm; |
| 422 | rdev->config.r300.reg_safe_bm_size = ARRAY_SIZE(rs600_reg_safe_bm); | 332 | rdev->config.r300.reg_safe_bm_size = ARRAY_SIZE(rs600_reg_safe_bm); |
| 333 | } | ||
| 334 | |||
| 335 | static void rs600_mc_program(struct radeon_device *rdev) | ||
| 336 | { | ||
| 337 | struct rv515_mc_save save; | ||
| 338 | |||
| 339 | /* Stops all mc clients */ | ||
| 340 | rv515_mc_stop(rdev, &save); | ||
| 341 | |||
| 342 | /* Wait for mc idle */ | ||
| 343 | if (rs600_mc_wait_for_idle(rdev)) | ||
| 344 | dev_warn(rdev->dev, "Wait MC idle timeout before updating MC.\n"); | ||
| 345 | |||
| 346 | /* FIXME: What does AGP means for such chipset ? */ | ||
| 347 | WREG32_MC(R_000005_MC_AGP_LOCATION, 0x0FFFFFFF); | ||
| 348 | WREG32_MC(R_000006_AGP_BASE, 0); | ||
| 349 | WREG32_MC(R_000007_AGP_BASE_2, 0); | ||
| 350 | /* Program MC */ | ||
| 351 | WREG32_MC(R_000004_MC_FB_LOCATION, | ||
| 352 | S_000004_MC_FB_START(rdev->mc.vram_start >> 16) | | ||
| 353 | S_000004_MC_FB_TOP(rdev->mc.vram_end >> 16)); | ||
| 354 | WREG32(R_000134_HDP_FB_LOCATION, | ||
| 355 | S_000134_HDP_FB_START(rdev->mc.vram_start >> 16)); | ||
| 356 | |||
| 357 | rv515_mc_resume(rdev, &save); | ||
| 358 | } | ||
| 359 | |||
| 360 | static int rs600_startup(struct radeon_device *rdev) | ||
| 361 | { | ||
| 362 | int r; | ||
| 363 | |||
| 364 | rs600_mc_program(rdev); | ||
| 365 | /* Resume clock */ | ||
| 366 | rv515_clock_startup(rdev); | ||
| 367 | /* Initialize GPU configuration (# pipes, ...) */ | ||
| 368 | rs600_gpu_init(rdev); | ||
| 369 | /* Initialize GART (initialize after TTM so we can allocate | ||
| 370 | * memory through TTM but finalize after TTM) */ | ||
| 371 | r = rs600_gart_enable(rdev); | ||
| 372 | if (r) | ||
| 373 | return r; | ||
| 374 | /* Enable IRQ */ | ||
| 375 | rdev->irq.sw_int = true; | ||
| 376 | rs600_irq_set(rdev); | ||
| 377 | /* 1M ring buffer */ | ||
| 378 | r = r100_cp_init(rdev, 1024 * 1024); | ||
| 379 | if (r) { | ||
| 380 | dev_err(rdev->dev, "failled initializing CP (%d).\n", r); | ||
| 381 | return r; | ||
| 382 | } | ||
| 383 | r = r100_wb_init(rdev); | ||
| 384 | if (r) | ||
| 385 | dev_err(rdev->dev, "failled initializing WB (%d).\n", r); | ||
| 386 | r = r100_ib_init(rdev); | ||
| 387 | if (r) { | ||
| 388 | dev_err(rdev->dev, "failled initializing IB (%d).\n", r); | ||
| 389 | return r; | ||
| 390 | } | ||
| 391 | return 0; | ||
| 392 | } | ||
| 393 | |||
| 394 | int rs600_resume(struct radeon_device *rdev) | ||
| 395 | { | ||
| 396 | /* Make sur GART are not working */ | ||
| 397 | rs600_gart_disable(rdev); | ||
| 398 | /* Resume clock before doing reset */ | ||
| 399 | rv515_clock_startup(rdev); | ||
| 400 | /* Reset gpu before posting otherwise ATOM will enter infinite loop */ | ||
| 401 | if (radeon_gpu_reset(rdev)) { | ||
| 402 | dev_warn(rdev->dev, "GPU reset failed ! (0xE40=0x%08X, 0x7C0=0x%08X)\n", | ||
| 403 | RREG32(R_000E40_RBBM_STATUS), | ||
| 404 | RREG32(R_0007C0_CP_STAT)); | ||
| 405 | } | ||
| 406 | /* post */ | ||
| 407 | atom_asic_init(rdev->mode_info.atom_context); | ||
| 408 | /* Resume clock after posting */ | ||
| 409 | rv515_clock_startup(rdev); | ||
| 410 | return rs600_startup(rdev); | ||
| 411 | } | ||
| 412 | |||
| 413 | int rs600_suspend(struct radeon_device *rdev) | ||
| 414 | { | ||
| 415 | r100_cp_disable(rdev); | ||
| 416 | r100_wb_disable(rdev); | ||
| 417 | rs600_irq_disable(rdev); | ||
| 418 | rs600_gart_disable(rdev); | ||
| 419 | return 0; | ||
| 420 | } | ||
| 421 | |||
| 422 | void rs600_fini(struct radeon_device *rdev) | ||
| 423 | { | ||
| 424 | rs600_suspend(rdev); | ||
| 425 | r100_cp_fini(rdev); | ||
| 426 | r100_wb_fini(rdev); | ||
| 427 | r100_ib_fini(rdev); | ||
| 428 | radeon_gem_fini(rdev); | ||
| 429 | rs600_gart_fini(rdev); | ||
| 430 | radeon_irq_kms_fini(rdev); | ||
| 431 | radeon_fence_driver_fini(rdev); | ||
| 432 | radeon_object_fini(rdev); | ||
| 433 | radeon_atombios_fini(rdev); | ||
| 434 | kfree(rdev->bios); | ||
| 435 | rdev->bios = NULL; | ||
| 436 | } | ||
| 437 | |||
| 438 | int rs600_init(struct radeon_device *rdev) | ||
| 439 | { | ||
| 440 | int r; | ||
| 441 | |||
| 442 | /* Disable VGA */ | ||
| 443 | rv515_vga_render_disable(rdev); | ||
| 444 | /* Initialize scratch registers */ | ||
| 445 | radeon_scratch_init(rdev); | ||
| 446 | /* Initialize surface registers */ | ||
| 447 | radeon_surface_init(rdev); | ||
| 448 | /* BIOS */ | ||
| 449 | if (!radeon_get_bios(rdev)) { | ||
| 450 | if (ASIC_IS_AVIVO(rdev)) | ||
| 451 | return -EINVAL; | ||
| 452 | } | ||
| 453 | if (rdev->is_atom_bios) { | ||
| 454 | r = radeon_atombios_init(rdev); | ||
| 455 | if (r) | ||
| 456 | return r; | ||
| 457 | } else { | ||
| 458 | dev_err(rdev->dev, "Expecting atombios for RS600 GPU\n"); | ||
| 459 | return -EINVAL; | ||
| 460 | } | ||
| 461 | /* Reset gpu before posting otherwise ATOM will enter infinite loop */ | ||
| 462 | if (radeon_gpu_reset(rdev)) { | ||
| 463 | dev_warn(rdev->dev, | ||
| 464 | "GPU reset failed ! (0xE40=0x%08X, 0x7C0=0x%08X)\n", | ||
| 465 | RREG32(R_000E40_RBBM_STATUS), | ||
| 466 | RREG32(R_0007C0_CP_STAT)); | ||
| 467 | } | ||
| 468 | /* check if cards are posted or not */ | ||
| 469 | if (!radeon_card_posted(rdev) && rdev->bios) { | ||
| 470 | DRM_INFO("GPU not posted. posting now...\n"); | ||
| 471 | atom_asic_init(rdev->mode_info.atom_context); | ||
| 472 | } | ||
| 473 | /* Initialize clocks */ | ||
| 474 | radeon_get_clock_info(rdev->ddev); | ||
| 475 | /* Get vram informations */ | ||
| 476 | rs600_vram_info(rdev); | ||
| 477 | /* Initialize memory controller (also test AGP) */ | ||
| 478 | r = r420_mc_init(rdev); | ||
| 479 | if (r) | ||
| 480 | return r; | ||
| 481 | rs600_debugfs(rdev); | ||
| 482 | /* Fence driver */ | ||
| 483 | r = radeon_fence_driver_init(rdev); | ||
| 484 | if (r) | ||
| 485 | return r; | ||
| 486 | r = radeon_irq_kms_init(rdev); | ||
| 487 | if (r) | ||
| 488 | return r; | ||
| 489 | /* Memory manager */ | ||
| 490 | r = radeon_object_init(rdev); | ||
| 491 | if (r) | ||
| 492 | return r; | ||
| 493 | r = rs600_gart_init(rdev); | ||
| 494 | if (r) | ||
| 495 | return r; | ||
| 496 | rs600_set_safe_registers(rdev); | ||
| 497 | rdev->accel_working = true; | ||
| 498 | r = rs600_startup(rdev); | ||
| 499 | if (r) { | ||
| 500 | /* Somethings want wront with the accel init stop accel */ | ||
| 501 | dev_err(rdev->dev, "Disabling GPU acceleration\n"); | ||
| 502 | rs600_suspend(rdev); | ||
| 503 | r100_cp_fini(rdev); | ||
| 504 | r100_wb_fini(rdev); | ||
| 505 | r100_ib_fini(rdev); | ||
| 506 | rs600_gart_fini(rdev); | ||
| 507 | radeon_irq_kms_fini(rdev); | ||
| 508 | rdev->accel_working = false; | ||
| 509 | } | ||
| 423 | return 0; | 510 | return 0; |
| 424 | } | 511 | } |
diff --git a/drivers/gpu/drm/radeon/rs600d.h b/drivers/gpu/drm/radeon/rs600d.h new file mode 100644 index 000000000000..81308924859a --- /dev/null +++ b/drivers/gpu/drm/radeon/rs600d.h | |||
| @@ -0,0 +1,470 @@ | |||
| 1 | /* | ||
| 2 | * Copyright 2008 Advanced Micro Devices, Inc. | ||
| 3 | * Copyright 2008 Red Hat Inc. | ||
| 4 | * Copyright 2009 Jerome Glisse. | ||
| 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: Dave Airlie | ||
| 25 | * Alex Deucher | ||
| 26 | * Jerome Glisse | ||
| 27 | */ | ||
| 28 | #ifndef __RS600D_H__ | ||
| 29 | #define __RS600D_H__ | ||
| 30 | |||
| 31 | /* Registers */ | ||
| 32 | #define R_000040_GEN_INT_CNTL 0x000040 | ||
| 33 | #define S_000040_DISPLAY_INT_STATUS(x) (((x) & 0x1) << 0) | ||
| 34 | #define G_000040_DISPLAY_INT_STATUS(x) (((x) >> 0) & 0x1) | ||
| 35 | #define C_000040_DISPLAY_INT_STATUS 0xFFFFFFFE | ||
| 36 | #define S_000040_DMA_VIPH0_INT_EN(x) (((x) & 0x1) << 12) | ||
| 37 | #define G_000040_DMA_VIPH0_INT_EN(x) (((x) >> 12) & 0x1) | ||
| 38 | #define C_000040_DMA_VIPH0_INT_EN 0xFFFFEFFF | ||
| 39 | #define S_000040_CRTC2_VSYNC(x) (((x) & 0x1) << 6) | ||
| 40 | #define G_000040_CRTC2_VSYNC(x) (((x) >> 6) & 0x1) | ||
| 41 | #define C_000040_CRTC2_VSYNC 0xFFFFFFBF | ||
| 42 | #define S_000040_SNAPSHOT2(x) (((x) & 0x1) << 7) | ||
| 43 | #define G_000040_SNAPSHOT2(x) (((x) >> 7) & 0x1) | ||
| 44 | #define C_000040_SNAPSHOT2 0xFFFFFF7F | ||
| 45 | #define S_000040_CRTC2_VBLANK(x) (((x) & 0x1) << 9) | ||
| 46 | #define G_000040_CRTC2_VBLANK(x) (((x) >> 9) & 0x1) | ||
| 47 | #define C_000040_CRTC2_VBLANK 0xFFFFFDFF | ||
| 48 | #define S_000040_FP2_DETECT(x) (((x) & 0x1) << 10) | ||
| 49 | #define G_000040_FP2_DETECT(x) (((x) >> 10) & 0x1) | ||
| 50 | #define C_000040_FP2_DETECT 0xFFFFFBFF | ||
| 51 | #define S_000040_VSYNC_DIFF_OVER_LIMIT(x) (((x) & 0x1) << 11) | ||
| 52 | #define G_000040_VSYNC_DIFF_OVER_LIMIT(x) (((x) >> 11) & 0x1) | ||
| 53 | #define C_000040_VSYNC_DIFF_OVER_LIMIT 0xFFFFF7FF | ||
| 54 | #define S_000040_DMA_VIPH1_INT_EN(x) (((x) & 0x1) << 13) | ||
| 55 | #define G_000040_DMA_VIPH1_INT_EN(x) (((x) >> 13) & 0x1) | ||
| 56 | #define C_000040_DMA_VIPH1_INT_EN 0xFFFFDFFF | ||
| 57 | #define S_000040_DMA_VIPH2_INT_EN(x) (((x) & 0x1) << 14) | ||
| 58 | #define G_000040_DMA_VIPH2_INT_EN(x) (((x) >> 14) & 0x1) | ||
| 59 | #define C_000040_DMA_VIPH2_INT_EN 0xFFFFBFFF | ||
| 60 | #define S_000040_DMA_VIPH3_INT_EN(x) (((x) & 0x1) << 15) | ||
| 61 | #define G_000040_DMA_VIPH3_INT_EN(x) (((x) >> 15) & 0x1) | ||
| 62 | #define C_000040_DMA_VIPH3_INT_EN 0xFFFF7FFF | ||
| 63 | #define S_000040_I2C_INT_EN(x) (((x) & 0x1) << 17) | ||
| 64 | #define G_000040_I2C_INT_EN(x) (((x) >> 17) & 0x1) | ||
| 65 | #define C_000040_I2C_INT_EN 0xFFFDFFFF | ||
| 66 | #define S_000040_GUI_IDLE(x) (((x) & 0x1) << 19) | ||
| 67 | #define G_000040_GUI_IDLE(x) (((x) >> 19) & 0x1) | ||
| 68 | #define C_000040_GUI_IDLE 0xFFF7FFFF | ||
| 69 | #define S_000040_VIPH_INT_EN(x) (((x) & 0x1) << 24) | ||
| 70 | #define G_000040_VIPH_INT_EN(x) (((x) >> 24) & 0x1) | ||
| 71 | #define C_000040_VIPH_INT_EN 0xFEFFFFFF | ||
| 72 | #define S_000040_SW_INT_EN(x) (((x) & 0x1) << 25) | ||
| 73 | #define G_000040_SW_INT_EN(x) (((x) >> 25) & 0x1) | ||
| 74 | #define C_000040_SW_INT_EN 0xFDFFFFFF | ||
| 75 | #define S_000040_GEYSERVILLE(x) (((x) & 0x1) << 27) | ||
| 76 | #define G_000040_GEYSERVILLE(x) (((x) >> 27) & 0x1) | ||
| 77 | #define C_000040_GEYSERVILLE 0xF7FFFFFF | ||
| 78 | #define S_000040_HDCP_AUTHORIZED_INT(x) (((x) & 0x1) << 28) | ||
| 79 | #define G_000040_HDCP_AUTHORIZED_INT(x) (((x) >> 28) & 0x1) | ||
| 80 | #define C_000040_HDCP_AUTHORIZED_INT 0xEFFFFFFF | ||
| 81 | #define S_000040_DVI_I2C_INT(x) (((x) & 0x1) << 29) | ||
| 82 | #define G_000040_DVI_I2C_INT(x) (((x) >> 29) & 0x1) | ||
| 83 | #define C_000040_DVI_I2C_INT 0xDFFFFFFF | ||
| 84 | #define S_000040_GUIDMA(x) (((x) & 0x1) << 30) | ||
| 85 | #define G_000040_GUIDMA(x) (((x) >> 30) & 0x1) | ||
| 86 | #define C_000040_GUIDMA 0xBFFFFFFF | ||
| 87 | #define S_000040_VIDDMA(x) (((x) & 0x1) << 31) | ||
| 88 | #define G_000040_VIDDMA(x) (((x) >> 31) & 0x1) | ||
| 89 | #define C_000040_VIDDMA 0x7FFFFFFF | ||
| 90 | #define R_000044_GEN_INT_STATUS 0x000044 | ||
| 91 | #define S_000044_DISPLAY_INT_STAT(x) (((x) & 0x1) << 0) | ||
| 92 | #define G_000044_DISPLAY_INT_STAT(x) (((x) >> 0) & 0x1) | ||
| 93 | #define C_000044_DISPLAY_INT_STAT 0xFFFFFFFE | ||
| 94 | #define S_000044_VGA_INT_STAT(x) (((x) & 0x1) << 1) | ||
| 95 | #define G_000044_VGA_INT_STAT(x) (((x) >> 1) & 0x1) | ||
| 96 | #define C_000044_VGA_INT_STAT 0xFFFFFFFD | ||
| 97 | #define S_000044_CAP0_INT_ACTIVE(x) (((x) & 0x1) << 8) | ||
| 98 | #define G_000044_CAP0_INT_ACTIVE(x) (((x) >> 8) & 0x1) | ||
| 99 | #define C_000044_CAP0_INT_ACTIVE 0xFFFFFEFF | ||
| 100 | #define S_000044_DMA_VIPH0_INT(x) (((x) & 0x1) << 12) | ||
| 101 | #define G_000044_DMA_VIPH0_INT(x) (((x) >> 12) & 0x1) | ||
| 102 | #define C_000044_DMA_VIPH0_INT 0xFFFFEFFF | ||
| 103 | #define S_000044_DMA_VIPH1_INT(x) (((x) & 0x1) << 13) | ||
| 104 | #define G_000044_DMA_VIPH1_INT(x) (((x) >> 13) & 0x1) | ||
| 105 | #define C_000044_DMA_VIPH1_INT 0xFFFFDFFF | ||
| 106 | #define S_000044_DMA_VIPH2_INT(x) (((x) & 0x1) << 14) | ||
| 107 | #define G_000044_DMA_VIPH2_INT(x) (((x) >> 14) & 0x1) | ||
| 108 | #define C_000044_DMA_VIPH2_INT 0xFFFFBFFF | ||
| 109 | #define S_000044_DMA_VIPH3_INT(x) (((x) & 0x1) << 15) | ||
| 110 | #define G_000044_DMA_VIPH3_INT(x) (((x) >> 15) & 0x1) | ||
| 111 | #define C_000044_DMA_VIPH3_INT 0xFFFF7FFF | ||
| 112 | #define S_000044_MC_PROBE_FAULT_STAT(x) (((x) & 0x1) << 16) | ||
| 113 | #define G_000044_MC_PROBE_FAULT_STAT(x) (((x) >> 16) & 0x1) | ||
| 114 | #define C_000044_MC_PROBE_FAULT_STAT 0xFFFEFFFF | ||
| 115 | #define S_000044_I2C_INT(x) (((x) & 0x1) << 17) | ||
| 116 | #define G_000044_I2C_INT(x) (((x) >> 17) & 0x1) | ||
| 117 | #define C_000044_I2C_INT 0xFFFDFFFF | ||
| 118 | #define S_000044_SCRATCH_INT_STAT(x) (((x) & 0x1) << 18) | ||
| 119 | #define G_000044_SCRATCH_INT_STAT(x) (((x) >> 18) & 0x1) | ||
| 120 | #define C_000044_SCRATCH_INT_STAT 0xFFFBFFFF | ||
| 121 | #define S_000044_GUI_IDLE_STAT(x) (((x) & 0x1) << 19) | ||
| 122 | #define G_000044_GUI_IDLE_STAT(x) (((x) >> 19) & 0x1) | ||
| 123 | #define C_000044_GUI_IDLE_STAT 0xFFF7FFFF | ||
| 124 | #define S_000044_ATI_OVERDRIVE_INT_STAT(x) (((x) & 0x1) << 20) | ||
| 125 | #define G_000044_ATI_OVERDRIVE_INT_STAT(x) (((x) >> 20) & 0x1) | ||
| 126 | #define C_000044_ATI_OVERDRIVE_INT_STAT 0xFFEFFFFF | ||
| 127 | #define S_000044_MC_PROTECTION_FAULT_STAT(x) (((x) & 0x1) << 21) | ||
| 128 | #define G_000044_MC_PROTECTION_FAULT_STAT(x) (((x) >> 21) & 0x1) | ||
| 129 | #define C_000044_MC_PROTECTION_FAULT_STAT 0xFFDFFFFF | ||
| 130 | #define S_000044_RBBM_READ_INT_STAT(x) (((x) & 0x1) << 22) | ||
| 131 | #define G_000044_RBBM_READ_INT_STAT(x) (((x) >> 22) & 0x1) | ||
| 132 | #define C_000044_RBBM_READ_INT_STAT 0xFFBFFFFF | ||
| 133 | #define S_000044_CB_CONTEXT_SWITCH_STAT(x) (((x) & 0x1) << 23) | ||
| 134 | #define G_000044_CB_CONTEXT_SWITCH_STAT(x) (((x) >> 23) & 0x1) | ||
| 135 | #define C_000044_CB_CONTEXT_SWITCH_STAT 0xFF7FFFFF | ||
| 136 | #define S_000044_VIPH_INT(x) (((x) & 0x1) << 24) | ||
| 137 | #define G_000044_VIPH_INT(x) (((x) >> 24) & 0x1) | ||
| 138 | #define C_000044_VIPH_INT 0xFEFFFFFF | ||
| 139 | #define S_000044_SW_INT(x) (((x) & 0x1) << 25) | ||
| 140 | #define G_000044_SW_INT(x) (((x) >> 25) & 0x1) | ||
| 141 | #define C_000044_SW_INT 0xFDFFFFFF | ||
| 142 | #define S_000044_SW_INT_SET(x) (((x) & 0x1) << 26) | ||
| 143 | #define G_000044_SW_INT_SET(x) (((x) >> 26) & 0x1) | ||
| 144 | #define C_000044_SW_INT_SET 0xFBFFFFFF | ||
| 145 | #define S_000044_IDCT_INT_STAT(x) (((x) & 0x1) << 27) | ||
| 146 | #define G_000044_IDCT_INT_STAT(x) (((x) >> 27) & 0x1) | ||
| 147 | #define C_000044_IDCT_INT_STAT 0xF7FFFFFF | ||
| 148 | #define S_000044_GUIDMA_STAT(x) (((x) & 0x1) << 30) | ||
| 149 | #define G_000044_GUIDMA_STAT(x) (((x) >> 30) & 0x1) | ||
| 150 | #define C_000044_GUIDMA_STAT 0xBFFFFFFF | ||
| 151 | #define S_000044_VIDDMA_STAT(x) (((x) & 0x1) << 31) | ||
| 152 | #define G_000044_VIDDMA_STAT(x) (((x) >> 31) & 0x1) | ||
| 153 | #define C_000044_VIDDMA_STAT 0x7FFFFFFF | ||
| 154 | #define R_00004C_BUS_CNTL 0x00004C | ||
| 155 | #define S_00004C_BUS_MASTER_DIS(x) (((x) & 0x1) << 14) | ||
| 156 | #define G_00004C_BUS_MASTER_DIS(x) (((x) >> 14) & 0x1) | ||
| 157 | #define C_00004C_BUS_MASTER_DIS 0xFFFFBFFF | ||
| 158 | #define S_00004C_BUS_MSI_REARM(x) (((x) & 0x1) << 20) | ||
| 159 | #define G_00004C_BUS_MSI_REARM(x) (((x) >> 20) & 0x1) | ||
| 160 | #define C_00004C_BUS_MSI_REARM 0xFFEFFFFF | ||
| 161 | #define R_000070_MC_IND_INDEX 0x000070 | ||
| 162 | #define S_000070_MC_IND_ADDR(x) (((x) & 0xFFFF) << 0) | ||
| 163 | #define G_000070_MC_IND_ADDR(x) (((x) >> 0) & 0xFFFF) | ||
| 164 | #define C_000070_MC_IND_ADDR 0xFFFF0000 | ||
| 165 | #define S_000070_MC_IND_SEQ_RBS_0(x) (((x) & 0x1) << 16) | ||
| 166 | #define G_000070_MC_IND_SEQ_RBS_0(x) (((x) >> 16) & 0x1) | ||
| 167 | #define C_000070_MC_IND_SEQ_RBS_0 0xFFFEFFFF | ||
| 168 | #define S_000070_MC_IND_SEQ_RBS_1(x) (((x) & 0x1) << 17) | ||
| 169 | #define G_000070_MC_IND_SEQ_RBS_1(x) (((x) >> 17) & 0x1) | ||
| 170 | #define C_000070_MC_IND_SEQ_RBS_1 0xFFFDFFFF | ||
| 171 | #define S_000070_MC_IND_SEQ_RBS_2(x) (((x) & 0x1) << 18) | ||
| 172 | #define G_000070_MC_IND_SEQ_RBS_2(x) (((x) >> 18) & 0x1) | ||
| 173 | #define C_000070_MC_IND_SEQ_RBS_2 0xFFFBFFFF | ||
| 174 | #define S_000070_MC_IND_SEQ_RBS_3(x) (((x) & 0x1) << 19) | ||
| 175 | #define G_000070_MC_IND_SEQ_RBS_3(x) (((x) >> 19) & 0x1) | ||
| 176 | #define C_000070_MC_IND_SEQ_RBS_3 0xFFF7FFFF | ||
| 177 | #define S_000070_MC_IND_AIC_RBS(x) (((x) & 0x1) << 20) | ||
| 178 | #define G_000070_MC_IND_AIC_RBS(x) (((x) >> 20) & 0x1) | ||
| 179 | #define C_000070_MC_IND_AIC_RBS 0xFFEFFFFF | ||
| 180 | #define S_000070_MC_IND_CITF_ARB0(x) (((x) & 0x1) << 21) | ||
| 181 | #define G_000070_MC_IND_CITF_ARB0(x) (((x) >> 21) & 0x1) | ||
| 182 | #define C_000070_MC_IND_CITF_ARB0 0xFFDFFFFF | ||
| 183 | #define S_000070_MC_IND_CITF_ARB1(x) (((x) & 0x1) << 22) | ||
| 184 | #define G_000070_MC_IND_CITF_ARB1(x) (((x) >> 22) & 0x1) | ||
| 185 | #define C_000070_MC_IND_CITF_ARB1 0xFFBFFFFF | ||
| 186 | #define S_000070_MC_IND_WR_EN(x) (((x) & 0x1) << 23) | ||
| 187 | #define G_000070_MC_IND_WR_EN(x) (((x) >> 23) & 0x1) | ||
| 188 | #define C_000070_MC_IND_WR_EN 0xFF7FFFFF | ||
| 189 | #define S_000070_MC_IND_RD_INV(x) (((x) & 0x1) << 24) | ||
| 190 | #define G_000070_MC_IND_RD_INV(x) (((x) >> 24) & 0x1) | ||
| 191 | #define C_000070_MC_IND_RD_INV 0xFEFFFFFF | ||
| 192 | #define R_000074_MC_IND_DATA 0x000074 | ||
| 193 | #define S_000074_MC_IND_DATA(x) (((x) & 0xFFFFFFFF) << 0) | ||
| 194 | #define G_000074_MC_IND_DATA(x) (((x) >> 0) & 0xFFFFFFFF) | ||
| 195 | #define C_000074_MC_IND_DATA 0x00000000 | ||
| 196 | #define R_000134_HDP_FB_LOCATION 0x000134 | ||
| 197 | #define S_000134_HDP_FB_START(x) (((x) & 0xFFFF) << 0) | ||
| 198 | #define G_000134_HDP_FB_START(x) (((x) >> 0) & 0xFFFF) | ||
| 199 | #define C_000134_HDP_FB_START 0xFFFF0000 | ||
| 200 | #define R_0007C0_CP_STAT 0x0007C0 | ||
| 201 | #define S_0007C0_MRU_BUSY(x) (((x) & 0x1) << 0) | ||
| 202 | #define G_0007C0_MRU_BUSY(x) (((x) >> 0) & 0x1) | ||
| 203 | #define C_0007C0_MRU_BUSY 0xFFFFFFFE | ||
| 204 | #define S_0007C0_MWU_BUSY(x) (((x) & 0x1) << 1) | ||
| 205 | #define G_0007C0_MWU_BUSY(x) (((x) >> 1) & 0x1) | ||
| 206 | #define C_0007C0_MWU_BUSY 0xFFFFFFFD | ||
| 207 | #define S_0007C0_RSIU_BUSY(x) (((x) & 0x1) << 2) | ||
| 208 | #define G_0007C0_RSIU_BUSY(x) (((x) >> 2) & 0x1) | ||
| 209 | #define C_0007C0_RSIU_BUSY 0xFFFFFFFB | ||
| 210 | #define S_0007C0_RCIU_BUSY(x) (((x) & 0x1) << 3) | ||
| 211 | #define G_0007C0_RCIU_BUSY(x) (((x) >> 3) & 0x1) | ||
| 212 | #define C_0007C0_RCIU_BUSY 0xFFFFFFF7 | ||
| 213 | #define S_0007C0_CSF_PRIMARY_BUSY(x) (((x) & 0x1) << 9) | ||
| 214 | #define G_0007C0_CSF_PRIMARY_BUSY(x) (((x) >> 9) & 0x1) | ||
| 215 | #define C_0007C0_CSF_PRIMARY_BUSY 0xFFFFFDFF | ||
| 216 | #define S_0007C0_CSF_INDIRECT_BUSY(x) (((x) & 0x1) << 10) | ||
| 217 | #define G_0007C0_CSF_INDIRECT_BUSY(x) (((x) >> 10) & 0x1) | ||
| 218 | #define C_0007C0_CSF_INDIRECT_BUSY 0xFFFFFBFF | ||
| 219 | #define S_0007C0_CSQ_PRIMARY_BUSY(x) (((x) & 0x1) << 11) | ||
| 220 | #define G_0007C0_CSQ_PRIMARY_BUSY(x) (((x) >> 11) & 0x1) | ||
| 221 | #define C_0007C0_CSQ_PRIMARY_BUSY 0xFFFFF7FF | ||
| 222 | #define S_0007C0_CSQ_INDIRECT_BUSY(x) (((x) & 0x1) << 12) | ||
| 223 | #define G_0007C0_CSQ_INDIRECT_BUSY(x) (((x) >> 12) & 0x1) | ||
| 224 | #define C_0007C0_CSQ_INDIRECT_BUSY 0xFFFFEFFF | ||
| 225 | #define S_0007C0_CSI_BUSY(x) (((x) & 0x1) << 13) | ||
| 226 | #define G_0007C0_CSI_BUSY(x) (((x) >> 13) & 0x1) | ||
| 227 | #define C_0007C0_CSI_BUSY 0xFFFFDFFF | ||
| 228 | #define S_0007C0_CSF_INDIRECT2_BUSY(x) (((x) & 0x1) << 14) | ||
| 229 | #define G_0007C0_CSF_INDIRECT2_BUSY(x) (((x) >> 14) & 0x1) | ||
| 230 | #define C_0007C0_CSF_INDIRECT2_BUSY 0xFFFFBFFF | ||
| 231 | #define S_0007C0_CSQ_INDIRECT2_BUSY(x) (((x) & 0x1) << 15) | ||
| 232 | #define G_0007C0_CSQ_INDIRECT2_BUSY(x) (((x) >> 15) & 0x1) | ||
| 233 | #define C_0007C0_CSQ_INDIRECT2_BUSY 0xFFFF7FFF | ||
| 234 | #define S_0007C0_GUIDMA_BUSY(x) (((x) & 0x1) << 28) | ||
| 235 | #define G_0007C0_GUIDMA_BUSY(x) (((x) >> 28) & 0x1) | ||
| 236 | #define C_0007C0_GUIDMA_BUSY 0xEFFFFFFF | ||
| 237 | #define S_0007C0_VIDDMA_BUSY(x) (((x) & 0x1) << 29) | ||
| 238 | #define G_0007C0_VIDDMA_BUSY(x) (((x) >> 29) & 0x1) | ||
| 239 | #define C_0007C0_VIDDMA_BUSY 0xDFFFFFFF | ||
| 240 | #define S_0007C0_CMDSTRM_BUSY(x) (((x) & 0x1) << 30) | ||
| 241 | #define G_0007C0_CMDSTRM_BUSY(x) (((x) >> 30) & 0x1) | ||
| 242 | #define C_0007C0_CMDSTRM_BUSY 0xBFFFFFFF | ||
| 243 | #define S_0007C0_CP_BUSY(x) (((x) & 0x1) << 31) | ||
| 244 | #define G_0007C0_CP_BUSY(x) (((x) >> 31) & 0x1) | ||
| 245 | #define C_0007C0_CP_BUSY 0x7FFFFFFF | ||
| 246 | #define R_000E40_RBBM_STATUS 0x000E40 | ||
| 247 | #define S_000E40_CMDFIFO_AVAIL(x) (((x) & 0x7F) << 0) | ||
| 248 | #define G_000E40_CMDFIFO_AVAIL(x) (((x) >> 0) & 0x7F) | ||
| 249 | #define C_000E40_CMDFIFO_AVAIL 0xFFFFFF80 | ||
| 250 | #define S_000E40_HIRQ_ON_RBB(x) (((x) & 0x1) << 8) | ||
| 251 | #define G_000E40_HIRQ_ON_RBB(x) (((x) >> 8) & 0x1) | ||
| 252 | #define C_000E40_HIRQ_ON_RBB 0xFFFFFEFF | ||
| 253 | #define S_000E40_CPRQ_ON_RBB(x) (((x) & 0x1) << 9) | ||
| 254 | #define G_000E40_CPRQ_ON_RBB(x) (((x) >> 9) & 0x1) | ||
| 255 | #define C_000E40_CPRQ_ON_RBB 0xFFFFFDFF | ||
| 256 | #define S_000E40_CFRQ_ON_RBB(x) (((x) & 0x1) << 10) | ||
| 257 | #define G_000E40_CFRQ_ON_RBB(x) (((x) >> 10) & 0x1) | ||
| 258 | #define C_000E40_CFRQ_ON_RBB 0xFFFFFBFF | ||
| 259 | #define S_000E40_HIRQ_IN_RTBUF(x) (((x) & 0x1) << 11) | ||
| 260 | #define G_000E40_HIRQ_IN_RTBUF(x) (((x) >> 11) & 0x1) | ||
| 261 | #define C_000E40_HIRQ_IN_RTBUF 0xFFFFF7FF | ||
| 262 | #define S_000E40_CPRQ_IN_RTBUF(x) (((x) & 0x1) << 12) | ||
| 263 | #define G_000E40_CPRQ_IN_RTBUF(x) (((x) >> 12) & 0x1) | ||
| 264 | #define C_000E40_CPRQ_IN_RTBUF 0xFFFFEFFF | ||
| 265 | #define S_000E40_CFRQ_IN_RTBUF(x) (((x) & 0x1) << 13) | ||
| 266 | #define G_000E40_CFRQ_IN_RTBUF(x) (((x) >> 13) & 0x1) | ||
| 267 | #define C_000E40_CFRQ_IN_RTBUF 0xFFFFDFFF | ||
| 268 | #define S_000E40_CF_PIPE_BUSY(x) (((x) & 0x1) << 14) | ||
| 269 | #define G_000E40_CF_PIPE_BUSY(x) (((x) >> 14) & 0x1) | ||
| 270 | #define C_000E40_CF_PIPE_BUSY 0xFFFFBFFF | ||
| 271 | #define S_000E40_ENG_EV_BUSY(x) (((x) & 0x1) << 15) | ||
| 272 | #define G_000E40_ENG_EV_BUSY(x) (((x) >> 15) & 0x1) | ||
| 273 | #define C_000E40_ENG_EV_BUSY 0xFFFF7FFF | ||
| 274 | #define S_000E40_CP_CMDSTRM_BUSY(x) (((x) & 0x1) << 16) | ||
| 275 | #define G_000E40_CP_CMDSTRM_BUSY(x) (((x) >> 16) & 0x1) | ||
| 276 | #define C_000E40_CP_CMDSTRM_BUSY 0xFFFEFFFF | ||
| 277 | #define S_000E40_E2_BUSY(x) (((x) & 0x1) << 17) | ||
| 278 | #define G_000E40_E2_BUSY(x) (((x) >> 17) & 0x1) | ||
| 279 | #define C_000E40_E2_BUSY 0xFFFDFFFF | ||
| 280 | #define S_000E40_RB2D_BUSY(x) (((x) & 0x1) << 18) | ||
| 281 | #define G_000E40_RB2D_BUSY(x) (((x) >> 18) & 0x1) | ||
| 282 | #define C_000E40_RB2D_BUSY 0xFFFBFFFF | ||
| 283 | #define S_000E40_RB3D_BUSY(x) (((x) & 0x1) << 19) | ||
| 284 | #define G_000E40_RB3D_BUSY(x) (((x) >> 19) & 0x1) | ||
| 285 | #define C_000E40_RB3D_BUSY 0xFFF7FFFF | ||
| 286 | #define S_000E40_VAP_BUSY(x) (((x) & 0x1) << 20) | ||
| 287 | #define G_000E40_VAP_BUSY(x) (((x) >> 20) & 0x1) | ||
| 288 | #define C_000E40_VAP_BUSY 0xFFEFFFFF | ||
| 289 | #define S_000E40_RE_BUSY(x) (((x) & 0x1) << 21) | ||
| 290 | #define G_000E40_RE_BUSY(x) (((x) >> 21) & 0x1) | ||
| 291 | #define C_000E40_RE_BUSY 0xFFDFFFFF | ||
| 292 | #define S_000E40_TAM_BUSY(x) (((x) & 0x1) << 22) | ||
| 293 | #define G_000E40_TAM_BUSY(x) (((x) >> 22) & 0x1) | ||
| 294 | #define C_000E40_TAM_BUSY 0xFFBFFFFF | ||
| 295 | #define S_000E40_TDM_BUSY(x) (((x) & 0x1) << 23) | ||
| 296 | #define G_000E40_TDM_BUSY(x) (((x) >> 23) & 0x1) | ||
| 297 | #define C_000E40_TDM_BUSY 0xFF7FFFFF | ||
| 298 | #define S_000E40_PB_BUSY(x) (((x) & 0x1) << 24) | ||
| 299 | #define G_000E40_PB_BUSY(x) (((x) >> 24) & 0x1) | ||
| 300 | #define C_000E40_PB_BUSY 0xFEFFFFFF | ||
| 301 | #define S_000E40_TIM_BUSY(x) (((x) & 0x1) << 25) | ||
| 302 | #define G_000E40_TIM_BUSY(x) (((x) >> 25) & 0x1) | ||
| 303 | #define C_000E40_TIM_BUSY 0xFDFFFFFF | ||
| 304 | #define S_000E40_GA_BUSY(x) (((x) & 0x1) << 26) | ||
| 305 | #define G_000E40_GA_BUSY(x) (((x) >> 26) & 0x1) | ||
| 306 | #define C_000E40_GA_BUSY 0xFBFFFFFF | ||
| 307 | #define S_000E40_CBA2D_BUSY(x) (((x) & 0x1) << 27) | ||
| 308 | #define G_000E40_CBA2D_BUSY(x) (((x) >> 27) & 0x1) | ||
| 309 | #define C_000E40_CBA2D_BUSY 0xF7FFFFFF | ||
| 310 | #define S_000E40_GUI_ACTIVE(x) (((x) & 0x1) << 31) | ||
| 311 | #define G_000E40_GUI_ACTIVE(x) (((x) >> 31) & 0x1) | ||
| 312 | #define C_000E40_GUI_ACTIVE 0x7FFFFFFF | ||
| 313 | #define R_0060A4_D1CRTC_STATUS_FRAME_COUNT 0x0060A4 | ||
| 314 | #define S_0060A4_D1CRTC_FRAME_COUNT(x) (((x) & 0xFFFFFF) << 0) | ||
| 315 | #define G_0060A4_D1CRTC_FRAME_COUNT(x) (((x) >> 0) & 0xFFFFFF) | ||
| 316 | #define C_0060A4_D1CRTC_FRAME_COUNT 0xFF000000 | ||
| 317 | #define R_006534_D1MODE_VBLANK_STATUS 0x006534 | ||
| 318 | #define S_006534_D1MODE_VBLANK_OCCURRED(x) (((x) & 0x1) << 0) | ||
| 319 | #define G_006534_D1MODE_VBLANK_OCCURRED(x) (((x) >> 0) & 0x1) | ||
| 320 | #define C_006534_D1MODE_VBLANK_OCCURRED 0xFFFFFFFE | ||
| 321 | #define S_006534_D1MODE_VBLANK_ACK(x) (((x) & 0x1) << 4) | ||
| 322 | #define G_006534_D1MODE_VBLANK_ACK(x) (((x) >> 4) & 0x1) | ||
| 323 | #define C_006534_D1MODE_VBLANK_ACK 0xFFFFFFEF | ||
| 324 | #define S_006534_D1MODE_VBLANK_STAT(x) (((x) & 0x1) << 12) | ||
| 325 | #define G_006534_D1MODE_VBLANK_STAT(x) (((x) >> 12) & 0x1) | ||
| 326 | #define C_006534_D1MODE_VBLANK_STAT 0xFFFFEFFF | ||
| 327 | #define S_006534_D1MODE_VBLANK_INTERRUPT(x) (((x) & 0x1) << 16) | ||
| 328 | #define G_006534_D1MODE_VBLANK_INTERRUPT(x) (((x) >> 16) & 0x1) | ||
| 329 | #define C_006534_D1MODE_VBLANK_INTERRUPT 0xFFFEFFFF | ||
| 330 | #define R_006540_DxMODE_INT_MASK 0x006540 | ||
| 331 | #define S_006540_D1MODE_VBLANK_INT_MASK(x) (((x) & 0x1) << 0) | ||
| 332 | #define G_006540_D1MODE_VBLANK_INT_MASK(x) (((x) >> 0) & 0x1) | ||
| 333 | #define C_006540_D1MODE_VBLANK_INT_MASK 0xFFFFFFFE | ||
| 334 | #define S_006540_D1MODE_VLINE_INT_MASK(x) (((x) & 0x1) << 4) | ||
| 335 | #define G_006540_D1MODE_VLINE_INT_MASK(x) (((x) >> 4) & 0x1) | ||
| 336 | #define C_006540_D1MODE_VLINE_INT_MASK 0xFFFFFFEF | ||
| 337 | #define S_006540_D2MODE_VBLANK_INT_MASK(x) (((x) & 0x1) << 8) | ||
| 338 | #define G_006540_D2MODE_VBLANK_INT_MASK(x) (((x) >> 8) & 0x1) | ||
| 339 | #define C_006540_D2MODE_VBLANK_INT_MASK 0xFFFFFEFF | ||
| 340 | #define S_006540_D2MODE_VLINE_INT_MASK(x) (((x) & 0x1) << 12) | ||
| 341 | #define G_006540_D2MODE_VLINE_INT_MASK(x) (((x) >> 12) & 0x1) | ||
| 342 | #define C_006540_D2MODE_VLINE_INT_MASK 0xFFFFEFFF | ||
| 343 | #define S_006540_D1MODE_VBLANK_CP_SEL(x) (((x) & 0x1) << 30) | ||
| 344 | #define G_006540_D1MODE_VBLANK_CP_SEL(x) (((x) >> 30) & 0x1) | ||
| 345 | #define C_006540_D1MODE_VBLANK_CP_SEL 0xBFFFFFFF | ||
| 346 | #define S_006540_D2MODE_VBLANK_CP_SEL(x) (((x) & 0x1) << 31) | ||
| 347 | #define G_006540_D2MODE_VBLANK_CP_SEL(x) (((x) >> 31) & 0x1) | ||
| 348 | #define C_006540_D2MODE_VBLANK_CP_SEL 0x7FFFFFFF | ||
| 349 | #define R_0068A4_D2CRTC_STATUS_FRAME_COUNT 0x0068A4 | ||
| 350 | #define S_0068A4_D2CRTC_FRAME_COUNT(x) (((x) & 0xFFFFFF) << 0) | ||
| 351 | #define G_0068A4_D2CRTC_FRAME_COUNT(x) (((x) >> 0) & 0xFFFFFF) | ||
| 352 | #define C_0068A4_D2CRTC_FRAME_COUNT 0xFF000000 | ||
| 353 | #define R_006D34_D2MODE_VBLANK_STATUS 0x006D34 | ||
| 354 | #define S_006D34_D2MODE_VBLANK_OCCURRED(x) (((x) & 0x1) << 0) | ||
| 355 | #define G_006D34_D2MODE_VBLANK_OCCURRED(x) (((x) >> 0) & 0x1) | ||
| 356 | #define C_006D34_D2MODE_VBLANK_OCCURRED 0xFFFFFFFE | ||
| 357 | #define S_006D34_D2MODE_VBLANK_ACK(x) (((x) & 0x1) << 4) | ||
| 358 | #define G_006D34_D2MODE_VBLANK_ACK(x) (((x) >> 4) & 0x1) | ||
| 359 | #define C_006D34_D2MODE_VBLANK_ACK 0xFFFFFFEF | ||
| 360 | #define S_006D34_D2MODE_VBLANK_STAT(x) (((x) & 0x1) << 12) | ||
| 361 | #define G_006D34_D2MODE_VBLANK_STAT(x) (((x) >> 12) & 0x1) | ||
| 362 | #define C_006D34_D2MODE_VBLANK_STAT 0xFFFFEFFF | ||
| 363 | #define S_006D34_D2MODE_VBLANK_INTERRUPT(x) (((x) & 0x1) << 16) | ||
| 364 | #define G_006D34_D2MODE_VBLANK_INTERRUPT(x) (((x) >> 16) & 0x1) | ||
| 365 | #define C_006D34_D2MODE_VBLANK_INTERRUPT 0xFFFEFFFF | ||
| 366 | #define R_007EDC_DISP_INTERRUPT_STATUS 0x007EDC | ||
| 367 | #define S_007EDC_LB_D1_VBLANK_INTERRUPT(x) (((x) & 0x1) << 4) | ||
| 368 | #define G_007EDC_LB_D1_VBLANK_INTERRUPT(x) (((x) >> 4) & 0x1) | ||
| 369 | #define C_007EDC_LB_D1_VBLANK_INTERRUPT 0xFFFFFFEF | ||
| 370 | #define S_007EDC_LB_D2_VBLANK_INTERRUPT(x) (((x) & 0x1) << 5) | ||
| 371 | #define G_007EDC_LB_D2_VBLANK_INTERRUPT(x) (((x) >> 5) & 0x1) | ||
| 372 | #define C_007EDC_LB_D2_VBLANK_INTERRUPT 0xFFFFFFDF | ||
| 373 | |||
| 374 | |||
| 375 | /* MC registers */ | ||
| 376 | #define R_000000_MC_STATUS 0x000000 | ||
| 377 | #define S_000000_MC_IDLE(x) (((x) & 0x1) << 0) | ||
| 378 | #define G_000000_MC_IDLE(x) (((x) >> 0) & 0x1) | ||
| 379 | #define C_000000_MC_IDLE 0xFFFFFFFE | ||
| 380 | #define R_000004_MC_FB_LOCATION 0x000004 | ||
| 381 | #define S_000004_MC_FB_START(x) (((x) & 0xFFFF) << 0) | ||
| 382 | #define G_000004_MC_FB_START(x) (((x) >> 0) & 0xFFFF) | ||
| 383 | #define C_000004_MC_FB_START 0xFFFF0000 | ||
| 384 | #define S_000004_MC_FB_TOP(x) (((x) & 0xFFFF) << 16) | ||
| 385 | #define G_000004_MC_FB_TOP(x) (((x) >> 16) & 0xFFFF) | ||
| 386 | #define C_000004_MC_FB_TOP 0x0000FFFF | ||
| 387 | #define R_000005_MC_AGP_LOCATION 0x000005 | ||
| 388 | #define S_000005_MC_AGP_START(x) (((x) & 0xFFFF) << 0) | ||
| 389 | #define G_000005_MC_AGP_START(x) (((x) >> 0) & 0xFFFF) | ||
| 390 | #define C_000005_MC_AGP_START 0xFFFF0000 | ||
| 391 | #define S_000005_MC_AGP_TOP(x) (((x) & 0xFFFF) << 16) | ||
| 392 | #define G_000005_MC_AGP_TOP(x) (((x) >> 16) & 0xFFFF) | ||
| 393 | #define C_000005_MC_AGP_TOP 0x0000FFFF | ||
| 394 | #define R_000006_AGP_BASE 0x000006 | ||
| 395 | #define S_000006_AGP_BASE_ADDR(x) (((x) & 0xFFFFFFFF) << 0) | ||
| 396 | #define G_000006_AGP_BASE_ADDR(x) (((x) >> 0) & 0xFFFFFFFF) | ||
| 397 | #define C_000006_AGP_BASE_ADDR 0x00000000 | ||
| 398 | #define R_000007_AGP_BASE_2 0x000007 | ||
| 399 | #define S_000007_AGP_BASE_ADDR_2(x) (((x) & 0xF) << 0) | ||
| 400 | #define G_000007_AGP_BASE_ADDR_2(x) (((x) >> 0) & 0xF) | ||
| 401 | #define C_000007_AGP_BASE_ADDR_2 0xFFFFFFF0 | ||
| 402 | #define R_000009_MC_CNTL1 0x000009 | ||
| 403 | #define S_000009_ENABLE_PAGE_TABLES(x) (((x) & 0x1) << 26) | ||
| 404 | #define G_000009_ENABLE_PAGE_TABLES(x) (((x) >> 26) & 0x1) | ||
| 405 | #define C_000009_ENABLE_PAGE_TABLES 0xFBFFFFFF | ||
| 406 | /* FIXME don't know the various field size need feedback from AMD */ | ||
| 407 | #define R_000100_MC_PT0_CNTL 0x000100 | ||
| 408 | #define S_000100_ENABLE_PT(x) (((x) & 0x1) << 0) | ||
| 409 | #define G_000100_ENABLE_PT(x) (((x) >> 0) & 0x1) | ||
| 410 | #define C_000100_ENABLE_PT 0xFFFFFFFE | ||
| 411 | #define S_000100_EFFECTIVE_L2_CACHE_SIZE(x) (((x) & 0x7) << 15) | ||
| 412 | #define G_000100_EFFECTIVE_L2_CACHE_SIZE(x) (((x) >> 15) & 0x7) | ||
| 413 | #define C_000100_EFFECTIVE_L2_CACHE_SIZE 0xFFFC7FFF | ||
| 414 | #define S_000100_EFFECTIVE_L2_QUEUE_SIZE(x) (((x) & 0x7) << 21) | ||
| 415 | #define G_000100_EFFECTIVE_L2_QUEUE_SIZE(x) (((x) >> 21) & 0x7) | ||
| 416 | #define C_000100_EFFECTIVE_L2_QUEUE_SIZE 0xFF1FFFFF | ||
| 417 | #define S_000100_INVALIDATE_ALL_L1_TLBS(x) (((x) & 0x1) << 28) | ||
| 418 | #define G_000100_INVALIDATE_ALL_L1_TLBS(x) (((x) >> 28) & 0x1) | ||
| 419 | #define C_000100_INVALIDATE_ALL_L1_TLBS 0xEFFFFFFF | ||
| 420 | #define S_000100_INVALIDATE_L2_CACHE(x) (((x) & 0x1) << 29) | ||
| 421 | #define G_000100_INVALIDATE_L2_CACHE(x) (((x) >> 29) & 0x1) | ||
| 422 | #define C_000100_INVALIDATE_L2_CACHE 0xDFFFFFFF | ||
| 423 | #define R_000102_MC_PT0_CONTEXT0_CNTL 0x000102 | ||
| 424 | #define S_000102_ENABLE_PAGE_TABLE(x) (((x) & 0x1) << 0) | ||
| 425 | #define G_000102_ENABLE_PAGE_TABLE(x) (((x) >> 0) & 0x1) | ||
| 426 | #define C_000102_ENABLE_PAGE_TABLE 0xFFFFFFFE | ||
| 427 | #define S_000102_PAGE_TABLE_DEPTH(x) (((x) & 0x3) << 1) | ||
| 428 | #define G_000102_PAGE_TABLE_DEPTH(x) (((x) >> 1) & 0x3) | ||
| 429 | #define C_000102_PAGE_TABLE_DEPTH 0xFFFFFFF9 | ||
| 430 | #define V_000102_PAGE_TABLE_FLAT 0 | ||
| 431 | /* R600 documentation suggest that this should be a number of pages */ | ||
| 432 | #define R_000112_MC_PT0_SYSTEM_APERTURE_LOW_ADDR 0x000112 | ||
| 433 | #define R_000114_MC_PT0_SYSTEM_APERTURE_HIGH_ADDR 0x000114 | ||
| 434 | #define R_00011C_MC_PT0_CONTEXT0_DEFAULT_READ_ADDR 0x00011C | ||
| 435 | #define R_00012C_MC_PT0_CONTEXT0_FLAT_BASE_ADDR 0x00012C | ||
| 436 | #define R_00013C_MC_PT0_CONTEXT0_FLAT_START_ADDR 0x00013C | ||
| 437 | #define R_00014C_MC_PT0_CONTEXT0_FLAT_END_ADDR 0x00014C | ||
| 438 | #define R_00016C_MC_PT0_CLIENT0_CNTL 0x00016C | ||
| 439 | #define S_00016C_ENABLE_TRANSLATION_MODE_OVERRIDE(x) (((x) & 0x1) << 0) | ||
| 440 | #define G_00016C_ENABLE_TRANSLATION_MODE_OVERRIDE(x) (((x) >> 0) & 0x1) | ||
| 441 | #define C_00016C_ENABLE_TRANSLATION_MODE_OVERRIDE 0xFFFFFFFE | ||
| 442 | #define S_00016C_TRANSLATION_MODE_OVERRIDE(x) (((x) & 0x1) << 1) | ||
| 443 | #define G_00016C_TRANSLATION_MODE_OVERRIDE(x) (((x) >> 1) & 0x1) | ||
| 444 | #define C_00016C_TRANSLATION_MODE_OVERRIDE 0xFFFFFFFD | ||
| 445 | #define S_00016C_SYSTEM_ACCESS_MODE_MASK(x) (((x) & 0x3) << 8) | ||
| 446 | #define G_00016C_SYSTEM_ACCESS_MODE_MASK(x) (((x) >> 8) & 0x3) | ||
| 447 | #define C_00016C_SYSTEM_ACCESS_MODE_MASK 0xFFFFFCFF | ||
| 448 | #define V_00016C_SYSTEM_ACCESS_MODE_PA_ONLY 0 | ||
| 449 | #define V_00016C_SYSTEM_ACCESS_MODE_USE_SYS_MAP 1 | ||
| 450 | #define V_00016C_SYSTEM_ACCESS_MODE_IN_SYS 2 | ||
| 451 | #define V_00016C_SYSTEM_ACCESS_MODE_NOT_IN_SYS 3 | ||
| 452 | #define S_00016C_SYSTEM_APERTURE_UNMAPPED_ACCESS(x) (((x) & 0x1) << 10) | ||
| 453 | #define G_00016C_SYSTEM_APERTURE_UNMAPPED_ACCESS(x) (((x) >> 10) & 0x1) | ||
| 454 | #define C_00016C_SYSTEM_APERTURE_UNMAPPED_ACCESS 0xFFFFFBFF | ||
| 455 | #define V_00016C_SYSTEM_APERTURE_UNMAPPED_PASSTHROUGH 0 | ||
| 456 | #define V_00016C_SYSTEM_APERTURE_UNMAPPED_DEFAULT_PAGE 1 | ||
| 457 | #define S_00016C_EFFECTIVE_L1_CACHE_SIZE(x) (((x) & 0x7) << 11) | ||
| 458 | #define G_00016C_EFFECTIVE_L1_CACHE_SIZE(x) (((x) >> 11) & 0x7) | ||
| 459 | #define C_00016C_EFFECTIVE_L1_CACHE_SIZE 0xFFFFC7FF | ||
| 460 | #define S_00016C_ENABLE_FRAGMENT_PROCESSING(x) (((x) & 0x1) << 14) | ||
| 461 | #define G_00016C_ENABLE_FRAGMENT_PROCESSING(x) (((x) >> 14) & 0x1) | ||
| 462 | #define C_00016C_ENABLE_FRAGMENT_PROCESSING 0xFFFFBFFF | ||
| 463 | #define S_00016C_EFFECTIVE_L1_QUEUE_SIZE(x) (((x) & 0x7) << 15) | ||
| 464 | #define G_00016C_EFFECTIVE_L1_QUEUE_SIZE(x) (((x) >> 15) & 0x7) | ||
| 465 | #define C_00016C_EFFECTIVE_L1_QUEUE_SIZE 0xFFFC7FFF | ||
| 466 | #define S_00016C_INVALIDATE_L1_TLB(x) (((x) & 0x1) << 20) | ||
| 467 | #define G_00016C_INVALIDATE_L1_TLB(x) (((x) >> 20) & 0x1) | ||
| 468 | #define C_00016C_INVALIDATE_L1_TLB 0xFFEFFFFF | ||
| 469 | |||
| 470 | #endif | ||
diff --git a/drivers/gpu/drm/radeon/rs690.c b/drivers/gpu/drm/radeon/rs690.c index 7a0098ddf977..025e3225346c 100644 --- a/drivers/gpu/drm/radeon/rs690.c +++ b/drivers/gpu/drm/radeon/rs690.c | |||
| @@ -26,105 +26,29 @@ | |||
| 26 | * Jerome Glisse | 26 | * Jerome Glisse |
| 27 | */ | 27 | */ |
| 28 | #include "drmP.h" | 28 | #include "drmP.h" |
| 29 | #include "radeon_reg.h" | ||
| 30 | #include "radeon.h" | 29 | #include "radeon.h" |
| 31 | #include "rs690r.h" | ||
| 32 | #include "atom.h" | 30 | #include "atom.h" |
| 33 | #include "atom-bits.h" | 31 | #include "rs690d.h" |
| 34 | |||
| 35 | /* rs690,rs740 depends on : */ | ||
| 36 | void r100_hdp_reset(struct radeon_device *rdev); | ||
| 37 | int r300_mc_wait_for_idle(struct radeon_device *rdev); | ||
| 38 | void r420_pipes_init(struct radeon_device *rdev); | ||
| 39 | void rs400_gart_disable(struct radeon_device *rdev); | ||
| 40 | int rs400_gart_enable(struct radeon_device *rdev); | ||
| 41 | void rs400_gart_adjust_size(struct radeon_device *rdev); | ||
| 42 | void rs600_mc_disable_clients(struct radeon_device *rdev); | ||
| 43 | |||
| 44 | /* This files gather functions specifics to : | ||
| 45 | * rs690,rs740 | ||
| 46 | * | ||
| 47 | * Some of these functions might be used by newer ASICs. | ||
| 48 | */ | ||
| 49 | void rs690_gpu_init(struct radeon_device *rdev); | ||
| 50 | int rs690_mc_wait_for_idle(struct radeon_device *rdev); | ||
| 51 | |||
| 52 | |||
| 53 | /* | ||
| 54 | * MC functions. | ||
| 55 | */ | ||
| 56 | int rs690_mc_init(struct radeon_device *rdev) | ||
| 57 | { | ||
| 58 | uint32_t tmp; | ||
| 59 | int r; | ||
| 60 | |||
| 61 | if (r100_debugfs_rbbm_init(rdev)) { | ||
| 62 | DRM_ERROR("Failed to register debugfs file for RBBM !\n"); | ||
| 63 | } | ||
| 64 | |||
| 65 | rs690_gpu_init(rdev); | ||
| 66 | rs400_gart_disable(rdev); | ||
| 67 | |||
| 68 | /* Setup GPU memory space */ | ||
| 69 | rdev->mc.gtt_location = rdev->mc.mc_vram_size; | ||
| 70 | rdev->mc.gtt_location += (rdev->mc.gtt_size - 1); | ||
| 71 | rdev->mc.gtt_location &= ~(rdev->mc.gtt_size - 1); | ||
| 72 | rdev->mc.vram_location = 0xFFFFFFFFUL; | ||
| 73 | r = radeon_mc_setup(rdev); | ||
| 74 | if (r) { | ||
| 75 | return r; | ||
| 76 | } | ||
| 77 | |||
| 78 | /* Program GPU memory space */ | ||
| 79 | rs600_mc_disable_clients(rdev); | ||
| 80 | if (rs690_mc_wait_for_idle(rdev)) { | ||
| 81 | printk(KERN_WARNING "Failed to wait MC idle while " | ||
| 82 | "programming pipes. Bad things might happen.\n"); | ||
| 83 | } | ||
| 84 | tmp = rdev->mc.vram_location + rdev->mc.mc_vram_size - 1; | ||
| 85 | tmp = REG_SET(RS690_MC_FB_TOP, tmp >> 16); | ||
| 86 | tmp |= REG_SET(RS690_MC_FB_START, rdev->mc.vram_location >> 16); | ||
| 87 | WREG32_MC(RS690_MCCFG_FB_LOCATION, tmp); | ||
| 88 | /* FIXME: Does this reg exist on RS480,RS740 ? */ | ||
| 89 | WREG32(0x310, rdev->mc.vram_location); | ||
| 90 | WREG32(RS690_HDP_FB_LOCATION, rdev->mc.vram_location >> 16); | ||
| 91 | return 0; | ||
| 92 | } | ||
| 93 | |||
| 94 | void rs690_mc_fini(struct radeon_device *rdev) | ||
| 95 | { | ||
| 96 | } | ||
| 97 | |||
| 98 | 32 | ||
| 99 | /* | 33 | static int rs690_mc_wait_for_idle(struct radeon_device *rdev) |
| 100 | * Global GPU functions | ||
| 101 | */ | ||
| 102 | int rs690_mc_wait_for_idle(struct radeon_device *rdev) | ||
| 103 | { | 34 | { |
| 104 | unsigned i; | 35 | unsigned i; |
| 105 | uint32_t tmp; | 36 | uint32_t tmp; |
| 106 | 37 | ||
| 107 | for (i = 0; i < rdev->usec_timeout; i++) { | 38 | for (i = 0; i < rdev->usec_timeout; i++) { |
| 108 | /* read MC_STATUS */ | 39 | /* read MC_STATUS */ |
| 109 | tmp = RREG32_MC(RS690_MC_STATUS); | 40 | tmp = RREG32_MC(R_000090_MC_SYSTEM_STATUS); |
| 110 | if (tmp & RS690_MC_STATUS_IDLE) { | 41 | if (G_000090_MC_SYSTEM_IDLE(tmp)) |
| 111 | return 0; | 42 | return 0; |
| 112 | } | 43 | udelay(1); |
| 113 | DRM_UDELAY(1); | ||
| 114 | } | 44 | } |
| 115 | return -1; | 45 | return -1; |
| 116 | } | 46 | } |
| 117 | 47 | ||
| 118 | void rs690_errata(struct radeon_device *rdev) | 48 | static void rs690_gpu_init(struct radeon_device *rdev) |
| 119 | { | ||
| 120 | rdev->pll_errata = 0; | ||
| 121 | } | ||
| 122 | |||
| 123 | void rs690_gpu_init(struct radeon_device *rdev) | ||
| 124 | { | 49 | { |
| 125 | /* FIXME: HDP same place on rs690 ? */ | 50 | /* FIXME: HDP same place on rs690 ? */ |
| 126 | r100_hdp_reset(rdev); | 51 | r100_hdp_reset(rdev); |
| 127 | rv515_vga_render_disable(rdev); | ||
| 128 | /* FIXME: is this correct ? */ | 52 | /* FIXME: is this correct ? */ |
| 129 | r420_pipes_init(rdev); | 53 | r420_pipes_init(rdev); |
| 130 | if (rs690_mc_wait_for_idle(rdev)) { | 54 | if (rs690_mc_wait_for_idle(rdev)) { |
| @@ -133,10 +57,6 @@ void rs690_gpu_init(struct radeon_device *rdev) | |||
| 133 | } | 57 | } |
| 134 | } | 58 | } |
| 135 | 59 | ||
| 136 | |||
| 137 | /* | ||
| 138 | * VRAM info. | ||
| 139 | */ | ||
| 140 | void rs690_pm_info(struct radeon_device *rdev) | 60 | void rs690_pm_info(struct radeon_device *rdev) |
| 141 | { | 61 | { |
| 142 | int index = GetIndexIntoMasterTable(DATA, IntegratedSystemInfo); | 62 | int index = GetIndexIntoMasterTable(DATA, IntegratedSystemInfo); |
| @@ -250,39 +170,39 @@ void rs690_line_buffer_adjust(struct radeon_device *rdev, | |||
| 250 | /* | 170 | /* |
| 251 | * Line Buffer Setup | 171 | * Line Buffer Setup |
| 252 | * There is a single line buffer shared by both display controllers. | 172 | * There is a single line buffer shared by both display controllers. |
| 253 | * DC_LB_MEMORY_SPLIT controls how that line buffer is shared between | 173 | * R_006520_DC_LB_MEMORY_SPLIT controls how that line buffer is shared between |
| 254 | * the display controllers. The paritioning can either be done | 174 | * the display controllers. The paritioning can either be done |
| 255 | * manually or via one of four preset allocations specified in bits 1:0: | 175 | * manually or via one of four preset allocations specified in bits 1:0: |
| 256 | * 0 - line buffer is divided in half and shared between crtc | 176 | * 0 - line buffer is divided in half and shared between crtc |
| 257 | * 1 - D1 gets 3/4 of the line buffer, D2 gets 1/4 | 177 | * 1 - D1 gets 3/4 of the line buffer, D2 gets 1/4 |
| 258 | * 2 - D1 gets the whole buffer | 178 | * 2 - D1 gets the whole buffer |
| 259 | * 3 - D1 gets 1/4 of the line buffer, D2 gets 3/4 | 179 | * 3 - D1 gets 1/4 of the line buffer, D2 gets 3/4 |
| 260 | * Setting bit 2 of DC_LB_MEMORY_SPLIT controls switches to manual | 180 | * Setting bit 2 of R_006520_DC_LB_MEMORY_SPLIT controls switches to manual |
| 261 | * allocation mode. In manual allocation mode, D1 always starts at 0, | 181 | * allocation mode. In manual allocation mode, D1 always starts at 0, |
| 262 | * D1 end/2 is specified in bits 14:4; D2 allocation follows D1. | 182 | * D1 end/2 is specified in bits 14:4; D2 allocation follows D1. |
| 263 | */ | 183 | */ |
| 264 | tmp = RREG32(DC_LB_MEMORY_SPLIT) & ~DC_LB_MEMORY_SPLIT_MASK; | 184 | tmp = RREG32(R_006520_DC_LB_MEMORY_SPLIT) & C_006520_DC_LB_MEMORY_SPLIT; |
| 265 | tmp &= ~DC_LB_MEMORY_SPLIT_SHIFT_MODE; | 185 | tmp &= ~C_006520_DC_LB_MEMORY_SPLIT_MODE; |
| 266 | /* auto */ | 186 | /* auto */ |
| 267 | if (mode1 && mode2) { | 187 | if (mode1 && mode2) { |
| 268 | if (mode1->hdisplay > mode2->hdisplay) { | 188 | if (mode1->hdisplay > mode2->hdisplay) { |
| 269 | if (mode1->hdisplay > 2560) | 189 | if (mode1->hdisplay > 2560) |
| 270 | tmp |= DC_LB_MEMORY_SPLIT_D1_3Q_D2_1Q; | 190 | tmp |= V_006520_DC_LB_MEMORY_SPLIT_D1_3Q_D2_1Q; |
| 271 | else | 191 | else |
| 272 | tmp |= DC_LB_MEMORY_SPLIT_D1HALF_D2HALF; | 192 | tmp |= V_006520_DC_LB_MEMORY_SPLIT_D1HALF_D2HALF; |
| 273 | } else if (mode2->hdisplay > mode1->hdisplay) { | 193 | } else if (mode2->hdisplay > mode1->hdisplay) { |
| 274 | if (mode2->hdisplay > 2560) | 194 | if (mode2->hdisplay > 2560) |
| 275 | tmp |= DC_LB_MEMORY_SPLIT_D1_1Q_D2_3Q; | 195 | tmp |= V_006520_DC_LB_MEMORY_SPLIT_D1_1Q_D2_3Q; |
| 276 | else | 196 | else |
| 277 | tmp |= DC_LB_MEMORY_SPLIT_D1HALF_D2HALF; | 197 | tmp |= V_006520_DC_LB_MEMORY_SPLIT_D1HALF_D2HALF; |
| 278 | } else | 198 | } else |
| 279 | tmp |= AVIVO_DC_LB_MEMORY_SPLIT_D1HALF_D2HALF; | 199 | tmp |= V_006520_DC_LB_MEMORY_SPLIT_D1HALF_D2HALF; |
| 280 | } else if (mode1) { | 200 | } else if (mode1) { |
| 281 | tmp |= DC_LB_MEMORY_SPLIT_D1_ONLY; | 201 | tmp |= V_006520_DC_LB_MEMORY_SPLIT_D1_ONLY; |
| 282 | } else if (mode2) { | 202 | } else if (mode2) { |
| 283 | tmp |= DC_LB_MEMORY_SPLIT_D1_1Q_D2_3Q; | 203 | tmp |= V_006520_DC_LB_MEMORY_SPLIT_D1_1Q_D2_3Q; |
| 284 | } | 204 | } |
| 285 | WREG32(DC_LB_MEMORY_SPLIT, tmp); | 205 | WREG32(R_006520_DC_LB_MEMORY_SPLIT, tmp); |
| 286 | } | 206 | } |
| 287 | 207 | ||
| 288 | struct rs690_watermark { | 208 | struct rs690_watermark { |
| @@ -487,28 +407,28 @@ void rs690_bandwidth_update(struct radeon_device *rdev) | |||
| 487 | * option. | 407 | * option. |
| 488 | */ | 408 | */ |
| 489 | if (rdev->disp_priority == 2) { | 409 | if (rdev->disp_priority == 2) { |
| 490 | tmp = RREG32_MC(MC_INIT_MISC_LAT_TIMER); | 410 | tmp = RREG32_MC(R_000104_MC_INIT_MISC_LAT_TIMER); |
| 491 | tmp &= ~MC_DISP1R_INIT_LAT_MASK; | 411 | tmp &= C_000104_MC_DISP0R_INIT_LAT; |
| 492 | tmp &= ~MC_DISP0R_INIT_LAT_MASK; | 412 | tmp &= C_000104_MC_DISP1R_INIT_LAT; |
| 493 | if (mode1) | ||
| 494 | tmp |= (1 << MC_DISP1R_INIT_LAT_SHIFT); | ||
| 495 | if (mode0) | 413 | if (mode0) |
| 496 | tmp |= (1 << MC_DISP0R_INIT_LAT_SHIFT); | 414 | tmp |= S_000104_MC_DISP0R_INIT_LAT(1); |
| 497 | WREG32_MC(MC_INIT_MISC_LAT_TIMER, tmp); | 415 | if (mode1) |
| 416 | tmp |= S_000104_MC_DISP1R_INIT_LAT(1); | ||
| 417 | WREG32_MC(R_000104_MC_INIT_MISC_LAT_TIMER, tmp); | ||
| 498 | } | 418 | } |
| 499 | rs690_line_buffer_adjust(rdev, mode0, mode1); | 419 | rs690_line_buffer_adjust(rdev, mode0, mode1); |
| 500 | 420 | ||
| 501 | if ((rdev->family == CHIP_RS690) || (rdev->family == CHIP_RS740)) | 421 | if ((rdev->family == CHIP_RS690) || (rdev->family == CHIP_RS740)) |
| 502 | WREG32(DCP_CONTROL, 0); | 422 | WREG32(R_006C9C_DCP_CONTROL, 0); |
| 503 | if ((rdev->family == CHIP_RS780) || (rdev->family == CHIP_RS880)) | 423 | if ((rdev->family == CHIP_RS780) || (rdev->family == CHIP_RS880)) |
| 504 | WREG32(DCP_CONTROL, 2); | 424 | WREG32(R_006C9C_DCP_CONTROL, 2); |
| 505 | 425 | ||
| 506 | rs690_crtc_bandwidth_compute(rdev, rdev->mode_info.crtcs[0], &wm0); | 426 | rs690_crtc_bandwidth_compute(rdev, rdev->mode_info.crtcs[0], &wm0); |
| 507 | rs690_crtc_bandwidth_compute(rdev, rdev->mode_info.crtcs[1], &wm1); | 427 | rs690_crtc_bandwidth_compute(rdev, rdev->mode_info.crtcs[1], &wm1); |
| 508 | 428 | ||
| 509 | tmp = (wm0.lb_request_fifo_depth - 1); | 429 | tmp = (wm0.lb_request_fifo_depth - 1); |
| 510 | tmp |= (wm1.lb_request_fifo_depth - 1) << 16; | 430 | tmp |= (wm1.lb_request_fifo_depth - 1) << 16; |
| 511 | WREG32(LB_MAX_REQ_OUTSTANDING, tmp); | 431 | WREG32(R_006D58_LB_MAX_REQ_OUTSTANDING, tmp); |
| 512 | 432 | ||
| 513 | if (mode0 && mode1) { | 433 | if (mode0 && mode1) { |
| 514 | if (rfixed_trunc(wm0.dbpp) > 64) | 434 | if (rfixed_trunc(wm0.dbpp) > 64) |
| @@ -561,10 +481,10 @@ void rs690_bandwidth_update(struct radeon_device *rdev) | |||
| 561 | priority_mark12.full = 0; | 481 | priority_mark12.full = 0; |
| 562 | if (wm1.priority_mark_max.full > priority_mark12.full) | 482 | if (wm1.priority_mark_max.full > priority_mark12.full) |
| 563 | priority_mark12.full = wm1.priority_mark_max.full; | 483 | priority_mark12.full = wm1.priority_mark_max.full; |
| 564 | WREG32(D1MODE_PRIORITY_A_CNT, rfixed_trunc(priority_mark02)); | 484 | WREG32(R_006548_D1MODE_PRIORITY_A_CNT, rfixed_trunc(priority_mark02)); |
| 565 | WREG32(D1MODE_PRIORITY_B_CNT, rfixed_trunc(priority_mark02)); | 485 | WREG32(R_00654C_D1MODE_PRIORITY_B_CNT, rfixed_trunc(priority_mark02)); |
| 566 | WREG32(D2MODE_PRIORITY_A_CNT, rfixed_trunc(priority_mark12)); | 486 | WREG32(R_006D48_D2MODE_PRIORITY_A_CNT, rfixed_trunc(priority_mark12)); |
| 567 | WREG32(D2MODE_PRIORITY_B_CNT, rfixed_trunc(priority_mark12)); | 487 | WREG32(R_006D4C_D2MODE_PRIORITY_B_CNT, rfixed_trunc(priority_mark12)); |
| 568 | } else if (mode0) { | 488 | } else if (mode0) { |
| 569 | if (rfixed_trunc(wm0.dbpp) > 64) | 489 | if (rfixed_trunc(wm0.dbpp) > 64) |
| 570 | a.full = rfixed_mul(wm0.dbpp, wm0.num_line_pair); | 490 | a.full = rfixed_mul(wm0.dbpp, wm0.num_line_pair); |
| @@ -591,10 +511,12 @@ void rs690_bandwidth_update(struct radeon_device *rdev) | |||
| 591 | priority_mark02.full = 0; | 511 | priority_mark02.full = 0; |
| 592 | if (wm0.priority_mark_max.full > priority_mark02.full) | 512 | if (wm0.priority_mark_max.full > priority_mark02.full) |
| 593 | priority_mark02.full = wm0.priority_mark_max.full; | 513 | priority_mark02.full = wm0.priority_mark_max.full; |
| 594 | WREG32(D1MODE_PRIORITY_A_CNT, rfixed_trunc(priority_mark02)); | 514 | WREG32(R_006548_D1MODE_PRIORITY_A_CNT, rfixed_trunc(priority_mark02)); |
| 595 | WREG32(D1MODE_PRIORITY_B_CNT, rfixed_trunc(priority_mark02)); | 515 | WREG32(R_00654C_D1MODE_PRIORITY_B_CNT, rfixed_trunc(priority_mark02)); |
| 596 | WREG32(D2MODE_PRIORITY_A_CNT, MODE_PRIORITY_OFF); | 516 | WREG32(R_006D48_D2MODE_PRIORITY_A_CNT, |
| 597 | WREG32(D2MODE_PRIORITY_B_CNT, MODE_PRIORITY_OFF); | 517 | S_006D48_D2MODE_PRIORITY_A_OFF(1)); |
| 518 | WREG32(R_006D4C_D2MODE_PRIORITY_B_CNT, | ||
| 519 | S_006D4C_D2MODE_PRIORITY_B_OFF(1)); | ||
| 598 | } else { | 520 | } else { |
| 599 | if (rfixed_trunc(wm1.dbpp) > 64) | 521 | if (rfixed_trunc(wm1.dbpp) > 64) |
| 600 | a.full = rfixed_mul(wm1.dbpp, wm1.num_line_pair); | 522 | a.full = rfixed_mul(wm1.dbpp, wm1.num_line_pair); |
| @@ -621,30 +543,203 @@ void rs690_bandwidth_update(struct radeon_device *rdev) | |||
| 621 | priority_mark12.full = 0; | 543 | priority_mark12.full = 0; |
| 622 | if (wm1.priority_mark_max.full > priority_mark12.full) | 544 | if (wm1.priority_mark_max.full > priority_mark12.full) |
| 623 | priority_mark12.full = wm1.priority_mark_max.full; | 545 | priority_mark12.full = wm1.priority_mark_max.full; |
| 624 | WREG32(D1MODE_PRIORITY_A_CNT, MODE_PRIORITY_OFF); | 546 | WREG32(R_006548_D1MODE_PRIORITY_A_CNT, |
| 625 | WREG32(D1MODE_PRIORITY_B_CNT, MODE_PRIORITY_OFF); | 547 | S_006548_D1MODE_PRIORITY_A_OFF(1)); |
| 626 | WREG32(D2MODE_PRIORITY_A_CNT, rfixed_trunc(priority_mark12)); | 548 | WREG32(R_00654C_D1MODE_PRIORITY_B_CNT, |
| 627 | WREG32(D2MODE_PRIORITY_B_CNT, rfixed_trunc(priority_mark12)); | 549 | S_00654C_D1MODE_PRIORITY_B_OFF(1)); |
| 550 | WREG32(R_006D48_D2MODE_PRIORITY_A_CNT, rfixed_trunc(priority_mark12)); | ||
| 551 | WREG32(R_006D4C_D2MODE_PRIORITY_B_CNT, rfixed_trunc(priority_mark12)); | ||
| 628 | } | 552 | } |
| 629 | } | 553 | } |
| 630 | 554 | ||
| 631 | /* | ||
| 632 | * Indirect registers accessor | ||
| 633 | */ | ||
| 634 | uint32_t rs690_mc_rreg(struct radeon_device *rdev, uint32_t reg) | 555 | uint32_t rs690_mc_rreg(struct radeon_device *rdev, uint32_t reg) |
| 635 | { | 556 | { |
| 636 | uint32_t r; | 557 | uint32_t r; |
| 637 | 558 | ||
| 638 | WREG32(RS690_MC_INDEX, (reg & RS690_MC_INDEX_MASK)); | 559 | WREG32(R_000078_MC_INDEX, S_000078_MC_IND_ADDR(reg)); |
| 639 | r = RREG32(RS690_MC_DATA); | 560 | r = RREG32(R_00007C_MC_DATA); |
| 640 | WREG32(RS690_MC_INDEX, RS690_MC_INDEX_MASK); | 561 | WREG32(R_000078_MC_INDEX, ~C_000078_MC_IND_ADDR); |
| 641 | return r; | 562 | return r; |
| 642 | } | 563 | } |
| 643 | 564 | ||
| 644 | void rs690_mc_wreg(struct radeon_device *rdev, uint32_t reg, uint32_t v) | 565 | void rs690_mc_wreg(struct radeon_device *rdev, uint32_t reg, uint32_t v) |
| 645 | { | 566 | { |
| 646 | WREG32(RS690_MC_INDEX, | 567 | WREG32(R_000078_MC_INDEX, S_000078_MC_IND_ADDR(reg) | |
| 647 | RS690_MC_INDEX_WR_EN | ((reg) & RS690_MC_INDEX_MASK)); | 568 | S_000078_MC_IND_WR_EN(1)); |
| 648 | WREG32(RS690_MC_DATA, v); | 569 | WREG32(R_00007C_MC_DATA, v); |
| 649 | WREG32(RS690_MC_INDEX, RS690_MC_INDEX_WR_ACK); | 570 | WREG32(R_000078_MC_INDEX, 0x7F); |
| 571 | } | ||
| 572 | |||
| 573 | void rs690_mc_program(struct radeon_device *rdev) | ||
| 574 | { | ||
| 575 | struct rv515_mc_save save; | ||
| 576 | |||
| 577 | /* Stops all mc clients */ | ||
| 578 | rv515_mc_stop(rdev, &save); | ||
| 579 | |||
| 580 | /* Wait for mc idle */ | ||
| 581 | if (rs690_mc_wait_for_idle(rdev)) | ||
| 582 | dev_warn(rdev->dev, "Wait MC idle timeout before updating MC.\n"); | ||
| 583 | /* Program MC, should be a 32bits limited address space */ | ||
| 584 | WREG32_MC(R_000100_MCCFG_FB_LOCATION, | ||
| 585 | S_000100_MC_FB_START(rdev->mc.vram_start >> 16) | | ||
| 586 | S_000100_MC_FB_TOP(rdev->mc.vram_end >> 16)); | ||
| 587 | WREG32(R_000134_HDP_FB_LOCATION, | ||
| 588 | S_000134_HDP_FB_START(rdev->mc.vram_start >> 16)); | ||
| 589 | |||
| 590 | rv515_mc_resume(rdev, &save); | ||
| 591 | } | ||
| 592 | |||
| 593 | static int rs690_startup(struct radeon_device *rdev) | ||
| 594 | { | ||
| 595 | int r; | ||
| 596 | |||
| 597 | rs690_mc_program(rdev); | ||
| 598 | /* Resume clock */ | ||
| 599 | rv515_clock_startup(rdev); | ||
| 600 | /* Initialize GPU configuration (# pipes, ...) */ | ||
| 601 | rs690_gpu_init(rdev); | ||
| 602 | /* Initialize GART (initialize after TTM so we can allocate | ||
| 603 | * memory through TTM but finalize after TTM) */ | ||
| 604 | r = rs400_gart_enable(rdev); | ||
| 605 | if (r) | ||
| 606 | return r; | ||
| 607 | /* Enable IRQ */ | ||
| 608 | rdev->irq.sw_int = true; | ||
| 609 | rs600_irq_set(rdev); | ||
| 610 | /* 1M ring buffer */ | ||
| 611 | r = r100_cp_init(rdev, 1024 * 1024); | ||
| 612 | if (r) { | ||
| 613 | dev_err(rdev->dev, "failled initializing CP (%d).\n", r); | ||
| 614 | return r; | ||
| 615 | } | ||
| 616 | r = r100_wb_init(rdev); | ||
| 617 | if (r) | ||
| 618 | dev_err(rdev->dev, "failled initializing WB (%d).\n", r); | ||
| 619 | r = r100_ib_init(rdev); | ||
| 620 | if (r) { | ||
| 621 | dev_err(rdev->dev, "failled initializing IB (%d).\n", r); | ||
| 622 | return r; | ||
| 623 | } | ||
| 624 | return 0; | ||
| 625 | } | ||
| 626 | |||
| 627 | int rs690_resume(struct radeon_device *rdev) | ||
| 628 | { | ||
| 629 | /* Make sur GART are not working */ | ||
| 630 | rs400_gart_disable(rdev); | ||
| 631 | /* Resume clock before doing reset */ | ||
| 632 | rv515_clock_startup(rdev); | ||
| 633 | /* Reset gpu before posting otherwise ATOM will enter infinite loop */ | ||
| 634 | if (radeon_gpu_reset(rdev)) { | ||
| 635 | dev_warn(rdev->dev, "GPU reset failed ! (0xE40=0x%08X, 0x7C0=0x%08X)\n", | ||
| 636 | RREG32(R_000E40_RBBM_STATUS), | ||
| 637 | RREG32(R_0007C0_CP_STAT)); | ||
| 638 | } | ||
| 639 | /* post */ | ||
| 640 | atom_asic_init(rdev->mode_info.atom_context); | ||
| 641 | /* Resume clock after posting */ | ||
| 642 | rv515_clock_startup(rdev); | ||
| 643 | return rs690_startup(rdev); | ||
| 644 | } | ||
| 645 | |||
| 646 | int rs690_suspend(struct radeon_device *rdev) | ||
| 647 | { | ||
| 648 | r100_cp_disable(rdev); | ||
| 649 | r100_wb_disable(rdev); | ||
| 650 | rs600_irq_disable(rdev); | ||
| 651 | rs400_gart_disable(rdev); | ||
| 652 | return 0; | ||
| 653 | } | ||
| 654 | |||
| 655 | void rs690_fini(struct radeon_device *rdev) | ||
| 656 | { | ||
| 657 | rs690_suspend(rdev); | ||
| 658 | r100_cp_fini(rdev); | ||
| 659 | r100_wb_fini(rdev); | ||
| 660 | r100_ib_fini(rdev); | ||
| 661 | radeon_gem_fini(rdev); | ||
| 662 | rs400_gart_fini(rdev); | ||
| 663 | radeon_irq_kms_fini(rdev); | ||
| 664 | radeon_fence_driver_fini(rdev); | ||
| 665 | radeon_object_fini(rdev); | ||
| 666 | radeon_atombios_fini(rdev); | ||
| 667 | kfree(rdev->bios); | ||
| 668 | rdev->bios = NULL; | ||
| 669 | } | ||
| 670 | |||
| 671 | int rs690_init(struct radeon_device *rdev) | ||
| 672 | { | ||
| 673 | int r; | ||
| 674 | |||
| 675 | /* Disable VGA */ | ||
| 676 | rv515_vga_render_disable(rdev); | ||
| 677 | /* Initialize scratch registers */ | ||
| 678 | radeon_scratch_init(rdev); | ||
| 679 | /* Initialize surface registers */ | ||
| 680 | radeon_surface_init(rdev); | ||
| 681 | /* TODO: disable VGA need to use VGA request */ | ||
| 682 | /* BIOS*/ | ||
| 683 | if (!radeon_get_bios(rdev)) { | ||
| 684 | if (ASIC_IS_AVIVO(rdev)) | ||
| 685 | return -EINVAL; | ||
| 686 | } | ||
| 687 | if (rdev->is_atom_bios) { | ||
| 688 | r = radeon_atombios_init(rdev); | ||
| 689 | if (r) | ||
| 690 | return r; | ||
| 691 | } else { | ||
| 692 | dev_err(rdev->dev, "Expecting atombios for RV515 GPU\n"); | ||
| 693 | return -EINVAL; | ||
| 694 | } | ||
| 695 | /* Reset gpu before posting otherwise ATOM will enter infinite loop */ | ||
| 696 | if (radeon_gpu_reset(rdev)) { | ||
| 697 | dev_warn(rdev->dev, | ||
| 698 | "GPU reset failed ! (0xE40=0x%08X, 0x7C0=0x%08X)\n", | ||
| 699 | RREG32(R_000E40_RBBM_STATUS), | ||
| 700 | RREG32(R_0007C0_CP_STAT)); | ||
| 701 | } | ||
| 702 | /* check if cards are posted or not */ | ||
| 703 | if (!radeon_card_posted(rdev) && rdev->bios) { | ||
| 704 | DRM_INFO("GPU not posted. posting now...\n"); | ||
| 705 | atom_asic_init(rdev->mode_info.atom_context); | ||
| 706 | } | ||
| 707 | /* Initialize clocks */ | ||
| 708 | radeon_get_clock_info(rdev->ddev); | ||
| 709 | /* Get vram informations */ | ||
| 710 | rs690_vram_info(rdev); | ||
| 711 | /* Initialize memory controller (also test AGP) */ | ||
| 712 | r = r420_mc_init(rdev); | ||
| 713 | if (r) | ||
| 714 | return r; | ||
| 715 | rv515_debugfs(rdev); | ||
| 716 | /* Fence driver */ | ||
| 717 | r = radeon_fence_driver_init(rdev); | ||
| 718 | if (r) | ||
| 719 | return r; | ||
| 720 | r = radeon_irq_kms_init(rdev); | ||
| 721 | if (r) | ||
| 722 | return r; | ||
| 723 | /* Memory manager */ | ||
| 724 | r = radeon_object_init(rdev); | ||
| 725 | if (r) | ||
| 726 | return r; | ||
| 727 | r = rs400_gart_init(rdev); | ||
| 728 | if (r) | ||
| 729 | return r; | ||
| 730 | rs600_set_safe_registers(rdev); | ||
| 731 | rdev->accel_working = true; | ||
| 732 | r = rs690_startup(rdev); | ||
| 733 | if (r) { | ||
| 734 | /* Somethings want wront with the accel init stop accel */ | ||
| 735 | dev_err(rdev->dev, "Disabling GPU acceleration\n"); | ||
| 736 | rs690_suspend(rdev); | ||
| 737 | r100_cp_fini(rdev); | ||
| 738 | r100_wb_fini(rdev); | ||
| 739 | r100_ib_fini(rdev); | ||
| 740 | rs400_gart_fini(rdev); | ||
| 741 | radeon_irq_kms_fini(rdev); | ||
| 742 | rdev->accel_working = false; | ||
| 743 | } | ||
| 744 | return 0; | ||
| 650 | } | 745 | } |
diff --git a/drivers/gpu/drm/radeon/rs690d.h b/drivers/gpu/drm/radeon/rs690d.h new file mode 100644 index 000000000000..62d31e7a897f --- /dev/null +++ b/drivers/gpu/drm/radeon/rs690d.h | |||
| @@ -0,0 +1,307 @@ | |||
| 1 | /* | ||
| 2 | * Copyright 2008 Advanced Micro Devices, Inc. | ||
| 3 | * Copyright 2008 Red Hat Inc. | ||
| 4 | * Copyright 2009 Jerome Glisse. | ||
| 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: Dave Airlie | ||
| 25 | * Alex Deucher | ||
| 26 | * Jerome Glisse | ||
| 27 | */ | ||
| 28 | #ifndef __RS690D_H__ | ||
| 29 | #define __RS690D_H__ | ||
| 30 | |||
| 31 | /* Registers */ | ||
| 32 | #define R_000078_MC_INDEX 0x000078 | ||
| 33 | #define S_000078_MC_IND_ADDR(x) (((x) & 0x1FF) << 0) | ||
| 34 | #define G_000078_MC_IND_ADDR(x) (((x) >> 0) & 0x1FF) | ||
| 35 | #define C_000078_MC_IND_ADDR 0xFFFFFE00 | ||
| 36 | #define S_000078_MC_IND_WR_EN(x) (((x) & 0x1) << 9) | ||
| 37 | #define G_000078_MC_IND_WR_EN(x) (((x) >> 9) & 0x1) | ||
| 38 | #define C_000078_MC_IND_WR_EN 0xFFFFFDFF | ||
| 39 | #define R_00007C_MC_DATA 0x00007C | ||
| 40 | #define S_00007C_MC_DATA(x) (((x) & 0xFFFFFFFF) << 0) | ||
| 41 | #define G_00007C_MC_DATA(x) (((x) >> 0) & 0xFFFFFFFF) | ||
| 42 | #define C_00007C_MC_DATA 0x00000000 | ||
| 43 | #define R_0000F8_CONFIG_MEMSIZE 0x0000F8 | ||
| 44 | #define S_0000F8_CONFIG_MEMSIZE(x) (((x) & 0xFFFFFFFF) << 0) | ||
| 45 | #define G_0000F8_CONFIG_MEMSIZE(x) (((x) >> 0) & 0xFFFFFFFF) | ||
| 46 | #define C_0000F8_CONFIG_MEMSIZE 0x00000000 | ||
| 47 | #define R_000134_HDP_FB_LOCATION 0x000134 | ||
| 48 | #define S_000134_HDP_FB_START(x) (((x) & 0xFFFF) << 0) | ||
| 49 | #define G_000134_HDP_FB_START(x) (((x) >> 0) & 0xFFFF) | ||
| 50 | #define C_000134_HDP_FB_START 0xFFFF0000 | ||
| 51 | #define R_0007C0_CP_STAT 0x0007C0 | ||
| 52 | #define S_0007C0_MRU_BUSY(x) (((x) & 0x1) << 0) | ||
| 53 | #define G_0007C0_MRU_BUSY(x) (((x) >> 0) & 0x1) | ||
| 54 | #define C_0007C0_MRU_BUSY 0xFFFFFFFE | ||
| 55 | #define S_0007C0_MWU_BUSY(x) (((x) & 0x1) << 1) | ||
| 56 | #define G_0007C0_MWU_BUSY(x) (((x) >> 1) & 0x1) | ||
| 57 | #define C_0007C0_MWU_BUSY 0xFFFFFFFD | ||
| 58 | #define S_0007C0_RSIU_BUSY(x) (((x) & 0x1) << 2) | ||
| 59 | #define G_0007C0_RSIU_BUSY(x) (((x) >> 2) & 0x1) | ||
| 60 | #define C_0007C0_RSIU_BUSY 0xFFFFFFFB | ||
| 61 | #define S_0007C0_RCIU_BUSY(x) (((x) & 0x1) << 3) | ||
| 62 | #define G_0007C0_RCIU_BUSY(x) (((x) >> 3) & 0x1) | ||
| 63 | #define C_0007C0_RCIU_BUSY 0xFFFFFFF7 | ||
| 64 | #define S_0007C0_CSF_PRIMARY_BUSY(x) (((x) & 0x1) << 9) | ||
| 65 | #define G_0007C0_CSF_PRIMARY_BUSY(x) (((x) >> 9) & 0x1) | ||
| 66 | #define C_0007C0_CSF_PRIMARY_BUSY 0xFFFFFDFF | ||
| 67 | #define S_0007C0_CSF_INDIRECT_BUSY(x) (((x) & 0x1) << 10) | ||
| 68 | #define G_0007C0_CSF_INDIRECT_BUSY(x) (((x) >> 10) & 0x1) | ||
| 69 | #define C_0007C0_CSF_INDIRECT_BUSY 0xFFFFFBFF | ||
| 70 | #define S_0007C0_CSQ_PRIMARY_BUSY(x) (((x) & 0x1) << 11) | ||
| 71 | #define G_0007C0_CSQ_PRIMARY_BUSY(x) (((x) >> 11) & 0x1) | ||
| 72 | #define C_0007C0_CSQ_PRIMARY_BUSY 0xFFFFF7FF | ||
| 73 | #define S_0007C0_CSQ_INDIRECT_BUSY(x) (((x) & 0x1) << 12) | ||
| 74 | #define G_0007C0_CSQ_INDIRECT_BUSY(x) (((x) >> 12) & 0x1) | ||
| 75 | #define C_0007C0_CSQ_INDIRECT_BUSY 0xFFFFEFFF | ||
| 76 | #define S_0007C0_CSI_BUSY(x) (((x) & 0x1) << 13) | ||
| 77 | #define G_0007C0_CSI_BUSY(x) (((x) >> 13) & 0x1) | ||
| 78 | #define C_0007C0_CSI_BUSY 0xFFFFDFFF | ||
| 79 | #define S_0007C0_CSF_INDIRECT2_BUSY(x) (((x) & 0x1) << 14) | ||
| 80 | #define G_0007C0_CSF_INDIRECT2_BUSY(x) (((x) >> 14) & 0x1) | ||
| 81 | #define C_0007C0_CSF_INDIRECT2_BUSY 0xFFFFBFFF | ||
| 82 | #define S_0007C0_CSQ_INDIRECT2_BUSY(x) (((x) & 0x1) << 15) | ||
| 83 | #define G_0007C0_CSQ_INDIRECT2_BUSY(x) (((x) >> 15) & 0x1) | ||
| 84 | #define C_0007C0_CSQ_INDIRECT2_BUSY 0xFFFF7FFF | ||
| 85 | #define S_0007C0_GUIDMA_BUSY(x) (((x) & 0x1) << 28) | ||
| 86 | #define G_0007C0_GUIDMA_BUSY(x) (((x) >> 28) & 0x1) | ||
| 87 | #define C_0007C0_GUIDMA_BUSY 0xEFFFFFFF | ||
| 88 | #define S_0007C0_VIDDMA_BUSY(x) (((x) & 0x1) << 29) | ||
| 89 | #define G_0007C0_VIDDMA_BUSY(x) (((x) >> 29) & 0x1) | ||
| 90 | #define C_0007C0_VIDDMA_BUSY 0xDFFFFFFF | ||
| 91 | #define S_0007C0_CMDSTRM_BUSY(x) (((x) & 0x1) << 30) | ||
| 92 | #define G_0007C0_CMDSTRM_BUSY(x) (((x) >> 30) & 0x1) | ||
| 93 | #define C_0007C0_CMDSTRM_BUSY 0xBFFFFFFF | ||
| 94 | #define S_0007C0_CP_BUSY(x) (((x) & 0x1) << 31) | ||
| 95 | #define G_0007C0_CP_BUSY(x) (((x) >> 31) & 0x1) | ||
| 96 | #define C_0007C0_CP_BUSY 0x7FFFFFFF | ||
| 97 | #define R_000E40_RBBM_STATUS 0x000E40 | ||
| 98 | #define S_000E40_CMDFIFO_AVAIL(x) (((x) & 0x7F) << 0) | ||
| 99 | #define G_000E40_CMDFIFO_AVAIL(x) (((x) >> 0) & 0x7F) | ||
| 100 | #define C_000E40_CMDFIFO_AVAIL 0xFFFFFF80 | ||
| 101 | #define S_000E40_HIRQ_ON_RBB(x) (((x) & 0x1) << 8) | ||
| 102 | #define G_000E40_HIRQ_ON_RBB(x) (((x) >> 8) & 0x1) | ||
| 103 | #define C_000E40_HIRQ_ON_RBB 0xFFFFFEFF | ||
| 104 | #define S_000E40_CPRQ_ON_RBB(x) (((x) & 0x1) << 9) | ||
| 105 | #define G_000E40_CPRQ_ON_RBB(x) (((x) >> 9) & 0x1) | ||
| 106 | #define C_000E40_CPRQ_ON_RBB 0xFFFFFDFF | ||
| 107 | #define S_000E40_CFRQ_ON_RBB(x) (((x) & 0x1) << 10) | ||
| 108 | #define G_000E40_CFRQ_ON_RBB(x) (((x) >> 10) & 0x1) | ||
| 109 | #define C_000E40_CFRQ_ON_RBB 0xFFFFFBFF | ||
| 110 | #define S_000E40_HIRQ_IN_RTBUF(x) (((x) & 0x1) << 11) | ||
| 111 | #define G_000E40_HIRQ_IN_RTBUF(x) (((x) >> 11) & 0x1) | ||
| 112 | #define C_000E40_HIRQ_IN_RTBUF 0xFFFFF7FF | ||
| 113 | #define S_000E40_CPRQ_IN_RTBUF(x) (((x) & 0x1) << 12) | ||
| 114 | #define G_000E40_CPRQ_IN_RTBUF(x) (((x) >> 12) & 0x1) | ||
| 115 | #define C_000E40_CPRQ_IN_RTBUF 0xFFFFEFFF | ||
| 116 | #define S_000E40_CFRQ_IN_RTBUF(x) (((x) & 0x1) << 13) | ||
| 117 | #define G_000E40_CFRQ_IN_RTBUF(x) (((x) >> 13) & 0x1) | ||
| 118 | #define C_000E40_CFRQ_IN_RTBUF 0xFFFFDFFF | ||
| 119 | #define S_000E40_CF_PIPE_BUSY(x) (((x) & 0x1) << 14) | ||
| 120 | #define G_000E40_CF_PIPE_BUSY(x) (((x) >> 14) & 0x1) | ||
| 121 | #define C_000E40_CF_PIPE_BUSY 0xFFFFBFFF | ||
| 122 | #define S_000E40_ENG_EV_BUSY(x) (((x) & 0x1) << 15) | ||
| 123 | #define G_000E40_ENG_EV_BUSY(x) (((x) >> 15) & 0x1) | ||
| 124 | #define C_000E40_ENG_EV_BUSY 0xFFFF7FFF | ||
| 125 | #define S_000E40_CP_CMDSTRM_BUSY(x) (((x) & 0x1) << 16) | ||
| 126 | #define G_000E40_CP_CMDSTRM_BUSY(x) (((x) >> 16) & 0x1) | ||
| 127 | #define C_000E40_CP_CMDSTRM_BUSY 0xFFFEFFFF | ||
| 128 | #define S_000E40_E2_BUSY(x) (((x) & 0x1) << 17) | ||
| 129 | #define G_000E40_E2_BUSY(x) (((x) >> 17) & 0x1) | ||
| 130 | #define C_000E40_E2_BUSY 0xFFFDFFFF | ||
| 131 | #define S_000E40_RB2D_BUSY(x) (((x) & 0x1) << 18) | ||
| 132 | #define G_000E40_RB2D_BUSY(x) (((x) >> 18) & 0x1) | ||
| 133 | #define C_000E40_RB2D_BUSY 0xFFFBFFFF | ||
| 134 | #define S_000E40_RB3D_BUSY(x) (((x) & 0x1) << 19) | ||
| 135 | #define G_000E40_RB3D_BUSY(x) (((x) >> 19) & 0x1) | ||
| 136 | #define C_000E40_RB3D_BUSY 0xFFF7FFFF | ||
| 137 | #define S_000E40_VAP_BUSY(x) (((x) & 0x1) << 20) | ||
| 138 | #define G_000E40_VAP_BUSY(x) (((x) >> 20) & 0x1) | ||
| 139 | #define C_000E40_VAP_BUSY 0xFFEFFFFF | ||
| 140 | #define S_000E40_RE_BUSY(x) (((x) & 0x1) << 21) | ||
| 141 | #define G_000E40_RE_BUSY(x) (((x) >> 21) & 0x1) | ||
| 142 | #define C_000E40_RE_BUSY 0xFFDFFFFF | ||
| 143 | #define S_000E40_TAM_BUSY(x) (((x) & 0x1) << 22) | ||
| 144 | #define G_000E40_TAM_BUSY(x) (((x) >> 22) & 0x1) | ||
| 145 | #define C_000E40_TAM_BUSY 0xFFBFFFFF | ||
| 146 | #define S_000E40_TDM_BUSY(x) (((x) & 0x1) << 23) | ||
| 147 | #define G_000E40_TDM_BUSY(x) (((x) >> 23) & 0x1) | ||
| 148 | #define C_000E40_TDM_BUSY 0xFF7FFFFF | ||
| 149 | #define S_000E40_PB_BUSY(x) (((x) & 0x1) << 24) | ||
| 150 | #define G_000E40_PB_BUSY(x) (((x) >> 24) & 0x1) | ||
| 151 | #define C_000E40_PB_BUSY 0xFEFFFFFF | ||
| 152 | #define S_000E40_TIM_BUSY(x) (((x) & 0x1) << 25) | ||
| 153 | #define G_000E40_TIM_BUSY(x) (((x) >> 25) & 0x1) | ||
| 154 | #define C_000E40_TIM_BUSY 0xFDFFFFFF | ||
| 155 | #define S_000E40_GA_BUSY(x) (((x) & 0x1) << 26) | ||
| 156 | #define G_000E40_GA_BUSY(x) (((x) >> 26) & 0x1) | ||
| 157 | #define C_000E40_GA_BUSY 0xFBFFFFFF | ||
| 158 | #define S_000E40_CBA2D_BUSY(x) (((x) & 0x1) << 27) | ||
| 159 | #define G_000E40_CBA2D_BUSY(x) (((x) >> 27) & 0x1) | ||
| 160 | #define C_000E40_CBA2D_BUSY 0xF7FFFFFF | ||
| 161 | #define S_000E40_GUI_ACTIVE(x) (((x) & 0x1) << 31) | ||
| 162 | #define G_000E40_GUI_ACTIVE(x) (((x) >> 31) & 0x1) | ||
| 163 | #define C_000E40_GUI_ACTIVE 0x7FFFFFFF | ||
| 164 | #define R_006520_DC_LB_MEMORY_SPLIT 0x006520 | ||
| 165 | #define S_006520_DC_LB_MEMORY_SPLIT(x) (((x) & 0x3) << 0) | ||
| 166 | #define G_006520_DC_LB_MEMORY_SPLIT(x) (((x) >> 0) & 0x3) | ||
| 167 | #define C_006520_DC_LB_MEMORY_SPLIT 0xFFFFFFFC | ||
| 168 | #define S_006520_DC_LB_MEMORY_SPLIT_MODE(x) (((x) & 0x1) << 2) | ||
| 169 | #define G_006520_DC_LB_MEMORY_SPLIT_MODE(x) (((x) >> 2) & 0x1) | ||
| 170 | #define C_006520_DC_LB_MEMORY_SPLIT_MODE 0xFFFFFFFB | ||
| 171 | #define V_006520_DC_LB_MEMORY_SPLIT_D1HALF_D2HALF 0 | ||
| 172 | #define V_006520_DC_LB_MEMORY_SPLIT_D1_3Q_D2_1Q 1 | ||
| 173 | #define V_006520_DC_LB_MEMORY_SPLIT_D1_ONLY 2 | ||
| 174 | #define V_006520_DC_LB_MEMORY_SPLIT_D1_1Q_D2_3Q 3 | ||
| 175 | #define S_006520_DC_LB_DISP1_END_ADR(x) (((x) & 0x7FF) << 4) | ||
| 176 | #define G_006520_DC_LB_DISP1_END_ADR(x) (((x) >> 4) & 0x7FF) | ||
| 177 | #define C_006520_DC_LB_DISP1_END_ADR 0xFFFF800F | ||
| 178 | #define R_006548_D1MODE_PRIORITY_A_CNT 0x006548 | ||
| 179 | #define S_006548_D1MODE_PRIORITY_MARK_A(x) (((x) & 0x7FFF) << 0) | ||
| 180 | #define G_006548_D1MODE_PRIORITY_MARK_A(x) (((x) >> 0) & 0x7FFF) | ||
| 181 | #define C_006548_D1MODE_PRIORITY_MARK_A 0xFFFF8000 | ||
| 182 | #define S_006548_D1MODE_PRIORITY_A_OFF(x) (((x) & 0x1) << 16) | ||
| 183 | #define G_006548_D1MODE_PRIORITY_A_OFF(x) (((x) >> 16) & 0x1) | ||
| 184 | #define C_006548_D1MODE_PRIORITY_A_OFF 0xFFFEFFFF | ||
| 185 | #define S_006548_D1MODE_PRIORITY_A_FORCE_MASK(x) (((x) & 0x1) << 24) | ||
| 186 | #define G_006548_D1MODE_PRIORITY_A_FORCE_MASK(x) (((x) >> 24) & 0x1) | ||
| 187 | #define C_006548_D1MODE_PRIORITY_A_FORCE_MASK 0xFEFFFFFF | ||
| 188 | #define R_00654C_D1MODE_PRIORITY_B_CNT 0x00654C | ||
| 189 | #define S_00654C_D1MODE_PRIORITY_MARK_B(x) (((x) & 0x7FFF) << 0) | ||
| 190 | #define G_00654C_D1MODE_PRIORITY_MARK_B(x) (((x) >> 0) & 0x7FFF) | ||
| 191 | #define C_00654C_D1MODE_PRIORITY_MARK_B 0xFFFF8000 | ||
| 192 | #define S_00654C_D1MODE_PRIORITY_B_OFF(x) (((x) & 0x1) << 16) | ||
| 193 | #define G_00654C_D1MODE_PRIORITY_B_OFF(x) (((x) >> 16) & 0x1) | ||
| 194 | #define C_00654C_D1MODE_PRIORITY_B_OFF 0xFFFEFFFF | ||
| 195 | #define S_00654C_D1MODE_PRIORITY_B_ALWAYS_ON(x) (((x) & 0x1) << 20) | ||
| 196 | #define G_00654C_D1MODE_PRIORITY_B_ALWAYS_ON(x) (((x) >> 20) & 0x1) | ||
| 197 | #define C_00654C_D1MODE_PRIORITY_B_ALWAYS_ON 0xFFEFFFFF | ||
| 198 | #define S_00654C_D1MODE_PRIORITY_B_FORCE_MASK(x) (((x) & 0x1) << 24) | ||
| 199 | #define G_00654C_D1MODE_PRIORITY_B_FORCE_MASK(x) (((x) >> 24) & 0x1) | ||
| 200 | #define C_00654C_D1MODE_PRIORITY_B_FORCE_MASK 0xFEFFFFFF | ||
| 201 | #define R_006C9C_DCP_CONTROL 0x006C9C | ||
| 202 | #define R_006D48_D2MODE_PRIORITY_A_CNT 0x006D48 | ||
| 203 | #define S_006D48_D2MODE_PRIORITY_MARK_A(x) (((x) & 0x7FFF) << 0) | ||
| 204 | #define G_006D48_D2MODE_PRIORITY_MARK_A(x) (((x) >> 0) & 0x7FFF) | ||
| 205 | #define C_006D48_D2MODE_PRIORITY_MARK_A 0xFFFF8000 | ||
| 206 | #define S_006D48_D2MODE_PRIORITY_A_OFF(x) (((x) & 0x1) << 16) | ||
| 207 | #define G_006D48_D2MODE_PRIORITY_A_OFF(x) (((x) >> 16) & 0x1) | ||
| 208 | #define C_006D48_D2MODE_PRIORITY_A_OFF 0xFFFEFFFF | ||
| 209 | #define S_006D48_D2MODE_PRIORITY_A_ALWAYS_ON(x) (((x) & 0x1) << 20) | ||
| 210 | #define G_006D48_D2MODE_PRIORITY_A_ALWAYS_ON(x) (((x) >> 20) & 0x1) | ||
| 211 | #define C_006D48_D2MODE_PRIORITY_A_ALWAYS_ON 0xFFEFFFFF | ||
| 212 | #define S_006D48_D2MODE_PRIORITY_A_FORCE_MASK(x) (((x) & 0x1) << 24) | ||
| 213 | #define G_006D48_D2MODE_PRIORITY_A_FORCE_MASK(x) (((x) >> 24) & 0x1) | ||
| 214 | #define C_006D48_D2MODE_PRIORITY_A_FORCE_MASK 0xFEFFFFFF | ||
| 215 | #define R_006D4C_D2MODE_PRIORITY_B_CNT 0x006D4C | ||
| 216 | #define S_006D4C_D2MODE_PRIORITY_MARK_B(x) (((x) & 0x7FFF) << 0) | ||
| 217 | #define G_006D4C_D2MODE_PRIORITY_MARK_B(x) (((x) >> 0) & 0x7FFF) | ||
| 218 | #define C_006D4C_D2MODE_PRIORITY_MARK_B 0xFFFF8000 | ||
| 219 | #define S_006D4C_D2MODE_PRIORITY_B_OFF(x) (((x) & 0x1) << 16) | ||
| 220 | #define G_006D4C_D2MODE_PRIORITY_B_OFF(x) (((x) >> 16) & 0x1) | ||
| 221 | #define C_006D4C_D2MODE_PRIORITY_B_OFF 0xFFFEFFFF | ||
| 222 | #define S_006D4C_D2MODE_PRIORITY_B_ALWAYS_ON(x) (((x) & 0x1) << 20) | ||
| 223 | #define G_006D4C_D2MODE_PRIORITY_B_ALWAYS_ON(x) (((x) >> 20) & 0x1) | ||
| 224 | #define C_006D4C_D2MODE_PRIORITY_B_ALWAYS_ON 0xFFEFFFFF | ||
| 225 | #define S_006D4C_D2MODE_PRIORITY_B_FORCE_MASK(x) (((x) & 0x1) << 24) | ||
| 226 | #define G_006D4C_D2MODE_PRIORITY_B_FORCE_MASK(x) (((x) >> 24) & 0x1) | ||
| 227 | #define C_006D4C_D2MODE_PRIORITY_B_FORCE_MASK 0xFEFFFFFF | ||
| 228 | #define R_006D58_LB_MAX_REQ_OUTSTANDING 0x006D58 | ||
| 229 | #define S_006D58_LB_D1_MAX_REQ_OUTSTANDING(x) (((x) & 0xF) << 0) | ||
| 230 | #define G_006D58_LB_D1_MAX_REQ_OUTSTANDING(x) (((x) >> 0) & 0xF) | ||
| 231 | #define C_006D58_LB_D1_MAX_REQ_OUTSTANDING 0xFFFFFFF0 | ||
| 232 | #define S_006D58_LB_D2_MAX_REQ_OUTSTANDING(x) (((x) & 0xF) << 16) | ||
| 233 | #define G_006D58_LB_D2_MAX_REQ_OUTSTANDING(x) (((x) >> 16) & 0xF) | ||
| 234 | #define C_006D58_LB_D2_MAX_REQ_OUTSTANDING 0xFFF0FFFF | ||
| 235 | |||
| 236 | |||
| 237 | #define R_000090_MC_SYSTEM_STATUS 0x000090 | ||
| 238 | #define S_000090_MC_SYSTEM_IDLE(x) (((x) & 0x1) << 0) | ||
| 239 | #define G_000090_MC_SYSTEM_IDLE(x) (((x) >> 0) & 0x1) | ||
| 240 | #define C_000090_MC_SYSTEM_IDLE 0xFFFFFFFE | ||
| 241 | #define S_000090_MC_SEQUENCER_IDLE(x) (((x) & 0x1) << 1) | ||
| 242 | #define G_000090_MC_SEQUENCER_IDLE(x) (((x) >> 1) & 0x1) | ||
| 243 | #define C_000090_MC_SEQUENCER_IDLE 0xFFFFFFFD | ||
| 244 | #define S_000090_MC_ARBITER_IDLE(x) (((x) & 0x1) << 2) | ||
| 245 | #define G_000090_MC_ARBITER_IDLE(x) (((x) >> 2) & 0x1) | ||
| 246 | #define C_000090_MC_ARBITER_IDLE 0xFFFFFFFB | ||
| 247 | #define S_000090_MC_SELECT_PM(x) (((x) & 0x1) << 3) | ||
| 248 | #define G_000090_MC_SELECT_PM(x) (((x) >> 3) & 0x1) | ||
| 249 | #define C_000090_MC_SELECT_PM 0xFFFFFFF7 | ||
| 250 | #define S_000090_RESERVED4(x) (((x) & 0xF) << 4) | ||
| 251 | #define G_000090_RESERVED4(x) (((x) >> 4) & 0xF) | ||
| 252 | #define C_000090_RESERVED4 0xFFFFFF0F | ||
| 253 | #define S_000090_RESERVED8(x) (((x) & 0xF) << 8) | ||
| 254 | #define G_000090_RESERVED8(x) (((x) >> 8) & 0xF) | ||
| 255 | #define C_000090_RESERVED8 0xFFFFF0FF | ||
| 256 | #define S_000090_RESERVED12(x) (((x) & 0xF) << 12) | ||
| 257 | #define G_000090_RESERVED12(x) (((x) >> 12) & 0xF) | ||
| 258 | #define C_000090_RESERVED12 0xFFFF0FFF | ||
| 259 | #define S_000090_MCA_INIT_EXECUTED(x) (((x) & 0x1) << 16) | ||
| 260 | #define G_000090_MCA_INIT_EXECUTED(x) (((x) >> 16) & 0x1) | ||
| 261 | #define C_000090_MCA_INIT_EXECUTED 0xFFFEFFFF | ||
| 262 | #define S_000090_MCA_IDLE(x) (((x) & 0x1) << 17) | ||
| 263 | #define G_000090_MCA_IDLE(x) (((x) >> 17) & 0x1) | ||
| 264 | #define C_000090_MCA_IDLE 0xFFFDFFFF | ||
| 265 | #define S_000090_MCA_SEQ_IDLE(x) (((x) & 0x1) << 18) | ||
| 266 | #define G_000090_MCA_SEQ_IDLE(x) (((x) >> 18) & 0x1) | ||
| 267 | #define C_000090_MCA_SEQ_IDLE 0xFFFBFFFF | ||
| 268 | #define S_000090_MCA_ARB_IDLE(x) (((x) & 0x1) << 19) | ||
| 269 | #define G_000090_MCA_ARB_IDLE(x) (((x) >> 19) & 0x1) | ||
| 270 | #define C_000090_MCA_ARB_IDLE 0xFFF7FFFF | ||
| 271 | #define S_000090_RESERVED20(x) (((x) & 0xFFF) << 20) | ||
| 272 | #define G_000090_RESERVED20(x) (((x) >> 20) & 0xFFF) | ||
| 273 | #define C_000090_RESERVED20 0x000FFFFF | ||
| 274 | #define R_000100_MCCFG_FB_LOCATION 0x000100 | ||
| 275 | #define S_000100_MC_FB_START(x) (((x) & 0xFFFF) << 0) | ||
| 276 | #define G_000100_MC_FB_START(x) (((x) >> 0) & 0xFFFF) | ||
| 277 | #define C_000100_MC_FB_START 0xFFFF0000 | ||
| 278 | #define S_000100_MC_FB_TOP(x) (((x) & 0xFFFF) << 16) | ||
| 279 | #define G_000100_MC_FB_TOP(x) (((x) >> 16) & 0xFFFF) | ||
| 280 | #define C_000100_MC_FB_TOP 0x0000FFFF | ||
| 281 | #define R_000104_MC_INIT_MISC_LAT_TIMER 0x000104 | ||
| 282 | #define S_000104_MC_CPR_INIT_LAT(x) (((x) & 0xF) << 0) | ||
| 283 | #define G_000104_MC_CPR_INIT_LAT(x) (((x) >> 0) & 0xF) | ||
| 284 | #define C_000104_MC_CPR_INIT_LAT 0xFFFFFFF0 | ||
| 285 | #define S_000104_MC_VF_INIT_LAT(x) (((x) & 0xF) << 4) | ||
| 286 | #define G_000104_MC_VF_INIT_LAT(x) (((x) >> 4) & 0xF) | ||
| 287 | #define C_000104_MC_VF_INIT_LAT 0xFFFFFF0F | ||
| 288 | #define S_000104_MC_DISP0R_INIT_LAT(x) (((x) & 0xF) << 8) | ||
| 289 | #define G_000104_MC_DISP0R_INIT_LAT(x) (((x) >> 8) & 0xF) | ||
| 290 | #define C_000104_MC_DISP0R_INIT_LAT 0xFFFFF0FF | ||
| 291 | #define S_000104_MC_DISP1R_INIT_LAT(x) (((x) & 0xF) << 12) | ||
| 292 | #define G_000104_MC_DISP1R_INIT_LAT(x) (((x) >> 12) & 0xF) | ||
| 293 | #define C_000104_MC_DISP1R_INIT_LAT 0xFFFF0FFF | ||
| 294 | #define S_000104_MC_FIXED_INIT_LAT(x) (((x) & 0xF) << 16) | ||
| 295 | #define G_000104_MC_FIXED_INIT_LAT(x) (((x) >> 16) & 0xF) | ||
| 296 | #define C_000104_MC_FIXED_INIT_LAT 0xFFF0FFFF | ||
| 297 | #define S_000104_MC_E2R_INIT_LAT(x) (((x) & 0xF) << 20) | ||
| 298 | #define G_000104_MC_E2R_INIT_LAT(x) (((x) >> 20) & 0xF) | ||
| 299 | #define C_000104_MC_E2R_INIT_LAT 0xFF0FFFFF | ||
| 300 | #define S_000104_SAME_PAGE_PRIO(x) (((x) & 0xF) << 24) | ||
| 301 | #define G_000104_SAME_PAGE_PRIO(x) (((x) >> 24) & 0xF) | ||
| 302 | #define C_000104_SAME_PAGE_PRIO 0xF0FFFFFF | ||
| 303 | #define S_000104_MC_GLOBW_INIT_LAT(x) (((x) & 0xF) << 28) | ||
| 304 | #define G_000104_MC_GLOBW_INIT_LAT(x) (((x) >> 28) & 0xF) | ||
| 305 | #define C_000104_MC_GLOBW_INIT_LAT 0x0FFFFFFF | ||
| 306 | |||
| 307 | #endif | ||
diff --git a/drivers/gpu/drm/radeon/rs690r.h b/drivers/gpu/drm/radeon/rs690r.h deleted file mode 100644 index c0d9faa2175b..000000000000 --- a/drivers/gpu/drm/radeon/rs690r.h +++ /dev/null | |||
| @@ -1,99 +0,0 @@ | |||
| 1 | /* | ||
| 2 | * Copyright 2008 Advanced Micro Devices, Inc. | ||
| 3 | * Copyright 2008 Red Hat Inc. | ||
| 4 | * Copyright 2009 Jerome Glisse. | ||
| 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: Dave Airlie | ||
| 25 | * Alex Deucher | ||
| 26 | * Jerome Glisse | ||
| 27 | */ | ||
| 28 | #ifndef RS690R_H | ||
| 29 | #define RS690R_H | ||
| 30 | |||
| 31 | /* RS690/RS740 registers */ | ||
| 32 | #define MC_INDEX 0x0078 | ||
| 33 | # define MC_INDEX_MASK 0x1FF | ||
| 34 | # define MC_INDEX_WR_EN (1 << 9) | ||
| 35 | # define MC_INDEX_WR_ACK 0x7F | ||
| 36 | #define MC_DATA 0x007C | ||
| 37 | #define HDP_FB_LOCATION 0x0134 | ||
| 38 | #define DC_LB_MEMORY_SPLIT 0x6520 | ||
| 39 | #define DC_LB_MEMORY_SPLIT_MASK 0x00000003 | ||
| 40 | #define DC_LB_MEMORY_SPLIT_SHIFT 0 | ||
| 41 | #define DC_LB_MEMORY_SPLIT_D1HALF_D2HALF 0 | ||
| 42 | #define DC_LB_MEMORY_SPLIT_D1_3Q_D2_1Q 1 | ||
| 43 | #define DC_LB_MEMORY_SPLIT_D1_ONLY 2 | ||
| 44 | #define DC_LB_MEMORY_SPLIT_D1_1Q_D2_3Q 3 | ||
| 45 | #define DC_LB_MEMORY_SPLIT_SHIFT_MODE (1 << 2) | ||
| 46 | #define DC_LB_DISP1_END_ADR_SHIFT 4 | ||
| 47 | #define DC_LB_DISP1_END_ADR_MASK 0x00007FF0 | ||
| 48 | #define D1MODE_PRIORITY_A_CNT 0x6548 | ||
| 49 | #define MODE_PRIORITY_MARK_MASK 0x00007FFF | ||
| 50 | #define MODE_PRIORITY_OFF (1 << 16) | ||
| 51 | #define MODE_PRIORITY_ALWAYS_ON (1 << 20) | ||
| 52 | #define MODE_PRIORITY_FORCE_MASK (1 << 24) | ||
| 53 | #define D1MODE_PRIORITY_B_CNT 0x654C | ||
| 54 | #define LB_MAX_REQ_OUTSTANDING 0x6D58 | ||
| 55 | #define LB_D1_MAX_REQ_OUTSTANDING_MASK 0x0000000F | ||
| 56 | #define LB_D1_MAX_REQ_OUTSTANDING_SHIFT 0 | ||
| 57 | #define LB_D2_MAX_REQ_OUTSTANDING_MASK 0x000F0000 | ||
| 58 | #define LB_D2_MAX_REQ_OUTSTANDING_SHIFT 16 | ||
| 59 | #define DCP_CONTROL 0x6C9C | ||
| 60 | #define D2MODE_PRIORITY_A_CNT 0x6D48 | ||
| 61 | #define D2MODE_PRIORITY_B_CNT 0x6D4C | ||
| 62 | |||
| 63 | /* MC indirect registers */ | ||
| 64 | #define MC_STATUS_IDLE (1 << 0) | ||
| 65 | #define MC_MISC_CNTL 0x18 | ||
| 66 | #define DISABLE_GTW (1 << 1) | ||
| 67 | #define GART_INDEX_REG_EN (1 << 12) | ||
| 68 | #define BLOCK_GFX_D3_EN (1 << 14) | ||
| 69 | #define GART_FEATURE_ID 0x2B | ||
| 70 | #define HANG_EN (1 << 11) | ||
| 71 | #define TLB_ENABLE (1 << 18) | ||
| 72 | #define P2P_ENABLE (1 << 19) | ||
| 73 | #define GTW_LAC_EN (1 << 25) | ||
| 74 | #define LEVEL2_GART (0 << 30) | ||
| 75 | #define LEVEL1_GART (1 << 30) | ||
| 76 | #define PDC_EN (1 << 31) | ||
| 77 | #define GART_BASE 0x2C | ||
| 78 | #define GART_CACHE_CNTRL 0x2E | ||
| 79 | # define GART_CACHE_INVALIDATE (1 << 0) | ||
| 80 | #define MC_STATUS 0x90 | ||
| 81 | #define MCCFG_FB_LOCATION 0x100 | ||
| 82 | #define MC_FB_START_MASK 0x0000FFFF | ||
| 83 | #define MC_FB_START_SHIFT 0 | ||
| 84 | #define MC_FB_TOP_MASK 0xFFFF0000 | ||
| 85 | #define MC_FB_TOP_SHIFT 16 | ||
| 86 | #define MCCFG_AGP_LOCATION 0x101 | ||
| 87 | #define MC_AGP_START_MASK 0x0000FFFF | ||
| 88 | #define MC_AGP_START_SHIFT 0 | ||
| 89 | #define MC_AGP_TOP_MASK 0xFFFF0000 | ||
| 90 | #define MC_AGP_TOP_SHIFT 16 | ||
| 91 | #define MCCFG_AGP_BASE 0x102 | ||
| 92 | #define MCCFG_AGP_BASE_2 0x103 | ||
| 93 | #define MC_INIT_MISC_LAT_TIMER 0x104 | ||
| 94 | #define MC_DISP0R_INIT_LAT_SHIFT 8 | ||
| 95 | #define MC_DISP0R_INIT_LAT_MASK 0x00000F00 | ||
| 96 | #define MC_DISP1R_INIT_LAT_SHIFT 12 | ||
| 97 | #define MC_DISP1R_INIT_LAT_MASK 0x0000F000 | ||
| 98 | |||
| 99 | #endif | ||
diff --git a/drivers/gpu/drm/radeon/rv200d.h b/drivers/gpu/drm/radeon/rv200d.h new file mode 100644 index 000000000000..c5b398330c26 --- /dev/null +++ b/drivers/gpu/drm/radeon/rv200d.h | |||
| @@ -0,0 +1,36 @@ | |||
| 1 | /* | ||
| 2 | * Copyright 2008 Advanced Micro Devices, Inc. | ||
| 3 | * Copyright 2008 Red Hat Inc. | ||
| 4 | * Copyright 2009 Jerome Glisse. | ||
| 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: Dave Airlie | ||
| 25 | * Alex Deucher | ||
| 26 | * Jerome Glisse | ||
| 27 | */ | ||
| 28 | #ifndef __RV200D_H__ | ||
| 29 | #define __RV200D_H__ | ||
| 30 | |||
| 31 | #define R_00015C_AGP_BASE_2 0x00015C | ||
| 32 | #define S_00015C_AGP_BASE_ADDR_2(x) (((x) & 0xF) << 0) | ||
| 33 | #define G_00015C_AGP_BASE_ADDR_2(x) (((x) >> 0) & 0xF) | ||
| 34 | #define C_00015C_AGP_BASE_ADDR_2 0xFFFFFFF0 | ||
| 35 | |||
| 36 | #endif | ||
diff --git a/drivers/gpu/drm/radeon/rv250d.h b/drivers/gpu/drm/radeon/rv250d.h new file mode 100644 index 000000000000..e5a70b06fe1f --- /dev/null +++ b/drivers/gpu/drm/radeon/rv250d.h | |||
| @@ -0,0 +1,123 @@ | |||
| 1 | /* | ||
| 2 | * Copyright 2008 Advanced Micro Devices, Inc. | ||
| 3 | * Copyright 2008 Red Hat Inc. | ||
| 4 | * Copyright 2009 Jerome Glisse. | ||
| 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: Dave Airlie | ||
| 25 | * Alex Deucher | ||
| 26 | * Jerome Glisse | ||
| 27 | */ | ||
| 28 | #ifndef __RV250D_H__ | ||
| 29 | #define __RV250D_H__ | ||
| 30 | |||
| 31 | #define R_00000D_SCLK_CNTL_M6 0x00000D | ||
| 32 | #define S_00000D_SCLK_SRC_SEL(x) (((x) & 0x7) << 0) | ||
| 33 | #define G_00000D_SCLK_SRC_SEL(x) (((x) >> 0) & 0x7) | ||
| 34 | #define C_00000D_SCLK_SRC_SEL 0xFFFFFFF8 | ||
| 35 | #define S_00000D_CP_MAX_DYN_STOP_LAT(x) (((x) & 0x1) << 3) | ||
| 36 | #define G_00000D_CP_MAX_DYN_STOP_LAT(x) (((x) >> 3) & 0x1) | ||
| 37 | #define C_00000D_CP_MAX_DYN_STOP_LAT 0xFFFFFFF7 | ||
| 38 | #define S_00000D_HDP_MAX_DYN_STOP_LAT(x) (((x) & 0x1) << 4) | ||
| 39 | #define G_00000D_HDP_MAX_DYN_STOP_LAT(x) (((x) >> 4) & 0x1) | ||
| 40 | #define C_00000D_HDP_MAX_DYN_STOP_LAT 0xFFFFFFEF | ||
| 41 | #define S_00000D_TV_MAX_DYN_STOP_LAT(x) (((x) & 0x1) << 5) | ||
| 42 | #define G_00000D_TV_MAX_DYN_STOP_LAT(x) (((x) >> 5) & 0x1) | ||
| 43 | #define C_00000D_TV_MAX_DYN_STOP_LAT 0xFFFFFFDF | ||
| 44 | #define S_00000D_E2_MAX_DYN_STOP_LAT(x) (((x) & 0x1) << 6) | ||
| 45 | #define G_00000D_E2_MAX_DYN_STOP_LAT(x) (((x) >> 6) & 0x1) | ||
| 46 | #define C_00000D_E2_MAX_DYN_STOP_LAT 0xFFFFFFBF | ||
| 47 | #define S_00000D_SE_MAX_DYN_STOP_LAT(x) (((x) & 0x1) << 7) | ||
| 48 | #define G_00000D_SE_MAX_DYN_STOP_LAT(x) (((x) >> 7) & 0x1) | ||
| 49 | #define C_00000D_SE_MAX_DYN_STOP_LAT 0xFFFFFF7F | ||
| 50 | #define S_00000D_IDCT_MAX_DYN_STOP_LAT(x) (((x) & 0x1) << 8) | ||
| 51 | #define G_00000D_IDCT_MAX_DYN_STOP_LAT(x) (((x) >> 8) & 0x1) | ||
| 52 | #define C_00000D_IDCT_MAX_DYN_STOP_LAT 0xFFFFFEFF | ||
| 53 | #define S_00000D_VIP_MAX_DYN_STOP_LAT(x) (((x) & 0x1) << 9) | ||
| 54 | #define G_00000D_VIP_MAX_DYN_STOP_LAT(x) (((x) >> 9) & 0x1) | ||
| 55 | #define C_00000D_VIP_MAX_DYN_STOP_LAT 0xFFFFFDFF | ||
| 56 | #define S_00000D_RE_MAX_DYN_STOP_LAT(x) (((x) & 0x1) << 10) | ||
| 57 | #define G_00000D_RE_MAX_DYN_STOP_LAT(x) (((x) >> 10) & 0x1) | ||
| 58 | #define C_00000D_RE_MAX_DYN_STOP_LAT 0xFFFFFBFF | ||
| 59 | #define S_00000D_PB_MAX_DYN_STOP_LAT(x) (((x) & 0x1) << 11) | ||
| 60 | #define G_00000D_PB_MAX_DYN_STOP_LAT(x) (((x) >> 11) & 0x1) | ||
| 61 | #define C_00000D_PB_MAX_DYN_STOP_LAT 0xFFFFF7FF | ||
| 62 | #define S_00000D_TAM_MAX_DYN_STOP_LAT(x) (((x) & 0x1) << 12) | ||
| 63 | #define G_00000D_TAM_MAX_DYN_STOP_LAT(x) (((x) >> 12) & 0x1) | ||
| 64 | #define C_00000D_TAM_MAX_DYN_STOP_LAT 0xFFFFEFFF | ||
| 65 | #define S_00000D_TDM_MAX_DYN_STOP_LAT(x) (((x) & 0x1) << 13) | ||
| 66 | #define G_00000D_TDM_MAX_DYN_STOP_LAT(x) (((x) >> 13) & 0x1) | ||
| 67 | #define C_00000D_TDM_MAX_DYN_STOP_LAT 0xFFFFDFFF | ||
| 68 | #define S_00000D_RB_MAX_DYN_STOP_LAT(x) (((x) & 0x1) << 14) | ||
| 69 | #define G_00000D_RB_MAX_DYN_STOP_LAT(x) (((x) >> 14) & 0x1) | ||
| 70 | #define C_00000D_RB_MAX_DYN_STOP_LAT 0xFFFFBFFF | ||
| 71 | #define S_00000D_FORCE_DISP2(x) (((x) & 0x1) << 15) | ||
| 72 | #define G_00000D_FORCE_DISP2(x) (((x) >> 15) & 0x1) | ||
| 73 | #define C_00000D_FORCE_DISP2 0xFFFF7FFF | ||
| 74 | #define S_00000D_FORCE_CP(x) (((x) & 0x1) << 16) | ||
| 75 | #define G_00000D_FORCE_CP(x) (((x) >> 16) & 0x1) | ||
| 76 | #define C_00000D_FORCE_CP 0xFFFEFFFF | ||
| 77 | #define S_00000D_FORCE_HDP(x) (((x) & 0x1) << 17) | ||
| 78 | #define G_00000D_FORCE_HDP(x) (((x) >> 17) & 0x1) | ||
| 79 | #define C_00000D_FORCE_HDP 0xFFFDFFFF | ||
| 80 | #define S_00000D_FORCE_DISP1(x) (((x) & 0x1) << 18) | ||
| 81 | #define G_00000D_FORCE_DISP1(x) (((x) >> 18) & 0x1) | ||
| 82 | #define C_00000D_FORCE_DISP1 0xFFFBFFFF | ||
| 83 | #define S_00000D_FORCE_TOP(x) (((x) & 0x1) << 19) | ||
| 84 | #define G_00000D_FORCE_TOP(x) (((x) >> 19) & 0x1) | ||
| 85 | #define C_00000D_FORCE_TOP 0xFFF7FFFF | ||
| 86 | #define S_00000D_FORCE_E2(x) (((x) & 0x1) << 20) | ||
| 87 | #define G_00000D_FORCE_E2(x) (((x) >> 20) & 0x1) | ||
| 88 | #define C_00000D_FORCE_E2 0xFFEFFFFF | ||
| 89 | #define S_00000D_FORCE_SE(x) (((x) & 0x1) << 21) | ||
| 90 | #define G_00000D_FORCE_SE(x) (((x) >> 21) & 0x1) | ||
| 91 | #define C_00000D_FORCE_SE 0xFFDFFFFF | ||
| 92 | #define S_00000D_FORCE_IDCT(x) (((x) & 0x1) << 22) | ||
| 93 | #define G_00000D_FORCE_IDCT(x) (((x) >> 22) & 0x1) | ||
| 94 | #define C_00000D_FORCE_IDCT 0xFFBFFFFF | ||
| 95 | #define S_00000D_FORCE_VIP(x) (((x) & 0x1) << 23) | ||
| 96 | #define G_00000D_FORCE_VIP(x) (((x) >> 23) & 0x1) | ||
| 97 | #define C_00000D_FORCE_VIP 0xFF7FFFFF | ||
| 98 | #define S_00000D_FORCE_RE(x) (((x) & 0x1) << 24) | ||
| 99 | #define G_00000D_FORCE_RE(x) (((x) >> 24) & 0x1) | ||
| 100 | #define C_00000D_FORCE_RE 0xFEFFFFFF | ||
| 101 | #define S_00000D_FORCE_PB(x) (((x) & 0x1) << 25) | ||
| 102 | #define G_00000D_FORCE_PB(x) (((x) >> 25) & 0x1) | ||
| 103 | #define C_00000D_FORCE_PB 0xFDFFFFFF | ||
| 104 | #define S_00000D_FORCE_TAM(x) (((x) & 0x1) << 26) | ||
| 105 | #define G_00000D_FORCE_TAM(x) (((x) >> 26) & 0x1) | ||
| 106 | #define C_00000D_FORCE_TAM 0xFBFFFFFF | ||
| 107 | #define S_00000D_FORCE_TDM(x) (((x) & 0x1) << 27) | ||
| 108 | #define G_00000D_FORCE_TDM(x) (((x) >> 27) & 0x1) | ||
| 109 | #define C_00000D_FORCE_TDM 0xF7FFFFFF | ||
| 110 | #define S_00000D_FORCE_RB(x) (((x) & 0x1) << 28) | ||
| 111 | #define G_00000D_FORCE_RB(x) (((x) >> 28) & 0x1) | ||
| 112 | #define C_00000D_FORCE_RB 0xEFFFFFFF | ||
| 113 | #define S_00000D_FORCE_TV_SCLK(x) (((x) & 0x1) << 29) | ||
| 114 | #define G_00000D_FORCE_TV_SCLK(x) (((x) >> 29) & 0x1) | ||
| 115 | #define C_00000D_FORCE_TV_SCLK 0xDFFFFFFF | ||
| 116 | #define S_00000D_FORCE_SUBPIC(x) (((x) & 0x1) << 30) | ||
| 117 | #define G_00000D_FORCE_SUBPIC(x) (((x) >> 30) & 0x1) | ||
| 118 | #define C_00000D_FORCE_SUBPIC 0xBFFFFFFF | ||
| 119 | #define S_00000D_FORCE_OV0(x) (((x) & 0x1) << 31) | ||
| 120 | #define G_00000D_FORCE_OV0(x) (((x) >> 31) & 0x1) | ||
| 121 | #define C_00000D_FORCE_OV0 0x7FFFFFFF | ||
| 122 | |||
| 123 | #endif | ||
diff --git a/drivers/gpu/drm/radeon/rv350d.h b/drivers/gpu/drm/radeon/rv350d.h new file mode 100644 index 000000000000..c75c5ed9e654 --- /dev/null +++ b/drivers/gpu/drm/radeon/rv350d.h | |||
| @@ -0,0 +1,52 @@ | |||
| 1 | /* | ||
| 2 | * Copyright 2008 Advanced Micro Devices, Inc. | ||
| 3 | * Copyright 2008 Red Hat Inc. | ||
| 4 | * Copyright 2009 Jerome Glisse. | ||
| 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: Dave Airlie | ||
| 25 | * Alex Deucher | ||
| 26 | * Jerome Glisse | ||
| 27 | */ | ||
| 28 | #ifndef __RV350D_H__ | ||
| 29 | #define __RV350D_H__ | ||
| 30 | |||
| 31 | /* RV350, RV380 registers */ | ||
| 32 | /* #define R_00000D_SCLK_CNTL 0x00000D */ | ||
| 33 | #define S_00000D_FORCE_VAP(x) (((x) & 0x1) << 21) | ||
| 34 | #define G_00000D_FORCE_VAP(x) (((x) >> 21) & 0x1) | ||
| 35 | #define C_00000D_FORCE_VAP 0xFFDFFFFF | ||
| 36 | #define S_00000D_FORCE_SR(x) (((x) & 0x1) << 25) | ||
| 37 | #define G_00000D_FORCE_SR(x) (((x) >> 25) & 0x1) | ||
| 38 | #define C_00000D_FORCE_SR 0xFDFFFFFF | ||
| 39 | #define S_00000D_FORCE_PX(x) (((x) & 0x1) << 26) | ||
| 40 | #define G_00000D_FORCE_PX(x) (((x) >> 26) & 0x1) | ||
| 41 | #define C_00000D_FORCE_PX 0xFBFFFFFF | ||
| 42 | #define S_00000D_FORCE_TX(x) (((x) & 0x1) << 27) | ||
| 43 | #define G_00000D_FORCE_TX(x) (((x) >> 27) & 0x1) | ||
| 44 | #define C_00000D_FORCE_TX 0xF7FFFFFF | ||
| 45 | #define S_00000D_FORCE_US(x) (((x) & 0x1) << 28) | ||
| 46 | #define G_00000D_FORCE_US(x) (((x) >> 28) & 0x1) | ||
| 47 | #define C_00000D_FORCE_US 0xEFFFFFFF | ||
| 48 | #define S_00000D_FORCE_SU(x) (((x) & 0x1) << 30) | ||
| 49 | #define G_00000D_FORCE_SU(x) (((x) >> 30) & 0x1) | ||
| 50 | #define C_00000D_FORCE_SU 0xBFFFFFFF | ||
| 51 | |||
| 52 | #endif | ||
diff --git a/drivers/gpu/drm/radeon/rv515.c b/drivers/gpu/drm/radeon/rv515.c index e53b5ca7a253..41a34c23e6d8 100644 --- a/drivers/gpu/drm/radeon/rv515.c +++ b/drivers/gpu/drm/radeon/rv515.c | |||
| @@ -478,7 +478,7 @@ static int rv515_startup(struct radeon_device *rdev) | |||
| 478 | } | 478 | } |
| 479 | /* Enable IRQ */ | 479 | /* Enable IRQ */ |
| 480 | rdev->irq.sw_int = true; | 480 | rdev->irq.sw_int = true; |
| 481 | r100_irq_set(rdev); | 481 | rs600_irq_set(rdev); |
| 482 | /* 1M ring buffer */ | 482 | /* 1M ring buffer */ |
| 483 | r = r100_cp_init(rdev, 1024 * 1024); | 483 | r = r100_cp_init(rdev, 1024 * 1024); |
| 484 | if (r) { | 484 | if (r) { |
| @@ -520,7 +520,7 @@ int rv515_suspend(struct radeon_device *rdev) | |||
| 520 | { | 520 | { |
| 521 | r100_cp_disable(rdev); | 521 | r100_cp_disable(rdev); |
| 522 | r100_wb_disable(rdev); | 522 | r100_wb_disable(rdev); |
| 523 | r100_irq_disable(rdev); | 523 | rs600_irq_disable(rdev); |
| 524 | if (rdev->flags & RADEON_IS_PCIE) | 524 | if (rdev->flags & RADEON_IS_PCIE) |
| 525 | rv370_pcie_gart_disable(rdev); | 525 | rv370_pcie_gart_disable(rdev); |
| 526 | return 0; | 526 | return 0; |
| @@ -553,7 +553,6 @@ int rv515_init(struct radeon_device *rdev) | |||
| 553 | { | 553 | { |
| 554 | int r; | 554 | int r; |
| 555 | 555 | ||
| 556 | rdev->new_init_path = true; | ||
| 557 | /* Initialize scratch registers */ | 556 | /* Initialize scratch registers */ |
| 558 | radeon_scratch_init(rdev); | 557 | radeon_scratch_init(rdev); |
| 559 | /* Initialize surface registers */ | 558 | /* Initialize surface registers */ |
diff --git a/drivers/gpu/drm/radeon/rv770.c b/drivers/gpu/drm/radeon/rv770.c index e0b97d161397..595ac638039d 100644 --- a/drivers/gpu/drm/radeon/rv770.c +++ b/drivers/gpu/drm/radeon/rv770.c | |||
| @@ -75,7 +75,7 @@ int rv770_pcie_gart_enable(struct radeon_device *rdev) | |||
| 75 | WREG32(MC_VM_MB_L1_TLB2_CNTL, tmp); | 75 | WREG32(MC_VM_MB_L1_TLB2_CNTL, tmp); |
| 76 | WREG32(MC_VM_MB_L1_TLB3_CNTL, tmp); | 76 | WREG32(MC_VM_MB_L1_TLB3_CNTL, tmp); |
| 77 | WREG32(VM_CONTEXT0_PAGE_TABLE_START_ADDR, rdev->mc.gtt_start >> 12); | 77 | WREG32(VM_CONTEXT0_PAGE_TABLE_START_ADDR, rdev->mc.gtt_start >> 12); |
| 78 | WREG32(VM_CONTEXT0_PAGE_TABLE_END_ADDR, (rdev->mc.gtt_end - 1) >> 12); | 78 | WREG32(VM_CONTEXT0_PAGE_TABLE_END_ADDR, rdev->mc.gtt_end >> 12); |
| 79 | WREG32(VM_CONTEXT0_PAGE_TABLE_BASE_ADDR, rdev->gart.table_addr >> 12); | 79 | WREG32(VM_CONTEXT0_PAGE_TABLE_BASE_ADDR, rdev->gart.table_addr >> 12); |
| 80 | WREG32(VM_CONTEXT0_CNTL, ENABLE_CONTEXT | PAGE_TABLE_DEPTH(0) | | 80 | WREG32(VM_CONTEXT0_CNTL, ENABLE_CONTEXT | PAGE_TABLE_DEPTH(0) | |
| 81 | RANGE_PROTECTION_FAULT_ENABLE_DEFAULT); | 81 | RANGE_PROTECTION_FAULT_ENABLE_DEFAULT); |
| @@ -126,17 +126,36 @@ void rv770_pcie_gart_fini(struct radeon_device *rdev) | |||
| 126 | } | 126 | } |
| 127 | 127 | ||
| 128 | 128 | ||
| 129 | /* | 129 | void rv770_agp_enable(struct radeon_device *rdev) |
| 130 | * MC | ||
| 131 | */ | ||
| 132 | static void rv770_mc_resume(struct radeon_device *rdev) | ||
| 133 | { | 130 | { |
| 134 | u32 d1vga_control, d2vga_control; | 131 | u32 tmp; |
| 135 | u32 vga_render_control, vga_hdp_control; | 132 | int i; |
| 136 | u32 d1crtc_control, d2crtc_control; | 133 | |
| 137 | u32 new_d1grph_primary, new_d1grph_secondary; | 134 | /* Setup L2 cache */ |
| 138 | u32 new_d2grph_primary, new_d2grph_secondary; | 135 | WREG32(VM_L2_CNTL, ENABLE_L2_CACHE | ENABLE_L2_FRAGMENT_PROCESSING | |
| 139 | u64 old_vram_start; | 136 | ENABLE_L2_PTE_CACHE_LRU_UPDATE_BY_WRITE | |
| 137 | EFFECTIVE_L2_QUEUE_SIZE(7)); | ||
| 138 | WREG32(VM_L2_CNTL2, 0); | ||
| 139 | WREG32(VM_L2_CNTL3, BANK_SELECT(0) | CACHE_UPDATE_MODE(2)); | ||
| 140 | /* Setup TLB control */ | ||
| 141 | tmp = ENABLE_L1_TLB | ENABLE_L1_FRAGMENT_PROCESSING | | ||
| 142 | SYSTEM_ACCESS_MODE_NOT_IN_SYS | | ||
| 143 | SYSTEM_APERTURE_UNMAPPED_ACCESS_PASS_THRU | | ||
| 144 | EFFECTIVE_L1_TLB_SIZE(5) | EFFECTIVE_L1_QUEUE_SIZE(5); | ||
| 145 | WREG32(MC_VM_MD_L1_TLB0_CNTL, tmp); | ||
| 146 | WREG32(MC_VM_MD_L1_TLB1_CNTL, tmp); | ||
| 147 | WREG32(MC_VM_MD_L1_TLB2_CNTL, tmp); | ||
| 148 | WREG32(MC_VM_MB_L1_TLB0_CNTL, tmp); | ||
| 149 | WREG32(MC_VM_MB_L1_TLB1_CNTL, tmp); | ||
| 150 | WREG32(MC_VM_MB_L1_TLB2_CNTL, tmp); | ||
| 151 | WREG32(MC_VM_MB_L1_TLB3_CNTL, tmp); | ||
| 152 | for (i = 0; i < 7; i++) | ||
| 153 | WREG32(VM_CONTEXT0_CNTL + (i * 4), 0); | ||
| 154 | } | ||
| 155 | |||
| 156 | static void rv770_mc_program(struct radeon_device *rdev) | ||
| 157 | { | ||
| 158 | struct rv515_mc_save save; | ||
| 140 | u32 tmp; | 159 | u32 tmp; |
| 141 | int i, j; | 160 | int i, j; |
| 142 | 161 | ||
| @@ -150,53 +169,42 @@ static void rv770_mc_resume(struct radeon_device *rdev) | |||
| 150 | } | 169 | } |
| 151 | WREG32(HDP_REG_COHERENCY_FLUSH_CNTL, 0); | 170 | WREG32(HDP_REG_COHERENCY_FLUSH_CNTL, 0); |
| 152 | 171 | ||
| 153 | d1vga_control = RREG32(D1VGA_CONTROL); | 172 | rv515_mc_stop(rdev, &save); |
| 154 | d2vga_control = RREG32(D2VGA_CONTROL); | ||
| 155 | vga_render_control = RREG32(VGA_RENDER_CONTROL); | ||
| 156 | vga_hdp_control = RREG32(VGA_HDP_CONTROL); | ||
| 157 | d1crtc_control = RREG32(D1CRTC_CONTROL); | ||
| 158 | d2crtc_control = RREG32(D2CRTC_CONTROL); | ||
| 159 | old_vram_start = (u64)(RREG32(MC_VM_FB_LOCATION) & 0xFFFF) << 24; | ||
| 160 | new_d1grph_primary = RREG32(D1GRPH_PRIMARY_SURFACE_ADDRESS); | ||
| 161 | new_d1grph_secondary = RREG32(D1GRPH_SECONDARY_SURFACE_ADDRESS); | ||
| 162 | new_d1grph_primary += rdev->mc.vram_start - old_vram_start; | ||
| 163 | new_d1grph_secondary += rdev->mc.vram_start - old_vram_start; | ||
| 164 | new_d2grph_primary = RREG32(D2GRPH_PRIMARY_SURFACE_ADDRESS); | ||
| 165 | new_d2grph_secondary = RREG32(D2GRPH_SECONDARY_SURFACE_ADDRESS); | ||
| 166 | new_d2grph_primary += rdev->mc.vram_start - old_vram_start; | ||
| 167 | new_d2grph_secondary += rdev->mc.vram_start - old_vram_start; | ||
| 168 | |||
| 169 | /* Stop all video */ | ||
| 170 | WREG32(D1VGA_CONTROL, 0); | ||
| 171 | WREG32(D2VGA_CONTROL, 0); | ||
| 172 | WREG32(VGA_RENDER_CONTROL, 0); | ||
| 173 | WREG32(D1CRTC_UPDATE_LOCK, 1); | ||
| 174 | WREG32(D2CRTC_UPDATE_LOCK, 1); | ||
| 175 | WREG32(D1CRTC_CONTROL, 0); | ||
| 176 | WREG32(D2CRTC_CONTROL, 0); | ||
| 177 | WREG32(D1CRTC_UPDATE_LOCK, 0); | ||
| 178 | WREG32(D2CRTC_UPDATE_LOCK, 0); | ||
| 179 | |||
| 180 | mdelay(1); | ||
| 181 | if (r600_mc_wait_for_idle(rdev)) { | 173 | if (r600_mc_wait_for_idle(rdev)) { |
| 182 | printk(KERN_WARNING "[drm] MC not idle !\n"); | 174 | dev_warn(rdev->dev, "Wait for MC idle timedout !\n"); |
| 183 | } | 175 | } |
| 184 | |||
| 185 | /* Lockout access through VGA aperture*/ | 176 | /* Lockout access through VGA aperture*/ |
| 186 | WREG32(VGA_HDP_CONTROL, VGA_MEMORY_DISABLE); | 177 | WREG32(VGA_HDP_CONTROL, VGA_MEMORY_DISABLE); |
| 187 | |||
| 188 | /* Update configuration */ | 178 | /* Update configuration */ |
| 189 | WREG32(MC_VM_SYSTEM_APERTURE_LOW_ADDR, rdev->mc.vram_start >> 12); | 179 | if (rdev->flags & RADEON_IS_AGP) { |
| 190 | WREG32(MC_VM_SYSTEM_APERTURE_HIGH_ADDR, (rdev->mc.vram_end - 1) >> 12); | 180 | if (rdev->mc.vram_start < rdev->mc.gtt_start) { |
| 181 | /* VRAM before AGP */ | ||
| 182 | WREG32(MC_VM_SYSTEM_APERTURE_LOW_ADDR, | ||
| 183 | rdev->mc.vram_start >> 12); | ||
| 184 | WREG32(MC_VM_SYSTEM_APERTURE_HIGH_ADDR, | ||
| 185 | rdev->mc.gtt_end >> 12); | ||
| 186 | } else { | ||
| 187 | /* VRAM after AGP */ | ||
| 188 | WREG32(MC_VM_SYSTEM_APERTURE_LOW_ADDR, | ||
| 189 | rdev->mc.gtt_start >> 12); | ||
| 190 | WREG32(MC_VM_SYSTEM_APERTURE_HIGH_ADDR, | ||
| 191 | rdev->mc.vram_end >> 12); | ||
| 192 | } | ||
| 193 | } else { | ||
| 194 | WREG32(MC_VM_SYSTEM_APERTURE_LOW_ADDR, | ||
| 195 | rdev->mc.vram_start >> 12); | ||
| 196 | WREG32(MC_VM_SYSTEM_APERTURE_HIGH_ADDR, | ||
| 197 | rdev->mc.vram_end >> 12); | ||
| 198 | } | ||
| 191 | WREG32(MC_VM_SYSTEM_APERTURE_DEFAULT_ADDR, 0); | 199 | WREG32(MC_VM_SYSTEM_APERTURE_DEFAULT_ADDR, 0); |
| 192 | tmp = (((rdev->mc.vram_end - 1) >> 24) & 0xFFFF) << 16; | 200 | tmp = ((rdev->mc.vram_end >> 24) & 0xFFFF) << 16; |
| 193 | tmp |= ((rdev->mc.vram_start >> 24) & 0xFFFF); | 201 | tmp |= ((rdev->mc.vram_start >> 24) & 0xFFFF); |
| 194 | WREG32(MC_VM_FB_LOCATION, tmp); | 202 | WREG32(MC_VM_FB_LOCATION, tmp); |
| 195 | WREG32(HDP_NONSURFACE_BASE, (rdev->mc.vram_start >> 8)); | 203 | WREG32(HDP_NONSURFACE_BASE, (rdev->mc.vram_start >> 8)); |
| 196 | WREG32(HDP_NONSURFACE_INFO, (2 << 7)); | 204 | WREG32(HDP_NONSURFACE_INFO, (2 << 7)); |
| 197 | WREG32(HDP_NONSURFACE_SIZE, (rdev->mc.mc_vram_size - 1) | 0x3FF); | 205 | WREG32(HDP_NONSURFACE_SIZE, (rdev->mc.mc_vram_size - 1) | 0x3FF); |
| 198 | if (rdev->flags & RADEON_IS_AGP) { | 206 | if (rdev->flags & RADEON_IS_AGP) { |
| 199 | WREG32(MC_VM_AGP_TOP, (rdev->mc.gtt_end - 1) >> 16); | 207 | WREG32(MC_VM_AGP_TOP, rdev->mc.gtt_end >> 16); |
| 200 | WREG32(MC_VM_AGP_BOT, rdev->mc.gtt_start >> 16); | 208 | WREG32(MC_VM_AGP_BOT, rdev->mc.gtt_start >> 16); |
| 201 | WREG32(MC_VM_AGP_BASE, rdev->mc.agp_base >> 22); | 209 | WREG32(MC_VM_AGP_BASE, rdev->mc.agp_base >> 22); |
| 202 | } else { | 210 | } else { |
| @@ -204,31 +212,10 @@ static void rv770_mc_resume(struct radeon_device *rdev) | |||
| 204 | WREG32(MC_VM_AGP_TOP, 0x0FFFFFFF); | 212 | WREG32(MC_VM_AGP_TOP, 0x0FFFFFFF); |
| 205 | WREG32(MC_VM_AGP_BOT, 0x0FFFFFFF); | 213 | WREG32(MC_VM_AGP_BOT, 0x0FFFFFFF); |
| 206 | } | 214 | } |
| 207 | WREG32(D1GRPH_PRIMARY_SURFACE_ADDRESS, new_d1grph_primary); | ||
| 208 | WREG32(D1GRPH_SECONDARY_SURFACE_ADDRESS, new_d1grph_secondary); | ||
| 209 | WREG32(D2GRPH_PRIMARY_SURFACE_ADDRESS, new_d2grph_primary); | ||
| 210 | WREG32(D2GRPH_SECONDARY_SURFACE_ADDRESS, new_d2grph_secondary); | ||
| 211 | WREG32(VGA_MEMORY_BASE_ADDRESS, rdev->mc.vram_start); | ||
| 212 | |||
| 213 | /* Unlock host access */ | ||
| 214 | WREG32(VGA_HDP_CONTROL, vga_hdp_control); | ||
| 215 | |||
| 216 | mdelay(1); | ||
| 217 | if (r600_mc_wait_for_idle(rdev)) { | 215 | if (r600_mc_wait_for_idle(rdev)) { |
| 218 | printk(KERN_WARNING "[drm] MC not idle !\n"); | 216 | dev_warn(rdev->dev, "Wait for MC idle timedout !\n"); |
| 219 | } | 217 | } |
| 220 | 218 | rv515_mc_resume(rdev, &save); | |
| 221 | /* Restore video state */ | ||
| 222 | WREG32(D1CRTC_UPDATE_LOCK, 1); | ||
| 223 | WREG32(D2CRTC_UPDATE_LOCK, 1); | ||
| 224 | WREG32(D1CRTC_CONTROL, d1crtc_control); | ||
| 225 | WREG32(D2CRTC_CONTROL, d2crtc_control); | ||
| 226 | WREG32(D1CRTC_UPDATE_LOCK, 0); | ||
| 227 | WREG32(D2CRTC_UPDATE_LOCK, 0); | ||
| 228 | WREG32(D1VGA_CONTROL, d1vga_control); | ||
| 229 | WREG32(D2VGA_CONTROL, d2vga_control); | ||
| 230 | WREG32(VGA_RENDER_CONTROL, vga_render_control); | ||
| 231 | |||
| 232 | /* we need to own VRAM, so turn off the VGA renderer here | 219 | /* we need to own VRAM, so turn off the VGA renderer here |
| 233 | * to stop it overwriting our objects */ | 220 | * to stop it overwriting our objects */ |
| 234 | rv515_vga_render_disable(rdev); | 221 | rv515_vga_render_disable(rdev); |
| @@ -840,9 +827,9 @@ int rv770_mc_init(struct radeon_device *rdev) | |||
| 840 | rdev->mc.gtt_size = radeon_gart_size * 1024 * 1024; | 827 | rdev->mc.gtt_size = radeon_gart_size * 1024 * 1024; |
| 841 | } | 828 | } |
| 842 | rdev->mc.vram_start = rdev->mc.vram_location; | 829 | rdev->mc.vram_start = rdev->mc.vram_location; |
| 843 | rdev->mc.vram_end = rdev->mc.vram_location + rdev->mc.mc_vram_size; | 830 | rdev->mc.vram_end = rdev->mc.vram_location + rdev->mc.mc_vram_size - 1; |
| 844 | rdev->mc.gtt_start = rdev->mc.gtt_location; | 831 | rdev->mc.gtt_start = rdev->mc.gtt_location; |
| 845 | rdev->mc.gtt_end = rdev->mc.gtt_location + rdev->mc.gtt_size; | 832 | rdev->mc.gtt_end = rdev->mc.gtt_location + rdev->mc.gtt_size - 1; |
| 846 | /* FIXME: we should enforce default clock in case GPU is not in | 833 | /* FIXME: we should enforce default clock in case GPU is not in |
| 847 | * default setup | 834 | * default setup |
| 848 | */ | 835 | */ |
| @@ -861,11 +848,14 @@ static int rv770_startup(struct radeon_device *rdev) | |||
| 861 | { | 848 | { |
| 862 | int r; | 849 | int r; |
| 863 | 850 | ||
| 864 | radeon_gpu_reset(rdev); | 851 | rv770_mc_program(rdev); |
| 865 | rv770_mc_resume(rdev); | 852 | if (rdev->flags & RADEON_IS_AGP) { |
| 866 | r = rv770_pcie_gart_enable(rdev); | 853 | rv770_agp_enable(rdev); |
| 867 | if (r) | 854 | } else { |
| 868 | return r; | 855 | r = rv770_pcie_gart_enable(rdev); |
| 856 | if (r) | ||
| 857 | return r; | ||
| 858 | } | ||
| 869 | rv770_gpu_init(rdev); | 859 | rv770_gpu_init(rdev); |
| 870 | 860 | ||
| 871 | r = radeon_object_pin(rdev->r600_blit.shader_obj, RADEON_GEM_DOMAIN_VRAM, | 861 | r = radeon_object_pin(rdev->r600_blit.shader_obj, RADEON_GEM_DOMAIN_VRAM, |
| @@ -884,9 +874,8 @@ static int rv770_startup(struct radeon_device *rdev) | |||
| 884 | r = r600_cp_resume(rdev); | 874 | r = r600_cp_resume(rdev); |
| 885 | if (r) | 875 | if (r) |
| 886 | return r; | 876 | return r; |
| 887 | r = r600_wb_init(rdev); | 877 | /* write back buffer are not vital so don't worry about failure */ |
| 888 | if (r) | 878 | r600_wb_enable(rdev); |
| 889 | return r; | ||
| 890 | return 0; | 879 | return 0; |
| 891 | } | 880 | } |
| 892 | 881 | ||
| @@ -894,15 +883,12 @@ int rv770_resume(struct radeon_device *rdev) | |||
| 894 | { | 883 | { |
| 895 | int r; | 884 | int r; |
| 896 | 885 | ||
| 897 | if (radeon_gpu_reset(rdev)) { | 886 | /* Do not reset GPU before posting, on rv770 hw unlike on r500 hw, |
| 898 | /* FIXME: what do we want to do here ? */ | 887 | * posting will perform necessary task to bring back GPU into good |
| 899 | } | 888 | * shape. |
| 889 | */ | ||
| 900 | /* post card */ | 890 | /* post card */ |
| 901 | if (rdev->is_atom_bios) { | 891 | atom_asic_init(rdev->mode_info.atom_context); |
| 902 | atom_asic_init(rdev->mode_info.atom_context); | ||
| 903 | } else { | ||
| 904 | radeon_combios_asic_init(rdev->ddev); | ||
| 905 | } | ||
| 906 | /* Initialize clocks */ | 892 | /* Initialize clocks */ |
| 907 | r = radeon_clocks_init(rdev); | 893 | r = radeon_clocks_init(rdev); |
| 908 | if (r) { | 894 | if (r) { |
| @@ -915,7 +901,7 @@ int rv770_resume(struct radeon_device *rdev) | |||
| 915 | return r; | 901 | return r; |
| 916 | } | 902 | } |
| 917 | 903 | ||
| 918 | r = radeon_ib_test(rdev); | 904 | r = r600_ib_test(rdev); |
| 919 | if (r) { | 905 | if (r) { |
| 920 | DRM_ERROR("radeon: failled testing IB (%d).\n", r); | 906 | DRM_ERROR("radeon: failled testing IB (%d).\n", r); |
| 921 | return r; | 907 | return r; |
| @@ -929,8 +915,8 @@ int rv770_suspend(struct radeon_device *rdev) | |||
| 929 | /* FIXME: we should wait for ring to be empty */ | 915 | /* FIXME: we should wait for ring to be empty */ |
| 930 | r700_cp_stop(rdev); | 916 | r700_cp_stop(rdev); |
| 931 | rdev->cp.ready = false; | 917 | rdev->cp.ready = false; |
| 918 | r600_wb_disable(rdev); | ||
| 932 | rv770_pcie_gart_disable(rdev); | 919 | rv770_pcie_gart_disable(rdev); |
| 933 | |||
| 934 | /* unpin shaders bo */ | 920 | /* unpin shaders bo */ |
| 935 | radeon_object_unpin(rdev->r600_blit.shader_obj); | 921 | radeon_object_unpin(rdev->r600_blit.shader_obj); |
| 936 | return 0; | 922 | return 0; |
| @@ -946,7 +932,6 @@ int rv770_init(struct radeon_device *rdev) | |||
| 946 | { | 932 | { |
| 947 | int r; | 933 | int r; |
| 948 | 934 | ||
| 949 | rdev->new_init_path = true; | ||
| 950 | r = radeon_dummy_page_init(rdev); | 935 | r = radeon_dummy_page_init(rdev); |
| 951 | if (r) | 936 | if (r) |
| 952 | return r; | 937 | return r; |
| @@ -960,8 +945,10 @@ int rv770_init(struct radeon_device *rdev) | |||
| 960 | return -EINVAL; | 945 | return -EINVAL; |
| 961 | } | 946 | } |
| 962 | /* Must be an ATOMBIOS */ | 947 | /* Must be an ATOMBIOS */ |
| 963 | if (!rdev->is_atom_bios) | 948 | if (!rdev->is_atom_bios) { |
| 949 | dev_err(rdev->dev, "Expecting atombios for R600 GPU\n"); | ||
| 964 | return -EINVAL; | 950 | return -EINVAL; |
| 951 | } | ||
| 965 | r = radeon_atombios_init(rdev); | 952 | r = radeon_atombios_init(rdev); |
| 966 | if (r) | 953 | if (r) |
| 967 | return r; | 954 | return r; |
| @@ -983,15 +970,8 @@ int rv770_init(struct radeon_device *rdev) | |||
| 983 | if (r) | 970 | if (r) |
| 984 | return r; | 971 | return r; |
| 985 | r = rv770_mc_init(rdev); | 972 | r = rv770_mc_init(rdev); |
| 986 | if (r) { | 973 | if (r) |
| 987 | if (rdev->flags & RADEON_IS_AGP) { | ||
| 988 | /* Retry with disabling AGP */ | ||
| 989 | rv770_fini(rdev); | ||
| 990 | rdev->flags &= ~RADEON_IS_AGP; | ||
| 991 | return rv770_init(rdev); | ||
| 992 | } | ||
| 993 | return r; | 974 | return r; |
| 994 | } | ||
| 995 | /* Memory manager */ | 975 | /* Memory manager */ |
| 996 | r = radeon_object_init(rdev); | 976 | r = radeon_object_init(rdev); |
| 997 | if (r) | 977 | if (r) |
| @@ -1020,12 +1000,10 @@ int rv770_init(struct radeon_device *rdev) | |||
| 1020 | 1000 | ||
| 1021 | r = rv770_startup(rdev); | 1001 | r = rv770_startup(rdev); |
| 1022 | if (r) { | 1002 | if (r) { |
| 1023 | if (rdev->flags & RADEON_IS_AGP) { | 1003 | rv770_suspend(rdev); |
| 1024 | /* Retry with disabling AGP */ | 1004 | r600_wb_fini(rdev); |
| 1025 | rv770_fini(rdev); | 1005 | radeon_ring_fini(rdev); |
| 1026 | rdev->flags &= ~RADEON_IS_AGP; | 1006 | rv770_pcie_gart_fini(rdev); |
| 1027 | return rv770_init(rdev); | ||
| 1028 | } | ||
| 1029 | rdev->accel_working = false; | 1007 | rdev->accel_working = false; |
| 1030 | } | 1008 | } |
| 1031 | if (rdev->accel_working) { | 1009 | if (rdev->accel_working) { |
| @@ -1034,7 +1012,7 @@ int rv770_init(struct radeon_device *rdev) | |||
| 1034 | DRM_ERROR("radeon: failled initializing IB pool (%d).\n", r); | 1012 | DRM_ERROR("radeon: failled initializing IB pool (%d).\n", r); |
| 1035 | rdev->accel_working = false; | 1013 | rdev->accel_working = false; |
| 1036 | } | 1014 | } |
| 1037 | r = radeon_ib_test(rdev); | 1015 | r = r600_ib_test(rdev); |
| 1038 | if (r) { | 1016 | if (r) { |
| 1039 | DRM_ERROR("radeon: failled testing IB (%d).\n", r); | 1017 | DRM_ERROR("radeon: failled testing IB (%d).\n", r); |
| 1040 | rdev->accel_working = false; | 1018 | rdev->accel_working = false; |
| @@ -1049,20 +1027,15 @@ void rv770_fini(struct radeon_device *rdev) | |||
| 1049 | 1027 | ||
| 1050 | r600_blit_fini(rdev); | 1028 | r600_blit_fini(rdev); |
| 1051 | radeon_ring_fini(rdev); | 1029 | radeon_ring_fini(rdev); |
| 1030 | r600_wb_fini(rdev); | ||
| 1052 | rv770_pcie_gart_fini(rdev); | 1031 | rv770_pcie_gart_fini(rdev); |
| 1053 | radeon_gem_fini(rdev); | 1032 | radeon_gem_fini(rdev); |
| 1054 | radeon_fence_driver_fini(rdev); | 1033 | radeon_fence_driver_fini(rdev); |
| 1055 | radeon_clocks_fini(rdev); | 1034 | radeon_clocks_fini(rdev); |
| 1056 | #if __OS_HAS_AGP | ||
| 1057 | if (rdev->flags & RADEON_IS_AGP) | 1035 | if (rdev->flags & RADEON_IS_AGP) |
| 1058 | radeon_agp_fini(rdev); | 1036 | radeon_agp_fini(rdev); |
| 1059 | #endif | ||
| 1060 | radeon_object_fini(rdev); | 1037 | radeon_object_fini(rdev); |
| 1061 | if (rdev->is_atom_bios) { | 1038 | radeon_atombios_fini(rdev); |
| 1062 | radeon_atombios_fini(rdev); | ||
| 1063 | } else { | ||
| 1064 | radeon_combios_fini(rdev); | ||
| 1065 | } | ||
| 1066 | kfree(rdev->bios); | 1039 | kfree(rdev->bios); |
| 1067 | rdev->bios = NULL; | 1040 | rdev->bios = NULL; |
| 1068 | radeon_dummy_page_fini(rdev); | 1041 | radeon_dummy_page_fini(rdev); |
diff --git a/drivers/gpu/drm/ttm/ttm_global.c b/drivers/gpu/drm/ttm/ttm_global.c index 541744d00d3e..b17007178a36 100644 --- a/drivers/gpu/drm/ttm/ttm_global.c +++ b/drivers/gpu/drm/ttm/ttm_global.c | |||
| @@ -82,8 +82,8 @@ int ttm_global_item_ref(struct ttm_global_reference *ref) | |||
| 82 | if (unlikely(ret != 0)) | 82 | if (unlikely(ret != 0)) |
| 83 | goto out_err; | 83 | goto out_err; |
| 84 | 84 | ||
| 85 | ++item->refcount; | ||
| 86 | } | 85 | } |
| 86 | ++item->refcount; | ||
| 87 | ref->object = item->object; | 87 | ref->object = item->object; |
| 88 | object = item->object; | 88 | object = item->object; |
| 89 | mutex_unlock(&item->mutex); | 89 | mutex_unlock(&item->mutex); |
diff --git a/include/drm/drm_crtc_helper.h b/include/drm/drm_crtc_helper.h index ef47dfd8e5e9..b29e20168b5f 100644 --- a/include/drm/drm_crtc_helper.h +++ b/include/drm/drm_crtc_helper.h | |||
| @@ -61,6 +61,9 @@ struct drm_crtc_helper_funcs { | |||
| 61 | /* Move the crtc on the current fb to the given position *optional* */ | 61 | /* Move the crtc on the current fb to the given position *optional* */ |
| 62 | int (*mode_set_base)(struct drm_crtc *crtc, int x, int y, | 62 | int (*mode_set_base)(struct drm_crtc *crtc, int x, int y, |
| 63 | struct drm_framebuffer *old_fb); | 63 | struct drm_framebuffer *old_fb); |
| 64 | |||
| 65 | /* reload the current crtc LUT */ | ||
| 66 | void (*load_lut)(struct drm_crtc *crtc); | ||
| 64 | }; | 67 | }; |
| 65 | 68 | ||
| 66 | struct drm_encoder_helper_funcs { | 69 | struct drm_encoder_helper_funcs { |
diff --git a/include/drm/drm_fb_helper.h b/include/drm/drm_fb_helper.h index 4aa5740ce59f..58c892a2cbfa 100644 --- a/include/drm/drm_fb_helper.h +++ b/include/drm/drm_fb_helper.h | |||
| @@ -39,6 +39,8 @@ struct drm_fb_helper_crtc { | |||
| 39 | struct drm_fb_helper_funcs { | 39 | struct drm_fb_helper_funcs { |
| 40 | void (*gamma_set)(struct drm_crtc *crtc, u16 red, u16 green, | 40 | void (*gamma_set)(struct drm_crtc *crtc, u16 red, u16 green, |
| 41 | u16 blue, int regno); | 41 | u16 blue, int regno); |
| 42 | void (*gamma_get)(struct drm_crtc *crtc, u16 *red, u16 *green, | ||
| 43 | u16 *blue, int regno); | ||
| 42 | }; | 44 | }; |
| 43 | 45 | ||
| 44 | /* mode specified on the command line */ | 46 | /* mode specified on the command line */ |
| @@ -71,6 +73,7 @@ struct drm_fb_helper { | |||
| 71 | }; | 73 | }; |
| 72 | 74 | ||
| 73 | int drm_fb_helper_single_fb_probe(struct drm_device *dev, | 75 | int drm_fb_helper_single_fb_probe(struct drm_device *dev, |
| 76 | int preferred_bpp, | ||
| 74 | int (*fb_create)(struct drm_device *dev, | 77 | int (*fb_create)(struct drm_device *dev, |
| 75 | uint32_t fb_width, | 78 | uint32_t fb_width, |
| 76 | uint32_t fb_height, | 79 | uint32_t fb_height, |
| @@ -98,9 +101,11 @@ int drm_fb_helper_setcolreg(unsigned regno, | |||
| 98 | void drm_fb_helper_restore(void); | 101 | void drm_fb_helper_restore(void); |
| 99 | void drm_fb_helper_fill_var(struct fb_info *info, struct drm_framebuffer *fb, | 102 | void drm_fb_helper_fill_var(struct fb_info *info, struct drm_framebuffer *fb, |
| 100 | uint32_t fb_width, uint32_t fb_height); | 103 | uint32_t fb_width, uint32_t fb_height); |
| 101 | void drm_fb_helper_fill_fix(struct fb_info *info, uint32_t pitch); | 104 | void drm_fb_helper_fill_fix(struct fb_info *info, uint32_t pitch, |
| 105 | uint32_t depth); | ||
| 102 | 106 | ||
| 103 | int drm_fb_helper_add_connector(struct drm_connector *connector); | 107 | int drm_fb_helper_add_connector(struct drm_connector *connector); |
| 104 | int drm_fb_helper_parse_command_line(struct drm_device *dev); | 108 | int drm_fb_helper_parse_command_line(struct drm_device *dev); |
| 109 | int drm_fb_helper_setcmap(struct fb_cmap *cmap, struct fb_info *info); | ||
| 105 | 110 | ||
| 106 | #endif | 111 | #endif |
diff --git a/include/drm/drm_pciids.h b/include/drm/drm_pciids.h index 3f6e545609be..e6f3b120f51a 100644 --- a/include/drm/drm_pciids.h +++ b/include/drm/drm_pciids.h | |||
| @@ -80,7 +80,7 @@ | |||
| 80 | {0x1002, 0x5158, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV200}, \ | 80 | {0x1002, 0x5158, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV200}, \ |
| 81 | {0x1002, 0x5159, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV100}, \ | 81 | {0x1002, 0x5159, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV100}, \ |
| 82 | {0x1002, 0x515A, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV100}, \ | 82 | {0x1002, 0x515A, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV100}, \ |
| 83 | {0x1002, 0x515E, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV100}, \ | 83 | {0x1002, 0x515E, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV100|RADEON_SINGLE_CRTC}, \ |
| 84 | {0x1002, 0x5460, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV380|RADEON_IS_MOBILITY}, \ | 84 | {0x1002, 0x5460, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV380|RADEON_IS_MOBILITY}, \ |
| 85 | {0x1002, 0x5462, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV380|RADEON_IS_MOBILITY}, \ | 85 | {0x1002, 0x5462, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV380|RADEON_IS_MOBILITY}, \ |
| 86 | {0x1002, 0x5464, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV380|RADEON_IS_MOBILITY}, \ | 86 | {0x1002, 0x5464, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV380|RADEON_IS_MOBILITY}, \ |
| @@ -113,7 +113,7 @@ | |||
| 113 | {0x1002, 0x5962, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV280}, \ | 113 | {0x1002, 0x5962, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV280}, \ |
| 114 | {0x1002, 0x5964, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV280}, \ | 114 | {0x1002, 0x5964, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV280}, \ |
| 115 | {0x1002, 0x5965, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV280}, \ | 115 | {0x1002, 0x5965, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV280}, \ |
| 116 | {0x1002, 0x5969, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV100}, \ | 116 | {0x1002, 0x5969, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV100|RADEON_SINGLE_CRTC}, \ |
| 117 | {0x1002, 0x5a41, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RS400|RADEON_IS_IGP|RADEON_IS_IGPGART}, \ | 117 | {0x1002, 0x5a41, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RS400|RADEON_IS_IGP|RADEON_IS_IGPGART}, \ |
| 118 | {0x1002, 0x5a42, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RS400|RADEON_IS_IGP|RADEON_IS_MOBILITY|RADEON_IS_IGPGART}, \ | 118 | {0x1002, 0x5a42, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RS400|RADEON_IS_IGP|RADEON_IS_MOBILITY|RADEON_IS_IGPGART}, \ |
| 119 | {0x1002, 0x5a61, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RS400|RADEON_IS_IGP|RADEON_IS_IGPGART}, \ | 119 | {0x1002, 0x5a61, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RS400|RADEON_IS_IGP|RADEON_IS_IGPGART}, \ |
