Subversion Repositories Kolibri OS

Rev

Rev 3243 | Rev 4104 | Go to most recent revision | Blame | Compare with Previous | Last modification | View Log | Download | RSS feed

  1. /*
  2.  * Intel GTT (Graphics Translation Table) routines
  3.  *
  4.  * Caveat: This driver implements the linux agp interface, but this is far from
  5.  * a agp driver! GTT support ended up here for purely historical reasons: The
  6.  * old userspace intel graphics drivers needed an interface to map memory into
  7.  * the GTT. And the drm provides a default interface for graphic devices sitting
  8.  * on an agp port. So it made sense to fake the GTT support as an agp port to
  9.  * avoid having to create a new api.
  10.  *
  11.  * With gem this does not make much sense anymore, just needlessly complicates
  12.  * the code. But as long as the old graphics stack is still support, it's stuck
  13.  * here.
  14.  *
  15.  * /fairy-tale-mode off
  16.  */
  17.  
  18. #include <syscall.h>
  19.  
  20. #include <linux/module.h>
  21. #include <errno-base.h>
  22. #include <linux/pci.h>
  23. #include <linux/kernel.h>
  24. #include <linux/export.h>
  25. #include <linux/scatterlist.h>
  26.  
  27. //#include <linux/pagemap.h>
  28. //#include <linux/agp_backend.h>
  29. //#include <asm/smp.h>
  30. #include <linux/spinlock.h>
  31. #include "agp.h"
  32. #include "intel-agp.h"
  33. #include <drm/intel-gtt.h>
  34.  
  35.  
  36. struct pci_dev *
  37. pci_get_device(unsigned int vendor, unsigned int device, struct pci_dev *from);
  38.  
  39.  
  40. #define PCI_VENDOR_ID_INTEL             0x8086
  41. #define PCI_DEVICE_ID_INTEL_82830_HB    0x3575
  42. #define PCI_DEVICE_ID_INTEL_82845G_HB   0x2560
  43. #define PCI_DEVICE_ID_INTEL_82915G_IG   0x2582
  44. #define PCI_DEVICE_ID_INTEL_82915GM_IG  0x2592
  45. #define PCI_DEVICE_ID_INTEL_82945G_IG   0x2772
  46. #define PCI_DEVICE_ID_INTEL_82945GM_IG  0x27A2
  47.  
  48.  
  49. #define AGP_NORMAL_MEMORY 0
  50.  
  51. #define AGP_USER_TYPES (1 << 16)
  52. #define AGP_USER_MEMORY (AGP_USER_TYPES)
  53. #define AGP_USER_CACHED_MEMORY (AGP_USER_TYPES + 1)
  54.  
  55.  
  56.  
  57. /*
  58.  * If we have Intel graphics, we're not going to have anything other than
  59.  * an Intel IOMMU. So make the correct use of the PCI DMA API contingent
  60.  * on the Intel IOMMU support (CONFIG_INTEL_IOMMU).
  61.  * Only newer chipsets need to bother with this, of course.
  62.  */
  63. #ifdef CONFIG_INTEL_IOMMU
  64. #define USE_PCI_DMA_API 1
  65. #else
  66. #define USE_PCI_DMA_API 0
  67. #endif
  68.  
  69. struct intel_gtt_driver {
  70.     unsigned int gen : 8;
  71.     unsigned int is_g33 : 1;
  72.     unsigned int is_pineview : 1;
  73.     unsigned int is_ironlake : 1;
  74.     unsigned int has_pgtbl_enable : 1;
  75.     unsigned int dma_mask_size : 8;
  76.     /* Chipset specific GTT setup */
  77.     int (*setup)(void);
  78.     /* This should undo anything done in ->setup() save the unmapping
  79.      * of the mmio register file, that's done in the generic code. */
  80.     void (*cleanup)(void);
  81.     void (*write_entry)(dma_addr_t addr, unsigned int entry, unsigned int flags);
  82.     /* Flags is a more or less chipset specific opaque value.
  83.      * For chipsets that need to support old ums (non-gem) code, this
  84.      * needs to be identical to the various supported agp memory types! */
  85.     bool (*check_flags)(unsigned int flags);
  86.     void (*chipset_flush)(void);
  87. };
  88.  
  89. static struct _intel_private {
  90.     const struct intel_gtt_driver *driver;
  91.     struct pci_dev *pcidev; /* device one */
  92.     struct pci_dev *bridge_dev;
  93.     u8 __iomem *registers;
  94.     phys_addr_t gtt_bus_addr;
  95.     u32 PGETBL_save;
  96.     u32 __iomem *gtt;       /* I915G */
  97.     bool clear_fake_agp; /* on first access via agp, fill with scratch */
  98.     int num_dcache_entries;
  99.     void __iomem *i9xx_flush_page;
  100.     char *i81x_gtt_table;
  101.     struct resource ifp_resource;
  102.     int resource_valid;
  103.     struct page *scratch_page;
  104.         phys_addr_t scratch_page_dma;
  105.         int refcount;
  106.         /* Whether i915 needs to use the dmar apis or not. */
  107.         unsigned int needs_dmar : 1;
  108.         phys_addr_t gma_bus_addr;
  109.         /*  Size of memory reserved for graphics by the BIOS */
  110.         unsigned int stolen_size;
  111.         /* Total number of gtt entries. */
  112.         unsigned int gtt_total_entries;
  113.         /* Part of the gtt that is mappable by the cpu, for those chips where
  114.          * this is not the full gtt. */
  115.         unsigned int gtt_mappable_entries;
  116. } intel_private;
  117.  
  118. #define INTEL_GTT_GEN   intel_private.driver->gen
  119. #define IS_G33          intel_private.driver->is_g33
  120. #define IS_PINEVIEW     intel_private.driver->is_pineview
  121. #define IS_IRONLAKE     intel_private.driver->is_ironlake
  122. #define HAS_PGTBL_EN    intel_private.driver->has_pgtbl_enable
  123.  
  124. static int intel_gtt_setup_scratch_page(void)
  125. {
  126.         struct page *page;
  127.         dma_addr_t dma_addr;
  128.  
  129.         page = alloc_page(GFP_KERNEL | GFP_DMA32 | __GFP_ZERO);
  130.         if (page == NULL)
  131.         return -ENOMEM;
  132.                 intel_private.scratch_page_dma = page_to_phys(page);
  133.  
  134.         intel_private.scratch_page = page;
  135.  
  136.     return 0;
  137. }
  138.  
  139. static unsigned int intel_gtt_stolen_size(void)
  140. {
  141.     u16 gmch_ctrl;
  142.     u8 rdct;
  143.     int local = 0;
  144.     static const int ddt[4] = { 0, 16, 32, 64 };
  145.     unsigned int stolen_size = 0;
  146.  
  147.     if (INTEL_GTT_GEN == 1)
  148.         return 0; /* no stolen mem on i81x */
  149.  
  150.     pci_read_config_word(intel_private.bridge_dev,
  151.                  I830_GMCH_CTRL, &gmch_ctrl);
  152.  
  153.     if (intel_private.bridge_dev->device == PCI_DEVICE_ID_INTEL_82830_HB ||
  154.         intel_private.bridge_dev->device == PCI_DEVICE_ID_INTEL_82845G_HB) {
  155.         switch (gmch_ctrl & I830_GMCH_GMS_MASK) {
  156.         case I830_GMCH_GMS_STOLEN_512:
  157.             stolen_size = KB(512);
  158.             break;
  159.         case I830_GMCH_GMS_STOLEN_1024:
  160.             stolen_size = MB(1);
  161.             break;
  162.         case I830_GMCH_GMS_STOLEN_8192:
  163.             stolen_size = MB(8);
  164.             break;
  165.         case I830_GMCH_GMS_LOCAL:
  166.             rdct = readb(intel_private.registers+I830_RDRAM_CHANNEL_TYPE);
  167.             stolen_size = (I830_RDRAM_ND(rdct) + 1) *
  168.                     MB(ddt[I830_RDRAM_DDT(rdct)]);
  169.             local = 1;
  170.             break;
  171.         default:
  172.             stolen_size = 0;
  173.             break;
  174.         }
  175.     } else {
  176.         switch (gmch_ctrl & I855_GMCH_GMS_MASK) {
  177.         case I855_GMCH_GMS_STOLEN_1M:
  178.             stolen_size = MB(1);
  179.             break;
  180.         case I855_GMCH_GMS_STOLEN_4M:
  181.             stolen_size = MB(4);
  182.             break;
  183.         case I855_GMCH_GMS_STOLEN_8M:
  184.             stolen_size = MB(8);
  185.             break;
  186.         case I855_GMCH_GMS_STOLEN_16M:
  187.             stolen_size = MB(16);
  188.             break;
  189.         case I855_GMCH_GMS_STOLEN_32M:
  190.             stolen_size = MB(32);
  191.             break;
  192.         case I915_GMCH_GMS_STOLEN_48M:
  193.             stolen_size = MB(48);
  194.             break;
  195.         case I915_GMCH_GMS_STOLEN_64M:
  196.             stolen_size = MB(64);
  197.             break;
  198.         case G33_GMCH_GMS_STOLEN_128M:
  199.             stolen_size = MB(128);
  200.             break;
  201.         case G33_GMCH_GMS_STOLEN_256M:
  202.             stolen_size = MB(256);
  203.             break;
  204.         case INTEL_GMCH_GMS_STOLEN_96M:
  205.             stolen_size = MB(96);
  206.             break;
  207.         case INTEL_GMCH_GMS_STOLEN_160M:
  208.             stolen_size = MB(160);
  209.             break;
  210.         case INTEL_GMCH_GMS_STOLEN_224M:
  211.             stolen_size = MB(224);
  212.             break;
  213.         case INTEL_GMCH_GMS_STOLEN_352M:
  214.             stolen_size = MB(352);
  215.             break;
  216.         default:
  217.             stolen_size = 0;
  218.             break;
  219.         }
  220.     }
  221.  
  222.     if (stolen_size > 0) {
  223.                 dev_info(&intel_private.bridge_dev->dev, "detected %dK %s memory\n",
  224.                stolen_size / KB(1), local ? "local" : "stolen");
  225.     } else {
  226.                 dev_info(&intel_private.bridge_dev->dev,
  227.                        "no pre-allocated video memory detected\n");
  228.         stolen_size = 0;
  229.     }
  230.  
  231.     return stolen_size;
  232. }
  233.  
  234. static void i965_adjust_pgetbl_size(unsigned int size_flag)
  235. {
  236.     u32 pgetbl_ctl, pgetbl_ctl2;
  237.  
  238.     /* ensure that ppgtt is disabled */
  239.     pgetbl_ctl2 = readl(intel_private.registers+I965_PGETBL_CTL2);
  240.     pgetbl_ctl2 &= ~I810_PGETBL_ENABLED;
  241.     writel(pgetbl_ctl2, intel_private.registers+I965_PGETBL_CTL2);
  242.  
  243.     /* write the new ggtt size */
  244.     pgetbl_ctl = readl(intel_private.registers+I810_PGETBL_CTL);
  245.     pgetbl_ctl &= ~I965_PGETBL_SIZE_MASK;
  246.     pgetbl_ctl |= size_flag;
  247.     writel(pgetbl_ctl, intel_private.registers+I810_PGETBL_CTL);
  248. }
  249.  
  250. static unsigned int i965_gtt_total_entries(void)
  251. {
  252.     int size;
  253.     u32 pgetbl_ctl;
  254.     u16 gmch_ctl;
  255.  
  256.     pci_read_config_word(intel_private.bridge_dev,
  257.                  I830_GMCH_CTRL, &gmch_ctl);
  258.  
  259.     if (INTEL_GTT_GEN == 5) {
  260.         switch (gmch_ctl & G4x_GMCH_SIZE_MASK) {
  261.         case G4x_GMCH_SIZE_1M:
  262.         case G4x_GMCH_SIZE_VT_1M:
  263.             i965_adjust_pgetbl_size(I965_PGETBL_SIZE_1MB);
  264.             break;
  265.         case G4x_GMCH_SIZE_VT_1_5M:
  266.             i965_adjust_pgetbl_size(I965_PGETBL_SIZE_1_5MB);
  267.             break;
  268.         case G4x_GMCH_SIZE_2M:
  269.         case G4x_GMCH_SIZE_VT_2M:
  270.             i965_adjust_pgetbl_size(I965_PGETBL_SIZE_2MB);
  271.             break;
  272.         }
  273.     }
  274.  
  275.     pgetbl_ctl = readl(intel_private.registers+I810_PGETBL_CTL);
  276.  
  277.     switch (pgetbl_ctl & I965_PGETBL_SIZE_MASK) {
  278.     case I965_PGETBL_SIZE_128KB:
  279.         size = KB(128);
  280.         break;
  281.     case I965_PGETBL_SIZE_256KB:
  282.         size = KB(256);
  283.         break;
  284.     case I965_PGETBL_SIZE_512KB:
  285.         size = KB(512);
  286.         break;
  287.     /* GTT pagetable sizes bigger than 512KB are not possible on G33! */
  288.     case I965_PGETBL_SIZE_1MB:
  289.         size = KB(1024);
  290.         break;
  291.     case I965_PGETBL_SIZE_2MB:
  292.         size = KB(2048);
  293.         break;
  294.     case I965_PGETBL_SIZE_1_5MB:
  295.         size = KB(1024 + 512);
  296.         break;
  297.     default:
  298.                 dev_info(&intel_private.pcidev->dev,
  299.                          "unknown page table size, assuming 512KB\n");
  300.         size = KB(512);
  301.     }
  302.  
  303.     return size/4;
  304. }
  305.  
  306. static unsigned int intel_gtt_total_entries(void)
  307. {
  308.     if (IS_G33 || INTEL_GTT_GEN == 4 || INTEL_GTT_GEN == 5)
  309.         return i965_gtt_total_entries();
  310.         else {
  311.         /* On previous hardware, the GTT size was just what was
  312.          * required to map the aperture.
  313.          */
  314.                 return intel_private.gtt_mappable_entries;
  315.     }
  316. }
  317.  
  318. static unsigned int intel_gtt_mappable_entries(void)
  319. {
  320.     unsigned int aperture_size;
  321.  
  322.     if (INTEL_GTT_GEN == 1) {
  323.         u32 smram_miscc;
  324.  
  325.         pci_read_config_dword(intel_private.bridge_dev,
  326.                       I810_SMRAM_MISCC, &smram_miscc);
  327.  
  328.         if ((smram_miscc & I810_GFX_MEM_WIN_SIZE)
  329.                 == I810_GFX_MEM_WIN_32M)
  330.             aperture_size = MB(32);
  331.         else
  332.             aperture_size = MB(64);
  333.     } else if (INTEL_GTT_GEN == 2) {
  334.         u16 gmch_ctrl;
  335.  
  336.         pci_read_config_word(intel_private.bridge_dev,
  337.                      I830_GMCH_CTRL, &gmch_ctrl);
  338.  
  339.         if ((gmch_ctrl & I830_GMCH_MEM_MASK) == I830_GMCH_MEM_64M)
  340.             aperture_size = MB(64);
  341.         else
  342.             aperture_size = MB(128);
  343.     } else {
  344.         /* 9xx supports large sizes, just look at the length */
  345.         aperture_size = pci_resource_len(intel_private.pcidev, 2);
  346.     }
  347.  
  348.     return aperture_size >> PAGE_SHIFT;
  349. }
  350.  
  351. static void intel_gtt_teardown_scratch_page(void)
  352. {
  353.    // FreePage(intel_private.scratch_page_dma);
  354. }
  355.  
  356. static void intel_gtt_cleanup(void)
  357. {
  358.     intel_private.driver->cleanup();
  359.  
  360.         iounmap(intel_private.gtt);
  361.         iounmap(intel_private.registers);
  362.  
  363.         intel_gtt_teardown_scratch_page();
  364. }
  365.  
  366. static int intel_gtt_init(void)
  367. {
  368.         u32 gma_addr;
  369.     u32 gtt_map_size;
  370.     int ret;
  371.  
  372.     ret = intel_private.driver->setup();
  373.     if (ret != 0)
  374.         return ret;
  375.  
  376.         intel_private.gtt_mappable_entries = intel_gtt_mappable_entries();
  377.         intel_private.gtt_total_entries = intel_gtt_total_entries();
  378.  
  379.     /* save the PGETBL reg for resume */
  380.     intel_private.PGETBL_save =
  381.         readl(intel_private.registers+I810_PGETBL_CTL)
  382.             & ~I810_PGETBL_ENABLED;
  383.     /* we only ever restore the register when enabling the PGTBL... */
  384.     if (HAS_PGTBL_EN)
  385.         intel_private.PGETBL_save |= I810_PGETBL_ENABLED;
  386.  
  387.         dev_info(&intel_private.bridge_dev->dev,
  388.                         "detected gtt size: %dK total, %dK mappable\n",
  389.                         intel_private.gtt_total_entries * 4,
  390.                         intel_private.gtt_mappable_entries * 4);
  391.  
  392.         gtt_map_size = intel_private.gtt_total_entries * 4;
  393.  
  394.         intel_private.gtt = NULL;
  395.         if (intel_private.gtt == NULL)
  396.                 intel_private.gtt = ioremap(intel_private.gtt_bus_addr,
  397.                                             gtt_map_size);
  398.         if (intel_private.gtt == NULL) {
  399.         intel_private.driver->cleanup();
  400.                 iounmap(intel_private.registers);
  401.         return -ENOMEM;
  402.     }
  403.  
  404.     asm volatile("wbinvd");
  405.  
  406.         intel_private.stolen_size = intel_gtt_stolen_size();
  407.  
  408.         intel_private.needs_dmar = USE_PCI_DMA_API && INTEL_GTT_GEN > 2;
  409.  
  410.     ret = intel_gtt_setup_scratch_page();
  411.     if (ret != 0) {
  412.         intel_gtt_cleanup();
  413.         return ret;
  414.     }
  415.  
  416.         if (INTEL_GTT_GEN <= 2)
  417.                 pci_read_config_dword(intel_private.pcidev, I810_GMADDR,
  418.                                       &gma_addr);
  419.         else
  420.                 pci_read_config_dword(intel_private.pcidev, I915_GMADDR,
  421.                                       &gma_addr);
  422.  
  423.         intel_private.gma_bus_addr = (gma_addr & PCI_BASE_ADDRESS_MEM_MASK);
  424.  
  425.  
  426.     return 0;
  427. }
  428.  
  429. static void i830_write_entry(dma_addr_t addr, unsigned int entry,
  430.                              unsigned int flags)
  431. {
  432.         u32 pte_flags = I810_PTE_VALID;
  433.  
  434.         if (flags ==  AGP_USER_CACHED_MEMORY)
  435.                 pte_flags |= I830_PTE_SYSTEM_CACHED;
  436.  
  437.         writel(addr | pte_flags, intel_private.gtt + entry);
  438. }
  439.  
  440. bool intel_enable_gtt(void)
  441. {
  442.     u8 __iomem *reg;
  443.  
  444.     if (INTEL_GTT_GEN == 2) {
  445.         u16 gmch_ctrl;
  446.  
  447.         pci_read_config_word(intel_private.bridge_dev,
  448.                      I830_GMCH_CTRL, &gmch_ctrl);
  449.         gmch_ctrl |= I830_GMCH_ENABLED;
  450.         pci_write_config_word(intel_private.bridge_dev,
  451.                       I830_GMCH_CTRL, gmch_ctrl);
  452.  
  453.         pci_read_config_word(intel_private.bridge_dev,
  454.                      I830_GMCH_CTRL, &gmch_ctrl);
  455.         if ((gmch_ctrl & I830_GMCH_ENABLED) == 0) {
  456.                         dev_err(&intel_private.pcidev->dev,
  457.                                 "failed to enable the GTT: GMCH_CTRL=%x\n",
  458.                 gmch_ctrl);
  459.             return false;
  460.         }
  461.     }
  462.  
  463.     /* On the resume path we may be adjusting the PGTBL value, so
  464.      * be paranoid and flush all chipset write buffers...
  465.      */
  466.     if (INTEL_GTT_GEN >= 3)
  467.         writel(0, intel_private.registers+GFX_FLSH_CNTL);
  468.  
  469.     reg = intel_private.registers+I810_PGETBL_CTL;
  470.     writel(intel_private.PGETBL_save, reg);
  471.     if (HAS_PGTBL_EN && (readl(reg) & I810_PGETBL_ENABLED) == 0) {
  472.                 dev_err(&intel_private.pcidev->dev,
  473.                         "failed to enable the GTT: PGETBL=%x [expected %x]\n",
  474.             readl(reg), intel_private.PGETBL_save);
  475.         return false;
  476.     }
  477.  
  478.     if (INTEL_GTT_GEN >= 3)
  479.         writel(0, intel_private.registers+GFX_FLSH_CNTL);
  480.  
  481.     return true;
  482. }
  483.  
  484. static bool i830_check_flags(unsigned int flags)
  485. {
  486.         switch (flags) {
  487.         case 0:
  488.         case AGP_PHYS_MEMORY:
  489.         case AGP_USER_CACHED_MEMORY:
  490.         case AGP_USER_MEMORY:
  491.                 return true;
  492.         }
  493.  
  494.         return false;
  495. }
  496.  
  497. void intel_gtt_insert_sg_entries(struct sg_table *st,
  498.                                  unsigned int pg_start,
  499.                                  unsigned int flags)
  500. {
  501.         struct scatterlist *sg;
  502.         unsigned int len, m;
  503.     int i, j;
  504.  
  505.         j = pg_start;
  506.  
  507.         /* sg may merge pages, but we have to separate
  508.          * per-page addr for GTT */
  509.         for_each_sg(st->sgl, sg, st->nents, i) {
  510.                 len = sg_dma_len(sg) >> PAGE_SHIFT;
  511.                 for (m = 0; m < len; m++) {
  512.                         dma_addr_t addr = sg_dma_address(sg) + (m << PAGE_SHIFT);
  513.         intel_private.driver->write_entry(addr, j, flags);
  514.         j++;
  515.                 }
  516.         }
  517.         readl(intel_private.gtt+j-1);
  518. }
  519. EXPORT_SYMBOL(intel_gtt_insert_sg_entries);
  520.  
  521. static void intel_gtt_insert_pages(unsigned int first_entry,
  522.                                    unsigned int num_entries,
  523.                                    struct page **pages,
  524.                                    unsigned int flags)
  525. {
  526.     int i, j;
  527.  
  528.     for (i = 0, j = first_entry; i < num_entries; i++, j++) {
  529.                 dma_addr_t addr = page_to_phys(pages[i]);
  530.         intel_private.driver->write_entry(addr,
  531.                           j, flags);
  532.     }
  533.     readl(intel_private.gtt+j-1);
  534. }
  535.  
  536.  
  537. void intel_gtt_clear_range(unsigned int first_entry, unsigned int num_entries)
  538. {
  539.         unsigned int i;
  540.  
  541.         for (i = first_entry; i < (first_entry + num_entries); i++) {
  542.                 intel_private.driver->write_entry(intel_private.scratch_page_dma,
  543.                                                   i, 0);
  544.         }
  545.         readl(intel_private.gtt+i-1);
  546. }
  547.  
  548. static void intel_i9xx_setup_flush(void)
  549. {
  550.     /* return if already configured */
  551.     if (intel_private.ifp_resource.start)
  552.         return;
  553.  
  554.     if (INTEL_GTT_GEN == 6)
  555.         return;
  556.  
  557.     /* setup a resource for this object */
  558. //    intel_private.ifp_resource.name = "Intel Flush Page";
  559. //    intel_private.ifp_resource.flags = IORESOURCE_MEM;
  560.  
  561.     intel_private.resource_valid = 0;
  562.  
  563.     /* Setup chipset flush for 915 */
  564. //    if (IS_G33 || INTEL_GTT_GEN >= 4) {
  565. //        intel_i965_g33_setup_chipset_flush();
  566. //    } else {
  567. //        intel_i915_setup_chipset_flush();
  568. //    }
  569.  
  570. //    if (intel_private.ifp_resource.start)
  571. //        intel_private.i9xx_flush_page = ioremap_nocache(intel_private.ifp_resource.start, PAGE_SIZE);
  572.     if (!intel_private.i9xx_flush_page)
  573.         dev_err(&intel_private.pcidev->dev,
  574.             "can't ioremap flush page - no chipset flushing\n");
  575. }
  576.  
  577. static void i9xx_cleanup(void)
  578. {
  579.         if (intel_private.i9xx_flush_page)
  580.                 iounmap(intel_private.i9xx_flush_page);
  581. //      if (intel_private.resource_valid)
  582. //              release_resource(&intel_private.ifp_resource);
  583.         intel_private.ifp_resource.start = 0;
  584.         intel_private.resource_valid = 0;
  585. }
  586.  
  587. static void i9xx_chipset_flush(void)
  588. {
  589.     if (intel_private.i9xx_flush_page)
  590.         writel(1, intel_private.i9xx_flush_page);
  591. }
  592.  
  593. static void i965_write_entry(dma_addr_t addr,
  594.                              unsigned int entry,
  595.                              unsigned int flags)
  596. {
  597.         u32 pte_flags;
  598.  
  599.         pte_flags = I810_PTE_VALID;
  600.         if (flags == AGP_USER_CACHED_MEMORY)
  601.                 pte_flags |= I830_PTE_SYSTEM_CACHED;
  602.  
  603.         /* Shift high bits down */
  604.         addr |= (addr >> 28) & 0xf0;
  605.         writel(addr | pte_flags, intel_private.gtt + entry);
  606. }
  607.  
  608. static int i9xx_setup(void)
  609. {
  610.         u32 reg_addr, gtt_addr;
  611.         int size = KB(512);
  612.  
  613.     pci_read_config_dword(intel_private.pcidev, I915_MMADDR, &reg_addr);
  614.  
  615.     reg_addr &= 0xfff80000;
  616.  
  617.         intel_private.registers = ioremap(reg_addr, size);
  618.     if (!intel_private.registers)
  619.         return -ENOMEM;
  620.  
  621.         switch (INTEL_GTT_GEN) {
  622.         case 3:
  623.         pci_read_config_dword(intel_private.pcidev,
  624.                       I915_PTEADDR, &gtt_addr);
  625.         intel_private.gtt_bus_addr = gtt_addr;
  626.                 break;
  627.         case 5:
  628.                 intel_private.gtt_bus_addr = reg_addr + MB(2);
  629.             break;
  630.         default:
  631.                 intel_private.gtt_bus_addr = reg_addr + KB(512);
  632.             break;
  633.         }
  634.  
  635.     intel_i9xx_setup_flush();
  636.  
  637.     return 0;
  638. }
  639.  
  640. static const struct intel_gtt_driver i915_gtt_driver = {
  641.         .gen = 3,
  642.         .has_pgtbl_enable = 1,
  643.         .setup = i9xx_setup,
  644.         .cleanup = i9xx_cleanup,
  645.         /* i945 is the last gpu to need phys mem (for overlay and cursors). */
  646.         .write_entry = i830_write_entry,
  647.         .dma_mask_size = 32,
  648.         .check_flags = i830_check_flags,
  649.         .chipset_flush = i9xx_chipset_flush,
  650. };
  651. static const struct intel_gtt_driver g33_gtt_driver = {
  652.         .gen = 3,
  653.         .is_g33 = 1,
  654.         .setup = i9xx_setup,
  655.         .cleanup = i9xx_cleanup,
  656.         .write_entry = i965_write_entry,
  657.         .dma_mask_size = 36,
  658.         .check_flags = i830_check_flags,
  659.         .chipset_flush = i9xx_chipset_flush,
  660. };
  661. static const struct intel_gtt_driver pineview_gtt_driver = {
  662.         .gen = 3,
  663.         .is_pineview = 1, .is_g33 = 1,
  664.         .setup = i9xx_setup,
  665.         .cleanup = i9xx_cleanup,
  666.         .write_entry = i965_write_entry,
  667.         .dma_mask_size = 36,
  668.         .check_flags = i830_check_flags,
  669.         .chipset_flush = i9xx_chipset_flush,
  670. };
  671. static const struct intel_gtt_driver i965_gtt_driver = {
  672.         .gen = 4,
  673.         .has_pgtbl_enable = 1,
  674.         .setup = i9xx_setup,
  675.         .cleanup = i9xx_cleanup,
  676.         .write_entry = i965_write_entry,
  677.         .dma_mask_size = 36,
  678.         .check_flags = i830_check_flags,
  679.         .chipset_flush = i9xx_chipset_flush,
  680. };
  681. static const struct intel_gtt_driver g4x_gtt_driver = {
  682.         .gen = 5,
  683.         .setup = i9xx_setup,
  684.         .cleanup = i9xx_cleanup,
  685.         .write_entry = i965_write_entry,
  686.         .dma_mask_size = 36,
  687.         .check_flags = i830_check_flags,
  688.         .chipset_flush = i9xx_chipset_flush,
  689. };
  690. static const struct intel_gtt_driver ironlake_gtt_driver = {
  691.         .gen = 5,
  692.         .is_ironlake = 1,
  693.         .setup = i9xx_setup,
  694.         .cleanup = i9xx_cleanup,
  695.         .write_entry = i965_write_entry,
  696.         .dma_mask_size = 36,
  697.         .check_flags = i830_check_flags,
  698.         .chipset_flush = i9xx_chipset_flush,
  699. };
  700.  
  701. /* Table to describe Intel GMCH and AGP/PCIE GART drivers.  At least one of
  702.  * driver and gmch_driver must be non-null, and find_gmch will determine
  703.  * which one should be used if a gmch_chip_id is present.
  704.  */
  705. static const struct intel_gtt_driver_description {
  706.     unsigned int gmch_chip_id;
  707.     char *name;
  708.     const struct intel_gtt_driver *gtt_driver;
  709. } intel_gtt_chipsets[] = {
  710.         { PCI_DEVICE_ID_INTEL_E7221_IG, "E7221 (i915)",
  711.                 &i915_gtt_driver },
  712.         { PCI_DEVICE_ID_INTEL_82915G_IG, "915G",
  713.                 &i915_gtt_driver },
  714.         { PCI_DEVICE_ID_INTEL_82915GM_IG, "915GM",
  715.                 &i915_gtt_driver },
  716.         { PCI_DEVICE_ID_INTEL_82945G_IG, "945G",
  717.                 &i915_gtt_driver },
  718.         { PCI_DEVICE_ID_INTEL_82945GM_IG, "945GM",
  719.                 &i915_gtt_driver },
  720.         { PCI_DEVICE_ID_INTEL_82945GME_IG, "945GME",
  721.                 &i915_gtt_driver },
  722.         { PCI_DEVICE_ID_INTEL_82946GZ_IG, "946GZ",
  723.                 &i965_gtt_driver },
  724.         { PCI_DEVICE_ID_INTEL_82G35_IG, "G35",
  725.                 &i965_gtt_driver },
  726.         { PCI_DEVICE_ID_INTEL_82965Q_IG, "965Q",
  727.                 &i965_gtt_driver },
  728.         { PCI_DEVICE_ID_INTEL_82965G_IG, "965G",
  729.                 &i965_gtt_driver },
  730.         { PCI_DEVICE_ID_INTEL_82965GM_IG, "965GM",
  731.                 &i965_gtt_driver },
  732.         { PCI_DEVICE_ID_INTEL_82965GME_IG, "965GME/GLE",
  733.                 &i965_gtt_driver },
  734.         { PCI_DEVICE_ID_INTEL_G33_IG, "G33",
  735.                 &g33_gtt_driver },
  736.         { PCI_DEVICE_ID_INTEL_Q35_IG, "Q35",
  737.                 &g33_gtt_driver },
  738.         { PCI_DEVICE_ID_INTEL_Q33_IG, "Q33",
  739.                 &g33_gtt_driver },
  740.         { PCI_DEVICE_ID_INTEL_PINEVIEW_M_IG, "GMA3150",
  741.                 &pineview_gtt_driver },
  742.         { PCI_DEVICE_ID_INTEL_PINEVIEW_IG, "GMA3150",
  743.                 &pineview_gtt_driver },
  744.         { PCI_DEVICE_ID_INTEL_GM45_IG, "GM45",
  745.                 &g4x_gtt_driver },
  746.         { PCI_DEVICE_ID_INTEL_EAGLELAKE_IG, "Eaglelake",
  747.                 &g4x_gtt_driver },
  748.         { PCI_DEVICE_ID_INTEL_Q45_IG, "Q45/Q43",
  749.                 &g4x_gtt_driver },
  750.         { PCI_DEVICE_ID_INTEL_G45_IG, "G45/G43",
  751.                 &g4x_gtt_driver },
  752.         { PCI_DEVICE_ID_INTEL_B43_IG, "B43",
  753.                 &g4x_gtt_driver },
  754.         { PCI_DEVICE_ID_INTEL_B43_1_IG, "B43",
  755.                 &g4x_gtt_driver },
  756.         { PCI_DEVICE_ID_INTEL_G41_IG, "G41",
  757.                 &g4x_gtt_driver },
  758.         { PCI_DEVICE_ID_INTEL_IRONLAKE_D_IG,
  759.             "HD Graphics", &ironlake_gtt_driver },
  760.         { PCI_DEVICE_ID_INTEL_IRONLAKE_M_IG,
  761.             "HD Graphics", &ironlake_gtt_driver },
  762.     { 0, NULL, NULL }
  763. };
  764.  
  765. static int find_gmch(u16 device)
  766. {
  767.     struct pci_dev *gmch_device;
  768.  
  769.     gmch_device = pci_get_device(PCI_VENDOR_ID_INTEL, device, NULL);
  770.     if (gmch_device && PCI_FUNC(gmch_device->devfn) != 0) {
  771.         gmch_device = pci_get_device(PCI_VENDOR_ID_INTEL,
  772.                          device, gmch_device);
  773.     }
  774.  
  775.     if (!gmch_device)
  776.         return 0;
  777.  
  778.     intel_private.pcidev = gmch_device;
  779.     return 1;
  780. }
  781.  
  782. int intel_gmch_probe(struct pci_dev *bridge_pdev, struct pci_dev *gpu_pdev,
  783.                       struct agp_bridge_data *bridge)
  784. {
  785.     int i, mask;
  786.  
  787.         /*
  788.          * Can be called from the fake agp driver but also directly from
  789.          * drm/i915.ko. Hence we need to check whether everything is set up
  790.          * already.
  791.          */
  792.         if (intel_private.driver) {
  793.                 intel_private.refcount++;
  794.                 return 1;
  795.         }
  796.  
  797.  
  798.     for (i = 0; intel_gtt_chipsets[i].name != NULL; i++) {
  799.         if (find_gmch(intel_gtt_chipsets[i].gmch_chip_id)) {
  800.             intel_private.driver =
  801.                 intel_gtt_chipsets[i].gtt_driver;
  802.             break;
  803.         }
  804.     }
  805.  
  806.     if (!intel_private.driver)
  807.         return 0;
  808.  
  809.         intel_private.refcount++;
  810.  
  811.         if (bridge) {
  812.                 bridge->dev_private_data = &intel_private;
  813.                 bridge->dev = bridge_pdev;
  814.         }
  815.  
  816.     intel_private.bridge_dev = bridge_pdev;
  817.  
  818.         dev_info(&bridge_pdev->dev, "Intel %s Chipset\n", intel_gtt_chipsets[i].name);
  819.  
  820.     mask = intel_private.driver->dma_mask_size;
  821. //    if (pci_set_dma_mask(intel_private.pcidev, DMA_BIT_MASK(mask)))
  822. //        dev_err(&intel_private.pcidev->dev,
  823. //            "set gfx device dma mask %d-bit failed!\n", mask);
  824. //    else
  825. //        pci_set_consistent_dma_mask(intel_private.pcidev,
  826. //                        DMA_BIT_MASK(mask));
  827.  
  828.         if (intel_gtt_init() != 0) {
  829. //              intel_gmch_remove();
  830.  
  831.         return 0;
  832.         }
  833.  
  834.     return 1;
  835. }
  836. EXPORT_SYMBOL(intel_gmch_probe);
  837.  
  838. void intel_gtt_get(size_t *gtt_total, size_t *stolen_size,
  839.                    phys_addr_t *mappable_base, unsigned long *mappable_end)
  840. {
  841.         *gtt_total = intel_private.gtt_total_entries << PAGE_SHIFT;
  842.         *stolen_size = intel_private.stolen_size;
  843.         *mappable_base = intel_private.gma_bus_addr;
  844.         *mappable_end = intel_private.gtt_mappable_entries << PAGE_SHIFT;
  845. }
  846. EXPORT_SYMBOL(intel_gtt_get);
  847.  
  848. void intel_gtt_chipset_flush(void)
  849. {
  850.         if (intel_private.driver->chipset_flush)
  851.                 intel_private.driver->chipset_flush();
  852. }
  853. EXPORT_SYMBOL(intel_gtt_chipset_flush);
  854.  
  855.  
  856. MODULE_AUTHOR("Dave Jones <davej@redhat.com>");
  857. MODULE_LICENSE("GPL and additional rights");
  858.