Subversion Repositories Kolibri OS

Rev

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

  1.  
  2. #include "types.h"
  3. #include "link.h"
  4.  
  5. #include <stdio.h>
  6. #include <malloc.h>
  7. #include <memory.h>
  8.  
  9. #include "pci.h"
  10. #include "agp.h"
  11.  
  12. #include "syscall.h"
  13.  
  14.  
  15. agp_t *bridge;
  16.  
  17.  
  18. int __stdcall srv_agp(ioctl_t *io);
  19.  
  20.  
  21. u32_t __stdcall drvEntry(int action)
  22. {
  23.     u32_t retval;
  24.  
  25.     int i;
  26.  
  27.     if(action != 1)
  28.         return 0;
  29.  
  30.     if(!dbg_open("/rd/1/drivers/agp.log"))
  31.     {
  32.         printf("Can't open /rd/1/drivers/agp.log\nExit\n");
  33.         return 0;
  34.     }
  35.  
  36.     if( FindPciDevice() == 0)
  37.     {
  38.         dbgprintf("Device not found\n");
  39.         return 0;
  40.     };
  41.  
  42.     return 0;
  43.  
  44. //    retval = RegService("AGP", srv_2d);
  45. //    dbgprintf("reg service %s as: %x\n", "HDRAW", retval);
  46.  
  47. //    return retval;
  48. };
  49.  
  50.  
  51. #include "pci.inc"
  52. #include "isoch.inc"
  53.  
  54. static void intel_8xx_tlbflush(void *mem)
  55. {
  56.     u32_t temp;
  57.  
  58.     temp = pciReadLong(bridge->PciTag, INTEL_AGPCTRL);
  59.     pciWriteLong(bridge->PciTag, INTEL_AGPCTRL, temp & ~(1 << 7));
  60.     temp = pciReadLong(bridge->PciTag, INTEL_AGPCTRL);
  61.     pciWriteLong(bridge->PciTag, INTEL_AGPCTRL, temp | (1 << 7));
  62. }
  63.  
  64.  
  65. static aper_size_t intel_8xx_sizes[7] =
  66. {
  67.     { 256, 65536, 64,  0 },
  68.     { 128, 32768, 32, 32 },
  69.     {  64, 16384, 16, 48 },
  70.     {  32,  8192,  8, 56 },
  71.     {  16,  4096,  4, 60 },
  72.     {   8,  2048,  2, 62 },
  73.     {   4,  1024,  1, 63 }
  74. };
  75.  
  76.  
  77.  
  78. static int intel_845_configure()
  79. {
  80.     u32_t temp;
  81.     u8_t  temp2;
  82.     aper_size_t *current_size;
  83.  
  84.     current_size = bridge->current_size;
  85.  
  86.         /* aperture size */
  87.     pciWriteByte(bridge->PciTag, INTEL_APSIZE, current_size->size_value);
  88.  
  89.     dbgprintf("INTEL_APSIZE %d\n", current_size->size_value );
  90.  
  91.     if (bridge->apbase_config != 0)
  92.     {
  93.         pciWriteLong(bridge->PciTag, AGP_APBASE, bridge->apbase_config);
  94.     }
  95.     else
  96.     {
  97.                 /* address to map to */
  98.         temp = pciReadLong(bridge->PciTag, AGP_APBASE);
  99.         bridge->gart_addr = (temp & PCI_MAP_MEMORY_ADDRESS_MASK);
  100.         bridge->apbase_config = temp;
  101.         }
  102.  
  103.     dbgprintf("AGP_APBASE %x\n", temp );
  104.  
  105.         /* attbase - aperture base */
  106.     pciWriteLong(bridge->PciTag, INTEL_ATTBASE, bridge->gatt_dma);
  107.  
  108.         /* agpctrl */
  109.     pciWriteLong(bridge->PciTag, INTEL_AGPCTRL, 0x0000);
  110.  
  111.         /* agpm */
  112.     temp2 = pciReadByte(bridge->PciTag, INTEL_I845_AGPM);
  113.     pciWriteByte(bridge->PciTag, INTEL_I845_AGPM, temp2 | (1 << 1));
  114.         /* clear any possible error conditions */
  115.     pciWriteWord(bridge->PciTag, INTEL_I845_ERRSTS, 0x001c);
  116.         return 0;
  117. }
  118.  
  119.  
  120. int agp_generic_create_gatt_table()
  121. {
  122.     count_t pages;
  123.  
  124.     pages = bridge->current_size->pages_count;
  125.  
  126.     if( bridge->gatt_dma = AllocPages(pages))
  127.     {
  128.         if(bridge->gatt_table =
  129.            (u32_t*)MapIoMem((void*)bridge->gatt_dma,
  130.                             pages<<12, PG_SW+PG_NOCACHE))
  131.         {
  132.             dbgprintf("gatt map %x at %x %d pages\n",bridge->gatt_dma ,
  133.                        bridge->gatt_table, pages);
  134.  
  135.         /* AK: bogus, should encode addresses > 4GB */
  136.  
  137.             u32_t volatile *table = bridge->gatt_table;
  138.  
  139.             count_t count = bridge->current_size->num_entries;
  140.  
  141.             while(count--) {            /* FIXME memset */
  142.                 addr_t tmp;
  143.  
  144.                 *table = 0;
  145.                 table++;
  146.             }
  147.             return 1;
  148.         };
  149.     };
  150.     dbgprintf("unable to get memory for "
  151.               "graphics translation table.\n");
  152.         return 0;
  153. }
  154.  
  155.  
  156. static int __intel_8xx_fetch_size(u8_t temp)
  157. {
  158.         int i;
  159.     aper_size_t *values;
  160.  
  161.     values = bridge->aperture_sizes;
  162.  
  163.     values = intel_8xx_sizes;
  164.  
  165.     for (i = 0; i < 7; i++)
  166.     {
  167.         if (temp == values[i].size_value)
  168.         {
  169.             bridge->previous_size =
  170.                 bridge->current_size = (void *) (values + i);
  171.             bridge->aperture_size_idx = i;
  172.                         return values[i].size;
  173.                 }
  174.         }
  175.         return 0;
  176. }
  177.  
  178. static int intel_8xx_fetch_size(void)
  179. {
  180.     u8_t temp;
  181.  
  182.     temp = pciReadByte(bridge->PciTag, INTEL_APSIZE);
  183.         return __intel_8xx_fetch_size(temp);
  184. }
  185.  
  186.  
  187. int agp_bind_memory(addr_t agp_addr, addr_t dma_addr, size_t size)
  188. {
  189.         int ret_val;
  190.     count_t count;
  191.  
  192. //    if (curr == NULL)
  193. //        return -EINVAL;
  194.  
  195. //    if (curr->is_bound == TRUE) {
  196. //        printk(KERN_INFO PFX "memory %p is already bound!\n", curr);
  197. //        return -EINVAL;
  198. //    }
  199. //    if (curr->is_flushed == FALSE) {
  200. //        curr->bridge->driver->cache_flush();
  201. //        curr->is_flushed = TRUE;
  202. //    }
  203. //    ret_val = curr->bridge->driver->insert_memory(curr, pg_start, curr->type);
  204.  
  205.     u32_t volatile *table = &bridge->gatt_table[agp_addr>>12];
  206.  
  207.     count = size >> 12;
  208.  
  209.     dma_addr |= 0x00000017;
  210.  
  211.     while(count--)
  212.     {
  213.         *table = dma_addr;
  214.         table++;
  215.         dma_addr+=4096;
  216.     }
  217.  
  218.     bridge->tlb_flush(NULL);
  219.  
  220. //    if (ret_val != 0)
  221. //        return ret_val;
  222.  
  223. //    curr->is_bound = TRUE;
  224. //    curr->pg_start = pg_start;
  225.         return 0;
  226. }
  227.  
  228. void get_agp_version(agp_t *bridge)
  229. {
  230.     u32_t ncapid;
  231.  
  232.         /* Exit early if already set by errata workarounds. */
  233.         if (bridge->major_version != 0)
  234.                 return;
  235.  
  236.     ncapid = pciReadLong(bridge->PciTag, bridge->capndx);
  237.         bridge->major_version = (ncapid >> AGP_MAJOR_VERSION_SHIFT) & 0xf;
  238.         bridge->minor_version = (ncapid >> AGP_MINOR_VERSION_SHIFT) & 0xf;
  239. }
  240.  
  241. static void agp_v2_parse_one(u32_t *requested_mode, u32_t *bridge_agpstat, u32_t *vga_agpstat)
  242. {
  243.     u32_t tmp;
  244.  
  245.         if (*requested_mode & AGP2_RESERVED_MASK) {
  246.         dbgprintf("reserved bits set (%x) in mode 0x%x. Fixed.\n",
  247.                         *requested_mode & AGP2_RESERVED_MASK, *requested_mode);
  248.                 *requested_mode &= ~AGP2_RESERVED_MASK;
  249.         }
  250.  
  251.         /* Check the speed bits make sense. Only one should be set. */
  252.         tmp = *requested_mode & 7;
  253.         switch (tmp) {
  254.                 case 0:
  255.             dbgprintf("Setting to x1 mode.\n");
  256.                         *requested_mode |= AGPSTAT2_1X;
  257.                         break;
  258.                 case 1:
  259.                 case 2:
  260.                         break;
  261.                 case 3:
  262.                         *requested_mode &= ~(AGPSTAT2_1X);      /* rate=2 */
  263.                         break;
  264.                 case 4:
  265.                         break;
  266.                 case 5:
  267.                 case 6:
  268.                 case 7:
  269.                         *requested_mode &= ~(AGPSTAT2_1X|AGPSTAT2_2X); /* rate=4*/
  270.                         break;
  271.         }
  272.  
  273.         /* disable SBA if it's not supported */
  274.         if (!((*bridge_agpstat & AGPSTAT_SBA) && (*vga_agpstat & AGPSTAT_SBA) && (*requested_mode & AGPSTAT_SBA)))
  275.                 *bridge_agpstat &= ~AGPSTAT_SBA;
  276.  
  277.         /* Set rate */
  278.         if (!((*bridge_agpstat & AGPSTAT2_4X) && (*vga_agpstat & AGPSTAT2_4X) && (*requested_mode & AGPSTAT2_4X)))
  279.                 *bridge_agpstat &= ~AGPSTAT2_4X;
  280.  
  281.         if (!((*bridge_agpstat & AGPSTAT2_2X) && (*vga_agpstat & AGPSTAT2_2X) && (*requested_mode & AGPSTAT2_2X)))
  282.                 *bridge_agpstat &= ~AGPSTAT2_2X;
  283.  
  284.         if (!((*bridge_agpstat & AGPSTAT2_1X) && (*vga_agpstat & AGPSTAT2_1X) && (*requested_mode & AGPSTAT2_1X)))
  285.                 *bridge_agpstat &= ~AGPSTAT2_1X;
  286.  
  287.         /* Now we know what mode it should be, clear out the unwanted bits. */
  288.         if (*bridge_agpstat & AGPSTAT2_4X)
  289.                 *bridge_agpstat &= ~(AGPSTAT2_1X | AGPSTAT2_2X);        /* 4X */
  290.  
  291.         if (*bridge_agpstat & AGPSTAT2_2X)
  292.                 *bridge_agpstat &= ~(AGPSTAT2_1X | AGPSTAT2_4X);        /* 2X */
  293.  
  294.         if (*bridge_agpstat & AGPSTAT2_1X)
  295.                 *bridge_agpstat &= ~(AGPSTAT2_2X | AGPSTAT2_4X);        /* 1X */
  296.  
  297.         /* Apply any errata. */
  298.     if (bridge->flags & AGP_ERRATA_FASTWRITES)
  299.                 *bridge_agpstat &= ~AGPSTAT_FW;
  300.  
  301.     if (bridge->flags & AGP_ERRATA_SBA)
  302.                 *bridge_agpstat &= ~AGPSTAT_SBA;
  303.  
  304.     if (bridge->flags & AGP_ERRATA_1X) {
  305.                 *bridge_agpstat &= ~(AGPSTAT2_2X | AGPSTAT2_4X);
  306.                 *bridge_agpstat |= AGPSTAT2_1X;
  307.         }
  308.  
  309.         /* If we've dropped down to 1X, disable fast writes. */
  310.         if (*bridge_agpstat & AGPSTAT2_1X)
  311.                 *bridge_agpstat &= ~AGPSTAT_FW;
  312. }
  313.  
  314.  
  315. static void agp_v3_parse_one(u32_t *requested_mode,
  316.                              u32_t *bridge_agpstat,
  317.                              u32_t *vga_agpstat)
  318. {
  319.     u32_t origbridge = *bridge_agpstat, origvga = *vga_agpstat;
  320.     u32_t tmp;
  321.  
  322.     if (*requested_mode & AGP3_RESERVED_MASK)
  323.     {
  324.         dbgprintf("reserved bits set (%x) in mode 0x%x. Fixed.\n",
  325.                         *requested_mode & AGP3_RESERVED_MASK, *requested_mode);
  326.                 *requested_mode &= ~AGP3_RESERVED_MASK;
  327.         }
  328.  
  329.         /* Check the speed bits make sense. */
  330.         tmp = *requested_mode & 7;
  331.         if (tmp == 0) {
  332.         dbgprintf("Setting to AGP3 x4 mode.\n");
  333.                 *requested_mode |= AGPSTAT3_4X;
  334.         }
  335.         if (tmp >= 3) {
  336.         dbgprintf("Setting to AGP3 x8 mode.\n");
  337.                 *requested_mode = (*requested_mode & ~7) | AGPSTAT3_8X;
  338.         }
  339.  
  340.         /* ARQSZ - Set the value to the maximum one.
  341.          * Don't allow the mode register to override values. */
  342.         *bridge_agpstat = ((*bridge_agpstat & ~AGPSTAT_ARQSZ) |
  343.         max_t(u32_t,(*bridge_agpstat & AGPSTAT_ARQSZ),(*vga_agpstat & AGPSTAT_ARQSZ)));
  344.  
  345.         /* Calibration cycle.
  346.          * Don't allow the mode register to override values. */
  347.         *bridge_agpstat = ((*bridge_agpstat & ~AGPSTAT_CAL_MASK) |
  348.         min_t(u32_t,(*bridge_agpstat & AGPSTAT_CAL_MASK),(*vga_agpstat & AGPSTAT_CAL_MASK)));
  349.  
  350.         /* SBA *must* be supported for AGP v3 */
  351.         *bridge_agpstat |= AGPSTAT_SBA;
  352.  
  353.         /*
  354.          * Set speed.
  355.          * Check for invalid speeds. This can happen when applications
  356.          * written before the AGP 3.0 standard pass AGP2.x modes to AGP3 hardware
  357.          */
  358.         if (*requested_mode & AGPSTAT_MODE_3_0) {
  359.                 /*
  360.                  * Caller hasn't a clue what it is doing. Bridge is in 3.0 mode,
  361.                  * have been passed a 3.0 mode, but with 2.x speed bits set.
  362.                  * AGP2.x 4x -> AGP3.0 4x.
  363.                  */
  364.                 if (*requested_mode & AGPSTAT2_4X) {
  365.             dbgprintf("broken AGP3 flags (%x). Fixed.\n", *requested_mode);
  366.                         *requested_mode &= ~AGPSTAT2_4X;
  367.                         *requested_mode |= AGPSTAT3_4X;
  368.                 }
  369.         } else {
  370.                 /*
  371.                  * The caller doesn't know what they are doing. We are in 3.0 mode,
  372.                  * but have been passed an AGP 2.x mode.
  373.                  * Convert AGP 1x,2x,4x -> AGP 3.0 4x.
  374.                  */
  375.         dbgprintf("broken AGP2 flags (%x) in AGP3 mode. Fixed.\n",*requested_mode);
  376.                 *requested_mode &= ~(AGPSTAT2_4X | AGPSTAT2_2X | AGPSTAT2_1X);
  377.                 *requested_mode |= AGPSTAT3_4X;
  378.         }
  379.  
  380.         if (*requested_mode & AGPSTAT3_8X) {
  381.                 if (!(*bridge_agpstat & AGPSTAT3_8X)) {
  382.                         *bridge_agpstat &= ~(AGPSTAT3_8X | AGPSTAT3_RSVD);
  383.                         *bridge_agpstat |= AGPSTAT3_4X;
  384.             dbgprintf("requested AGPx8 but bridge not capable.\n");
  385.                         return;
  386.                 }
  387.                 if (!(*vga_agpstat & AGPSTAT3_8X)) {
  388.                         *bridge_agpstat &= ~(AGPSTAT3_8X | AGPSTAT3_RSVD);
  389.                         *bridge_agpstat |= AGPSTAT3_4X;
  390.             dbgprintf("requested AGPx8 but graphic card not capable.\n");
  391.                         return;
  392.                 }
  393.                 /* All set, bridge & device can do AGP x8*/
  394.                 *bridge_agpstat &= ~(AGPSTAT3_4X | AGPSTAT3_RSVD);
  395.                 goto done;
  396.  
  397.         } else {
  398.  
  399.                 /*
  400.                  * If we didn't specify AGPx8, we can only do x4.
  401.                  * If the hardware can't do x4, we're up shit creek, and never
  402.                  *  should have got this far.
  403.                  */
  404.                 *bridge_agpstat &= ~(AGPSTAT3_8X | AGPSTAT3_RSVD);
  405.                 if ((*bridge_agpstat & AGPSTAT3_4X) && (*vga_agpstat & AGPSTAT3_4X))
  406.                         *bridge_agpstat |= AGPSTAT3_4X;
  407.                 else {
  408.             dbgprintf("Badness. Don't know which AGP mode to set. "
  409.                                                         "[bridge_agpstat:%x vga_agpstat:%x fell back to:- bridge_agpstat:%x vga_agpstat:%x]\n",
  410.                                                         origbridge, origvga, *bridge_agpstat, *vga_agpstat);
  411.                         if (!(*bridge_agpstat & AGPSTAT3_4X))
  412.                 dbgprintf("Bridge couldn't do AGP x4.\n");
  413.                         if (!(*vga_agpstat & AGPSTAT3_4X))
  414.                 dbgprintf("Graphic card couldn't do AGP x4.\n");
  415.                         return;
  416.                 }
  417.         }
  418.  
  419. done:
  420.         /* Apply any errata. */
  421.     if (bridge->flags & AGP_ERRATA_FASTWRITES)
  422.                 *bridge_agpstat &= ~AGPSTAT_FW;
  423.  
  424.     if (bridge->flags & AGP_ERRATA_SBA)
  425.                 *bridge_agpstat &= ~AGPSTAT_SBA;
  426.  
  427.     if (bridge->flags & AGP_ERRATA_1X) {
  428.                 *bridge_agpstat &= ~(AGPSTAT2_2X | AGPSTAT2_4X);
  429.                 *bridge_agpstat |= AGPSTAT2_1X;
  430.         }
  431. }
  432.  
  433.  
  434. u32_t agp_collect_device_status(agp_t *bridge, u32_t requested_mode,
  435.                                 u32_t bridge_agpstat)
  436. {
  437.     PCITAG  vgaTag;
  438.     u32_t   vga_agpstat;
  439.     int     cap_ptr;
  440.  
  441.     for (;;)
  442.     {
  443.         vgaTag = pci_find_class(PCI_CLASS_DISPLAY_VGA);
  444.         if (vgaTag == -1)
  445.         {
  446.             dbgprintf("Couldn't find an AGP VGA controller.\n");
  447.                         return 0;
  448.                 }
  449.         cap_ptr = pci_find_capability(vgaTag, PCI_CAP_ID_AGP);
  450.                 if (cap_ptr)
  451.                         break;
  452.         }
  453.  
  454.         /*
  455.          * Ok, here we have a AGP device. Disable impossible
  456.          * settings, and adjust the readqueue to the minimum.
  457.          */
  458.     vga_agpstat = pciReadLong(vgaTag, cap_ptr+PCI_AGP_STATUS);
  459.  
  460.         /* adjust RQ depth */
  461.         bridge_agpstat = ((bridge_agpstat & ~AGPSTAT_RQ_DEPTH) |
  462.          min_t(u32_t, (requested_mode & AGPSTAT_RQ_DEPTH),
  463.          min_t(u32_t, (bridge_agpstat & AGPSTAT_RQ_DEPTH), (vga_agpstat & AGPSTAT_RQ_DEPTH))));
  464.  
  465.         /* disable FW if it's not supported */
  466.         if (!((bridge_agpstat & AGPSTAT_FW) &&
  467.           (vga_agpstat & AGPSTAT_FW) &&
  468.           (requested_mode & AGPSTAT_FW)))
  469.                 bridge_agpstat &= ~AGPSTAT_FW;
  470.  
  471.         /* Check to see if we are operating in 3.0 mode */
  472.     if (bridge->mode & AGPSTAT_MODE_3_0)
  473.                 agp_v3_parse_one(&requested_mode, &bridge_agpstat, &vga_agpstat);
  474.         else
  475.                 agp_v2_parse_one(&requested_mode, &bridge_agpstat, &vga_agpstat);
  476.  
  477.         return bridge_agpstat;
  478. }
  479.  
  480.  
  481. void agp_device_command(u32_t bridge_agpstat, int agp_v3)
  482. {
  483.     PCITAG device = 0;
  484.         int mode;
  485.  
  486.         mode = bridge_agpstat & 0x7;
  487.         if (agp_v3)
  488.                 mode *= 4;
  489.  
  490.     for_each_pci_dev(device)
  491.     {
  492.         int agp = pci_find_capability(device, PCI_CAP_ID_AGP);
  493.                 if (!agp)
  494.                         continue;
  495.  
  496.         dbgprintf("Putting AGP V%d device at into %dx mode\n",
  497.                 agp_v3 ? 3 : 2, mode);
  498.         pciWriteLong(device, agp + PCI_AGP_COMMAND, bridge_agpstat);
  499.         }
  500. }
  501.  
  502.  
  503. void agp_generic_enable(u32_t requested_mode)
  504. {
  505.     u32_t bridge_agpstat, temp;
  506.  
  507.     get_agp_version(bridge);
  508.  
  509.     dbgprintf("Found an AGP %d.%d compliant device.\n",
  510.            bridge->major_version, bridge->minor_version);
  511.  
  512.     bridge_agpstat = pciReadLong(bridge->PciTag,
  513.                      bridge->capndx + PCI_AGP_STATUS);
  514.  
  515.     bridge_agpstat = agp_collect_device_status(bridge, requested_mode, bridge_agpstat);
  516.         if (bridge_agpstat == 0)
  517.                 /* Something bad happened. FIXME: Return error code? */
  518.                 return;
  519.  
  520.         bridge_agpstat |= AGPSTAT_AGP_ENABLE;
  521.  
  522.         /* Do AGP version specific frobbing. */
  523.     if (bridge->major_version >= 3)
  524.     {
  525.         if (bridge->mode & AGPSTAT_MODE_3_0)
  526.         {
  527.                         /* If we have 3.5, we can do the isoch stuff. */
  528.             if (bridge->minor_version >= 5)
  529.                 agp_3_5_enable(bridge);
  530.             agp_device_command(bridge_agpstat, TRUE);
  531.                         return;
  532.         }
  533.         else
  534.         {
  535.                     /* Disable calibration cycle in RX91<1> when not in AGP3.0 mode of operation.*/
  536.                     bridge_agpstat &= ~(7<<10) ;
  537.             temp = pciReadLong(bridge->PciTag, bridge->capndx+AGPCTRL);
  538.                     temp |= (1<<9);
  539.             pciWriteLong(bridge->PciTag, bridge->capndx+AGPCTRL, temp);
  540.  
  541.             dbgprintf("Device is in legacy mode,"
  542.                       " falling back to 2.x\n");
  543.                 }
  544.         }
  545.  
  546.         /* AGP v<3 */
  547.     agp_device_command(bridge_agpstat, FALSE);
  548. }
  549.  
  550.  
  551. static agp_t intel_845_driver =
  552. {
  553.     .aperture_sizes     = intel_8xx_sizes,
  554. //    .size_type          = U8_APER_SIZE,
  555. //    .num_aperture_sizes = 7,
  556.     .configure          = intel_845_configure,
  557.     .fetch_size         = intel_8xx_fetch_size,
  558. //    .cleanup            = intel_8xx_cleanup,
  559.     .tlb_flush          = intel_8xx_tlbflush,
  560. //    .mask_memory        = agp_generic_mask_memory,
  561. //    .masks              = intel_generic_masks,
  562. //    .agp_enable         = agp_generic_enable,
  563. //    .cache_flush        = global_cache_flush,
  564.     .create_gatt_table  = agp_generic_create_gatt_table,
  565. //    .free_gatt_table    = agp_generic_free_gatt_table,
  566. //    .insert_memory      = agp_generic_insert_memory,
  567. //    .remove_memory      = agp_generic_remove_memory,
  568. //    .alloc_by_type      = agp_generic_alloc_by_type,
  569. //    .free_by_type       = agp_generic_free_by_type,
  570. //    .agp_alloc_page     = agp_generic_alloc_page,
  571. //    .agp_destroy_page   = agp_generic_destroy_page,
  572. };
  573.  
  574. int init_bridge(PCITAG pciTag)
  575. {
  576.     size_t size_value;
  577.  
  578.     bridge = &intel_845_driver;
  579.  
  580.     bridge->PciTag = pciTag;
  581.  
  582.     bridge->capndx = pci_find_capability(pciTag, PCI_CAP_ID_AGP);
  583.  
  584.     size_value = bridge->fetch_size();
  585.  
  586.     if (size_value == 0) {
  587.         dbgprintf("unable to determine aperture size.\n");
  588.         return 0;
  589.     };
  590.  
  591.     dbgprintf("fetch size = %x\n", size_value);
  592.  
  593.     if( bridge->create_gatt_table() )
  594.     {
  595.         bridge->configure();
  596.         return 1;
  597.     }
  598.     return 0;
  599. }
  600.  
  601.  
  602. #include "detect.inc"
  603.