Ticket #6202: intel_extreme_atom_20101128_1.patch

File intel_extreme_atom_20101128_1.patch, 10.7 KB (added by umccullough, 12 years ago)

Fixed version of brecht's patch, missing constant values added from linux driver

  • src/add-ons/kernel/busses/agp_gart/intel_gart.cpp

     
    7171
    7272    {0x2e30, 0x2e32, INTEL_TYPE_GM45, "GMA_X4500_VGA"},
    7373    {0x2a40, 0x2a42, INTEL_TYPE_GM45, "GM45"},
     74   
     75    {0xa000, 0xa001, INTEL_TYPE_IGDG, "Atom_Dx10"},
     76    {0xa010, 0xa011, INTEL_TYPE_IGDGM, "Atom_N4x0"},
    7477};
    7578
    7679struct intel_info {
     
    140143                gttSize = 512 << 10;
    141144                break;
    142145        }
    143     } else if (info.type == INTEL_TYPE_G33) {
     146    } else if (info.type == INTEL_TYPE_G33
     147               || (info.type & INTEL_TYPE_GROUP_MASK) == INTEL_TYPE_IGD) {
    144148        switch (memoryConfig & G33_GTT_MASK) {
    145149            case G33_GTT_1M:
    146150                gttSize = 1 << 20;
  • src/add-ons/kernel/drivers/graphics/intel_extreme/driver.cpp

     
    5959
    6060    {0x2e32, INTEL_TYPE_GM45, "GMA_X4500_VGA"},
    6161    {0x2a42, INTEL_TYPE_GM45, "GM45"},
     62
     63    {0xa001, INTEL_TYPE_IGDG, "Atom_Dx10"},
     64    {0xa011, INTEL_TYPE_IGDGM, "Atom_N4x0"},
    6265};
    6366
    6467int32 api_version = B_CUR_DRIVER_API_VERSION;
  • src/add-ons/accelerants/intel_extreme/mode.cpp

     
    243243            200000, 1750000, 3500000
    244244        };
    245245        limits = kLimits;
     246    } else if (gInfo->shared_info->device_type.InGroup(INTEL_TYPE_IGD)) {
     247        // TODO: support LVDS output limits as well
     248        // M1 is reserved and must be 0
     249        static const pll_limits kLimits = {
     250            // p, p1, p2, high,   n,   m, m1,  m2
     251            {  5,  1, 10, false,  3,   2,  0,   0}, // min
     252            { 80,  8,  5, true,   6, 256,  0, 254}, // max
     253            200000, 1700000, 3500000
     254        };
     255        limits = kLimits;
    246256    } else if (gInfo->shared_info->device_type.InFamily(INTEL_TYPE_9xx)) {
    247257        // TODO: support LVDS output limits as well
    248258        // (Update: Output limits are adjusted in the computation (post2=7/14))
     
    323333    float best = requestedPixelClock;
    324334    pll_divisors bestDivisors;
    325335
     336    bool is_igd = gInfo->shared_info->device_type.InGroup(INTEL_TYPE_IGD);
    326337    for (divisors.m1 = limits.min.m1; divisors.m1 <= limits.max.m1; divisors.m1++) {
    327         for (divisors.m2 = limits.min.m2; divisors.m2 < divisors.m1
    328                 && divisors.m2 <= limits.max.m2; divisors.m2++) {
     338        for (divisors.m2 = limits.min.m2; divisors.m2 <= limits.max.m2
     339                && ((divisors.m2 < divisors.m1) || is_igd); divisors.m2++) {
    329340            for (divisors.n = limits.min.n; divisors.n <= limits.max.n;
    330341                    divisors.n++) {
    331342                for (divisors.post1 = limits.min.post1;
     
    397408    }
    398409
    399410    pll_divisors divisors;
    400     divisors.m1 = (pllDivisor & DISPLAY_PLL_M1_DIVISOR_MASK)
    401         >> DISPLAY_PLL_M1_DIVISOR_SHIFT;
    402     divisors.m2 = (pllDivisor & DISPLAY_PLL_M2_DIVISOR_MASK)
    403         >> DISPLAY_PLL_M2_DIVISOR_SHIFT;
    404     divisors.n = (pllDivisor & DISPLAY_PLL_N_DIVISOR_MASK)
    405         >> DISPLAY_PLL_N_DIVISOR_SHIFT;
     411    if (gInfo->shared_info->device_type.InGroup(INTEL_TYPE_IGD)) {
     412        divisors.m1 = 0;
     413        divisors.m2 = (pllDivisor & DISPLAY_PLL_M2_DIVISOR_MASK_IGD)
     414            >> DISPLAY_PLL_M2_DIVISOR_SHIFT;
     415        divisors.n = (pllDivisor & DISPLAY_PLL_N_DIVISOR_MASK_IGD)
     416            >> DISPLAY_PLL_N_DIVISOR_SHIFT;
     417    } else {
     418        divisors.m1 = (pllDivisor & DISPLAY_PLL_M1_DIVISOR_MASK)
     419            >> DISPLAY_PLL_M1_DIVISOR_SHIFT;
     420        divisors.m2 = (pllDivisor & DISPLAY_PLL_M2_DIVISOR_MASK)
     421            >> DISPLAY_PLL_M2_DIVISOR_SHIFT;
     422        divisors.n = (pllDivisor & DISPLAY_PLL_N_DIVISOR_MASK)
     423            >> DISPLAY_PLL_N_DIVISOR_SHIFT;     
     424    }
    406425
    407426    pll_limits limits;
    408427    get_pll_limits(limits);
    409428
    410429    if (gInfo->shared_info->device_type.InFamily(INTEL_TYPE_9xx)) {
    411         divisors.post1 = (pll & DISPLAY_PLL_9xx_POST1_DIVISOR_MASK)
    412             >> DISPLAY_PLL_POST1_DIVISOR_SHIFT;
     430        if (gInfo->shared_info->device_type.InGroup(INTEL_TYPE_IGD)) {
     431            divisors.post1 = (pll & DISPLAY_PLL_IGD_POST1_DIVISOR_MASK)
     432                >> DISPLAY_PLL_POST1_DIVISOR_SHIFT_IGD;         
     433        } else {
     434            divisors.post1 = (pll & DISPLAY_PLL_9xx_POST1_DIVISOR_MASK)
     435                >> DISPLAY_PLL_POST1_DIVISOR_SHIFT;
     436        }
    413437
    414438        if (pllRegister == INTEL_DISPLAY_B_PLL
    415439            && !gInfo->shared_info->device_type.InGroup(INTEL_TYPE_96x)) {
     
    725749        }
    726750
    727751        // Compute bitmask from p1 value
    728         dpll |= (1 << (divisors.post1 - 1)) << DISPLAY_PLL_POST1_DIVISOR_SHIFT;
     752        if (gInfo->shared_info->device_type.InGroup(INTEL_TYPE_IGD)) {
     753            dpll |= (1 << (divisors.post1 - 1)) << DISPLAY_PLL_POST1_DIVISOR_SHIFT_IGD;
     754        } else {
     755            dpll |= (1 << (divisors.post1 - 1)) << DISPLAY_PLL_POST1_DIVISOR_SHIFT;
     756        }
    729757        switch (divisors.post2) {
    730758            case 5:
    731759            case 7:
     
    739767            // (I don't know how to detect that)
    740768
    741769        if ((dpll & DISPLAY_PLL_ENABLED) != 0) {
    742             write32(INTEL_DISPLAY_B_PLL_DIVISOR_0,
    743                 (((divisors.n - 2) << DISPLAY_PLL_N_DIVISOR_SHIFT)
    744                     & DISPLAY_PLL_N_DIVISOR_MASK)
    745                 | (((divisors.m1 - 2) << DISPLAY_PLL_M1_DIVISOR_SHIFT)
    746                     & DISPLAY_PLL_M1_DIVISOR_MASK)
    747                 | (((divisors.m2 - 2) << DISPLAY_PLL_M2_DIVISOR_SHIFT)
    748                     & DISPLAY_PLL_M2_DIVISOR_MASK));
     770            if (gInfo->shared_info->device_type.InGroup(INTEL_TYPE_IGD)) {
     771                write32(INTEL_DISPLAY_B_PLL_DIVISOR_0,
     772                    (((1 << (divisors.n - 2)) << DISPLAY_PLL_N_DIVISOR_SHIFT)
     773                        & DISPLAY_PLL_N_DIVISOR_MASK_IGD)
     774                    | (((divisors.m2 - 2) << DISPLAY_PLL_M2_DIVISOR_SHIFT)
     775                        & DISPLAY_PLL_M2_DIVISOR_MASK_IGD));
     776            } else {
     777                write32(INTEL_DISPLAY_B_PLL_DIVISOR_0,
     778                    (((divisors.n - 2) << DISPLAY_PLL_N_DIVISOR_SHIFT)
     779                        & DISPLAY_PLL_N_DIVISOR_MASK)
     780                    | (((divisors.m1 - 2) << DISPLAY_PLL_M1_DIVISOR_SHIFT)
     781                        & DISPLAY_PLL_M1_DIVISOR_MASK)
     782                    | (((divisors.m2 - 2) << DISPLAY_PLL_M2_DIVISOR_SHIFT)
     783                        & DISPLAY_PLL_M2_DIVISOR_MASK));               
     784            }
    749785            write32(INTEL_DISPLAY_B_PLL, dpll & ~DISPLAY_PLL_ENABLED);
    750786            read32(INTEL_DISPLAY_B_PLL);
    751787            spin(150);
     
    771807        write32(INTEL_DISPLAY_LVDS_PORT, lvds);
    772808        read32(INTEL_DISPLAY_LVDS_PORT);
    773809
    774         write32(INTEL_DISPLAY_B_PLL_DIVISOR_0,
    775             (((divisors.n - 2) << DISPLAY_PLL_N_DIVISOR_SHIFT)
    776                 & DISPLAY_PLL_N_DIVISOR_MASK)
    777             | (((divisors.m1 - 2) << DISPLAY_PLL_M1_DIVISOR_SHIFT)
    778                 & DISPLAY_PLL_M1_DIVISOR_MASK)
    779             | (((divisors.m2 - 2) << DISPLAY_PLL_M2_DIVISOR_SHIFT)
    780                 & DISPLAY_PLL_M2_DIVISOR_MASK));
     810        if (gInfo->shared_info->device_type.InGroup(INTEL_TYPE_IGD)) {
     811            write32(INTEL_DISPLAY_B_PLL_DIVISOR_0,
     812                (((1 << (divisors.n - 2)) << DISPLAY_PLL_N_DIVISOR_SHIFT)
     813                    & DISPLAY_PLL_N_DIVISOR_MASK_IGD)
     814                | (((divisors.m2 - 2) << DISPLAY_PLL_M2_DIVISOR_SHIFT)
     815                    & DISPLAY_PLL_M2_DIVISOR_MASK_IGD));
     816        } else {
     817            write32(INTEL_DISPLAY_B_PLL_DIVISOR_0,
     818                (((divisors.n - 2) << DISPLAY_PLL_N_DIVISOR_SHIFT)
     819                    & DISPLAY_PLL_N_DIVISOR_MASK)
     820                | (((divisors.m1 - 2) << DISPLAY_PLL_M1_DIVISOR_SHIFT)
     821                    & DISPLAY_PLL_M1_DIVISOR_MASK)
     822                | (((divisors.m2 - 2) << DISPLAY_PLL_M2_DIVISOR_SHIFT)
     823                    & DISPLAY_PLL_M2_DIVISOR_MASK));   
     824        }
    781825
    782826        write32(INTEL_DISPLAY_B_PLL, dpll);
    783827        read32(INTEL_DISPLAY_B_PLL);
     
    904948        pll_divisors divisors;
    905949        compute_pll_divisors(target, divisors, false);
    906950
    907         write32(INTEL_DISPLAY_A_PLL_DIVISOR_0,
    908             (((divisors.n - 2) << DISPLAY_PLL_N_DIVISOR_SHIFT)
    909                 & DISPLAY_PLL_N_DIVISOR_MASK)
    910             | (((divisors.m1 - 2) << DISPLAY_PLL_M1_DIVISOR_SHIFT)
    911                 & DISPLAY_PLL_M1_DIVISOR_MASK)
    912             | (((divisors.m2 - 2) << DISPLAY_PLL_M2_DIVISOR_SHIFT)
    913                 & DISPLAY_PLL_M2_DIVISOR_MASK));
     951        if (gInfo->shared_info->device_type.InGroup(INTEL_TYPE_IGD)) {
     952            write32(INTEL_DISPLAY_A_PLL_DIVISOR_0,
     953                (((divisors.n - 2) << DISPLAY_PLL_N_DIVISOR_SHIFT)
     954                    & DISPLAY_PLL_N_DIVISOR_MASK_IGD)
     955                | (((divisors.m2 - 2) << DISPLAY_PLL_M2_DIVISOR_SHIFT)
     956                    & DISPLAY_PLL_M2_DIVISOR_MASK_IGD));
     957        } else {
     958            write32(INTEL_DISPLAY_A_PLL_DIVISOR_0,
     959                (((divisors.n - 2) << DISPLAY_PLL_N_DIVISOR_SHIFT)
     960                    & DISPLAY_PLL_N_DIVISOR_MASK)
     961                | (((divisors.m1 - 2) << DISPLAY_PLL_M1_DIVISOR_SHIFT)
     962                    & DISPLAY_PLL_M1_DIVISOR_MASK)
     963                | (((divisors.m2 - 2) << DISPLAY_PLL_M2_DIVISOR_SHIFT)
     964                    & DISPLAY_PLL_M2_DIVISOR_MASK));
     965        }
    914966
    915967        uint32 pll = DISPLAY_PLL_ENABLED | DISPLAY_PLL_NO_VGA_CONTROL;
    916968        if (gInfo->shared_info->device_type.InFamily(INTEL_TYPE_9xx)) {
    917             pll |= ((1 << (divisors.post1 - 1))
    918                     << DISPLAY_PLL_POST1_DIVISOR_SHIFT)
    919                 & DISPLAY_PLL_9xx_POST1_DIVISOR_MASK;
    920 //          pll |= ((divisors.post1 - 1) << DISPLAY_PLL_POST1_DIVISOR_SHIFT)
    921 //              & DISPLAY_PLL_9xx_POST1_DIVISOR_MASK;
     969            if (gInfo->shared_info->device_type.InGroup(INTEL_TYPE_IGD)) {
     970                pll |= ((1 << (divisors.post1 - 1))
     971                        << DISPLAY_PLL_POST1_DIVISOR_SHIFT_IGD)
     972                    & DISPLAY_PLL_IGD_POST1_DIVISOR_MASK;
     973            } else {
     974                pll |= ((1 << (divisors.post1 - 1))
     975                        << DISPLAY_PLL_POST1_DIVISOR_SHIFT)
     976                    & DISPLAY_PLL_9xx_POST1_DIVISOR_MASK;
     977//              pll |= ((divisors.post1 - 1) << DISPLAY_PLL_POST1_DIVISOR_SHIFT)
     978//                  & DISPLAY_PLL_9xx_POST1_DIVISOR_MASK;
     979            }
    922980            if (divisors.post2_high)
    923981                pll |= DISPLAY_PLL_DIVIDE_HIGH;
    924982
  • headers/private/graphics/intel_extreme/intel_extreme.h

     
    3333#define INTEL_TYPE_96x          (INTEL_TYPE_9xx | 0x0100)
    3434#define INTEL_TYPE_Gxx          (INTEL_TYPE_9xx | 0x0200)
    3535#define INTEL_TYPE_G4x          (INTEL_TYPE_9xx | 0x0400)
     36#define INTEL_TYPE_IGD          (INTEL_TYPE_9xx | 0x0800)
    3637// models
    3738#define INTEL_TYPE_MOBILE       0x0008
    3839#define INTEL_TYPE_915          (INTEL_TYPE_91x)
     
    4344#define INTEL_TYPE_G33          (INTEL_TYPE_Gxx)
    4445#define INTEL_TYPE_G45          (INTEL_TYPE_G4x)
    4546#define INTEL_TYPE_GM45         (INTEL_TYPE_G4x | INTEL_TYPE_MOBILE)
     47#define INTEL_TYPE_IGDG         (INTEL_TYPE_IGD)
     48#define INTEL_TYPE_IGDGM        (INTEL_TYPE_IGD | INTEL_TYPE_MOBILE)
    4649
    4750#define DEVICE_NAME             "intel_extreme"
    4851#define INTEL_ACCELERANT_NAME   "intel_extreme.accelerant"
     
    300303#define DISPLAY_PLL_POST1_DIVIDE_2      (1UL << 21)
    301304#define DISPLAY_PLL_POST1_DIVISOR_MASK  0x001f0000
    302305#define DISPLAY_PLL_9xx_POST1_DIVISOR_MASK  0x00ff0000
     306#define DISPLAY_PLL_IGD_POST1_DIVISOR_MASK  0x00ff8000
    303307#define DISPLAY_PLL_POST1_DIVISOR_SHIFT 16
     308#define DISPLAY_PLL_POST1_DIVISOR_SHIFT_IGD 15
    304309#define DISPLAY_PLL_DIVISOR_1           (1UL << 8)
    305310#define DISPLAY_PLL_N_DIVISOR_MASK      0x001f0000
     311#define DISPLAY_PLL_N_DIVISOR_MASK_IGD      0x00ff0000
    306312#define DISPLAY_PLL_M1_DIVISOR_MASK     0x00001f00
    307313#define DISPLAY_PLL_M2_DIVISOR_MASK     0x0000001f
     314#define DISPLAY_PLL_M2_DIVISOR_MASK_IGD     0x000000ff
    308315#define DISPLAY_PLL_N_DIVISOR_SHIFT     16
    309316#define DISPLAY_PLL_M1_DIVISOR_SHIFT    8
    310317#define DISPLAY_PLL_M2_DIVISOR_SHIFT    0