Subversion Repositories Kolibri OS

Rev

Blame | Last modification | View Log | RSS feed

  1. /*
  2.  * Mesa 3-D graphics library
  3.  *
  4.  * Copyright (C) 2012-2013 LunarG, Inc.
  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
  14.  * in 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 AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  20.  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
  21.  * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
  22.  * DEALINGS IN THE SOFTWARE.
  23.  *
  24.  * Authors:
  25.  *    Chia-I Wu <olv@lunarg.com>
  26.  */
  27.  
  28. #include "pipe/p_state.h"
  29. #include "os/os_misc.h"
  30. #include "util/u_format_s3tc.h"
  31. #include "vl/vl_decoder.h"
  32. #include "vl/vl_video_buffer.h"
  33. #include "genhw/genhw.h" /* for GEN6_REG_TIMESTAMP */
  34. #include "core/ilo_fence.h"
  35. #include "core/ilo_format.h"
  36. #include "core/intel_winsys.h"
  37.  
  38. #include "ilo_context.h"
  39. #include "ilo_resource.h"
  40. #include "ilo_transfer.h" /* for ILO_TRANSFER_MAP_BUFFER_ALIGNMENT */
  41. #include "ilo_public.h"
  42. #include "ilo_screen.h"
  43.  
  44. struct pipe_fence_handle {
  45.    struct pipe_reference reference;
  46.  
  47.    struct ilo_fence fence;
  48. };
  49.  
  50. static float
  51. ilo_get_paramf(struct pipe_screen *screen, enum pipe_capf param)
  52. {
  53.    switch (param) {
  54.    case PIPE_CAPF_MAX_LINE_WIDTH:
  55.       /* in U3.7, defined in 3DSTATE_SF */
  56.       return 7.0f;
  57.    case PIPE_CAPF_MAX_LINE_WIDTH_AA:
  58.       /* line width minus one, which is reserved for AA region */
  59.       return 6.0f;
  60.    case PIPE_CAPF_MAX_POINT_WIDTH:
  61.       /* in U8.3, defined in 3DSTATE_SF */
  62.       return 255.0f;
  63.    case PIPE_CAPF_MAX_POINT_WIDTH_AA:
  64.       /* same as point width, as we ignore rasterizer->point_smooth */
  65.       return 255.0f;
  66.    case PIPE_CAPF_MAX_TEXTURE_ANISOTROPY:
  67.       /* [2.0, 16.0], defined in SAMPLER_STATE */
  68.       return 16.0f;
  69.    case PIPE_CAPF_MAX_TEXTURE_LOD_BIAS:
  70.       /* [-16.0, 16.0), defined in SAMPLER_STATE */
  71.       return 15.0f;
  72.    case PIPE_CAPF_GUARD_BAND_LEFT:
  73.    case PIPE_CAPF_GUARD_BAND_TOP:
  74.    case PIPE_CAPF_GUARD_BAND_RIGHT:
  75.    case PIPE_CAPF_GUARD_BAND_BOTTOM:
  76.       /* what are these for? */
  77.       return 0.0f;
  78.  
  79.    default:
  80.       return 0.0f;
  81.    }
  82. }
  83.  
  84. static int
  85. ilo_get_shader_param(struct pipe_screen *screen, unsigned shader,
  86.                      enum pipe_shader_cap param)
  87. {
  88.    switch (shader) {
  89.    case PIPE_SHADER_FRAGMENT:
  90.    case PIPE_SHADER_VERTEX:
  91.    case PIPE_SHADER_GEOMETRY:
  92.       break;
  93.    default:
  94.       return 0;
  95.    }
  96.  
  97.    switch (param) {
  98.    /* the limits are copied from the classic driver */
  99.    case PIPE_SHADER_CAP_MAX_INSTRUCTIONS:
  100.       return (shader == PIPE_SHADER_FRAGMENT) ? 1024 : 16384;
  101.    case PIPE_SHADER_CAP_MAX_ALU_INSTRUCTIONS:
  102.       return (shader == PIPE_SHADER_FRAGMENT) ? 1024 : 0;
  103.    case PIPE_SHADER_CAP_MAX_TEX_INSTRUCTIONS:
  104.       return (shader == PIPE_SHADER_FRAGMENT) ? 1024 : 0;
  105.    case PIPE_SHADER_CAP_MAX_TEX_INDIRECTIONS:
  106.       return (shader == PIPE_SHADER_FRAGMENT) ? 1024 : 0;
  107.    case PIPE_SHADER_CAP_MAX_CONTROL_FLOW_DEPTH:
  108.       return UINT_MAX;
  109.    case PIPE_SHADER_CAP_MAX_INPUTS:
  110.    case PIPE_SHADER_CAP_MAX_OUTPUTS:
  111.       /* this is limited by how many attributes SF can remap */
  112.       return 16;
  113.    case PIPE_SHADER_CAP_MAX_CONST_BUFFER_SIZE:
  114.       return 1024 * sizeof(float[4]);
  115.    case PIPE_SHADER_CAP_MAX_CONST_BUFFERS:
  116.       return ILO_MAX_CONST_BUFFERS;
  117.    case PIPE_SHADER_CAP_MAX_TEMPS:
  118.       return 256;
  119.    case PIPE_SHADER_CAP_MAX_PREDS:
  120.       return 0;
  121.    case PIPE_SHADER_CAP_TGSI_CONT_SUPPORTED:
  122.       return 1;
  123.    case PIPE_SHADER_CAP_INDIRECT_INPUT_ADDR:
  124.       return 0;
  125.    case PIPE_SHADER_CAP_INDIRECT_OUTPUT_ADDR:
  126.       return 0;
  127.    case PIPE_SHADER_CAP_INDIRECT_TEMP_ADDR:
  128.       return (shader == PIPE_SHADER_FRAGMENT) ? 0 : 1;
  129.    case PIPE_SHADER_CAP_INDIRECT_CONST_ADDR:
  130.       return 1;
  131.    case PIPE_SHADER_CAP_SUBROUTINES:
  132.       return 0;
  133.    case PIPE_SHADER_CAP_INTEGERS:
  134.       return 1;
  135.    case PIPE_SHADER_CAP_MAX_TEXTURE_SAMPLERS:
  136.       return ILO_MAX_SAMPLERS;
  137.    case PIPE_SHADER_CAP_MAX_SAMPLER_VIEWS:
  138.       return ILO_MAX_SAMPLER_VIEWS;
  139.    case PIPE_SHADER_CAP_PREFERRED_IR:
  140.       return PIPE_SHADER_IR_TGSI;
  141.    case PIPE_SHADER_CAP_TGSI_SQRT_SUPPORTED:
  142.       return 1;
  143.  
  144.    default:
  145.       return 0;
  146.    }
  147. }
  148.  
  149. static int
  150. ilo_get_video_param(struct pipe_screen *screen,
  151.                     enum pipe_video_profile profile,
  152.                     enum pipe_video_entrypoint entrypoint,
  153.                     enum pipe_video_cap param)
  154. {
  155.    switch (param) {
  156.    case PIPE_VIDEO_CAP_SUPPORTED:
  157.       return vl_profile_supported(screen, profile, entrypoint);
  158.    case PIPE_VIDEO_CAP_NPOT_TEXTURES:
  159.       return 1;
  160.    case PIPE_VIDEO_CAP_MAX_WIDTH:
  161.    case PIPE_VIDEO_CAP_MAX_HEIGHT:
  162.       return vl_video_buffer_max_size(screen);
  163.    case PIPE_VIDEO_CAP_PREFERED_FORMAT:
  164.       return PIPE_FORMAT_NV12;
  165.    case PIPE_VIDEO_CAP_PREFERS_INTERLACED:
  166.       return 1;
  167.    case PIPE_VIDEO_CAP_SUPPORTS_PROGRESSIVE:
  168.       return 1;
  169.    case PIPE_VIDEO_CAP_SUPPORTS_INTERLACED:
  170.       return 0;
  171.    case PIPE_VIDEO_CAP_MAX_LEVEL:
  172.       return vl_level_supported(screen, profile);
  173.    default:
  174.       return 0;
  175.    }
  176. }
  177.  
  178. static int
  179. ilo_get_compute_param(struct pipe_screen *screen,
  180.                       enum pipe_compute_cap param,
  181.                       void *ret)
  182. {
  183.    struct ilo_screen *is = ilo_screen(screen);
  184.    union {
  185.       const char *ir_target;
  186.       uint64_t grid_dimension;
  187.       uint64_t max_grid_size[3];
  188.       uint64_t max_block_size[3];
  189.       uint64_t max_threads_per_block;
  190.       uint64_t max_global_size;
  191.       uint64_t max_local_size;
  192.       uint64_t max_private_size;
  193.       uint64_t max_input_size;
  194.       uint64_t max_mem_alloc_size;
  195.       uint32_t max_clock_frequency;
  196.       uint32_t max_compute_units;
  197.       uint32_t images_supported;
  198.    } val;
  199.    const void *ptr;
  200.    int size;
  201.  
  202.    switch (param) {
  203.    case PIPE_COMPUTE_CAP_IR_TARGET:
  204.       val.ir_target = "ilog";
  205.  
  206.       ptr = val.ir_target;
  207.       size = strlen(val.ir_target) + 1;
  208.       break;
  209.    case PIPE_COMPUTE_CAP_GRID_DIMENSION:
  210.       val.grid_dimension = Elements(val.max_grid_size);
  211.  
  212.       ptr = &val.grid_dimension;
  213.       size = sizeof(val.grid_dimension);
  214.       break;
  215.    case PIPE_COMPUTE_CAP_MAX_GRID_SIZE:
  216.       val.max_grid_size[0] = 0xffffffffu;
  217.       val.max_grid_size[1] = 0xffffffffu;
  218.       val.max_grid_size[2] = 0xffffffffu;
  219.  
  220.       ptr = &val.max_grid_size;
  221.       size = sizeof(val.max_grid_size);
  222.       break;
  223.    case PIPE_COMPUTE_CAP_MAX_BLOCK_SIZE:
  224.       val.max_block_size[0] = 1024;
  225.       val.max_block_size[1] = 1024;
  226.       val.max_block_size[2] = 1024;
  227.  
  228.       ptr = &val.max_block_size;
  229.       size = sizeof(val.max_block_size);
  230.       break;
  231.  
  232.    case PIPE_COMPUTE_CAP_MAX_THREADS_PER_BLOCK:
  233.       val.max_threads_per_block = 1024;
  234.  
  235.       ptr = &val.max_threads_per_block;
  236.       size = sizeof(val.max_threads_per_block);
  237.       break;
  238.    case PIPE_COMPUTE_CAP_MAX_GLOBAL_SIZE:
  239.       /* \see ilo_max_resource_size */
  240.       val.max_global_size = 1u << 31;
  241.  
  242.       ptr = &val.max_global_size;
  243.       size = sizeof(val.max_global_size);
  244.       break;
  245.    case PIPE_COMPUTE_CAP_MAX_LOCAL_SIZE:
  246.       /* Shared Local Memory Size of INTERFACE_DESCRIPTOR_DATA */
  247.       val.max_local_size = 64 * 1024;
  248.  
  249.       ptr = &val.max_local_size;
  250.       size = sizeof(val.max_local_size);
  251.       break;
  252.    case PIPE_COMPUTE_CAP_MAX_PRIVATE_SIZE:
  253.       /* scratch size */
  254.       val.max_private_size = 12 * 1024;
  255.  
  256.       ptr = &val.max_private_size;
  257.       size = sizeof(val.max_private_size);
  258.       break;
  259.    case PIPE_COMPUTE_CAP_MAX_INPUT_SIZE:
  260.       val.max_input_size = 1024;
  261.  
  262.       ptr = &val.max_input_size;
  263.       size = sizeof(val.max_input_size);
  264.       break;
  265.    case PIPE_COMPUTE_CAP_MAX_MEM_ALLOC_SIZE:
  266.       val.max_mem_alloc_size = 1u << 31;
  267.  
  268.       ptr = &val.max_mem_alloc_size;
  269.       size = sizeof(val.max_mem_alloc_size);
  270.       break;
  271.    case PIPE_COMPUTE_CAP_MAX_CLOCK_FREQUENCY:
  272.       val.max_clock_frequency = 1000;
  273.  
  274.       ptr = &val.max_clock_frequency;
  275.       size = sizeof(val.max_clock_frequency);
  276.       break;
  277.    case PIPE_COMPUTE_CAP_MAX_COMPUTE_UNITS:
  278.       val.max_compute_units = is->dev.eu_count;
  279.  
  280.       ptr = &val.max_compute_units;
  281.       size = sizeof(val.max_compute_units);
  282.       break;
  283.    case PIPE_COMPUTE_CAP_IMAGES_SUPPORTED:
  284.       val.images_supported = 1;
  285.  
  286.       ptr = &val.images_supported;
  287.       size = sizeof(val.images_supported);
  288.       break;
  289.    default:
  290.       ptr = NULL;
  291.       size = 0;
  292.       break;
  293.    }
  294.  
  295.    if (ret)
  296.       memcpy(ret, ptr, size);
  297.  
  298.    return size;
  299. }
  300.  
  301. static int
  302. ilo_get_param(struct pipe_screen *screen, enum pipe_cap param)
  303. {
  304.    struct ilo_screen *is = ilo_screen(screen);
  305.  
  306.    switch (param) {
  307.    case PIPE_CAP_NPOT_TEXTURES:
  308.    case PIPE_CAP_TWO_SIDED_STENCIL:
  309.       return true;
  310.    case PIPE_CAP_MAX_DUAL_SOURCE_RENDER_TARGETS:
  311.       return 0; /* TODO */
  312.    case PIPE_CAP_ANISOTROPIC_FILTER:
  313.    case PIPE_CAP_POINT_SPRITE:
  314.       return true;
  315.    case PIPE_CAP_MAX_RENDER_TARGETS:
  316.       return ILO_MAX_DRAW_BUFFERS;
  317.    case PIPE_CAP_OCCLUSION_QUERY:
  318.    case PIPE_CAP_QUERY_TIME_ELAPSED:
  319.    case PIPE_CAP_TEXTURE_SHADOW_MAP:
  320.    case PIPE_CAP_TEXTURE_SWIZZLE: /* must be supported for shadow map */
  321.       return true;
  322.    case PIPE_CAP_MAX_TEXTURE_2D_LEVELS:
  323.       /*
  324.        * As defined in SURFACE_STATE, we have
  325.        *
  326.        *           Max WxHxD for 2D and CUBE     Max WxHxD for 3D
  327.        *  GEN6           8192x8192x512            2048x2048x2048
  328.        *  GEN7         16384x16384x2048           2048x2048x2048
  329.        */
  330.       return (ilo_dev_gen(&is->dev) >= ILO_GEN(7)) ? 15 : 14;
  331.    case PIPE_CAP_MAX_TEXTURE_3D_LEVELS:
  332.       return 12;
  333.    case PIPE_CAP_MAX_TEXTURE_CUBE_LEVELS:
  334.       return (ilo_dev_gen(&is->dev) >= ILO_GEN(7)) ? 15 : 14;
  335.    case PIPE_CAP_TEXTURE_MIRROR_CLAMP:
  336.       return false;
  337.    case PIPE_CAP_BLEND_EQUATION_SEPARATE:
  338.    case PIPE_CAP_SM3:
  339.       return true;
  340.    case PIPE_CAP_MAX_STREAM_OUTPUT_BUFFERS:
  341.       if (ilo_dev_gen(&is->dev) >= ILO_GEN(7) && !is->dev.has_gen7_sol_reset)
  342.          return 0;
  343.       return ILO_MAX_SO_BUFFERS;
  344.    case PIPE_CAP_PRIMITIVE_RESTART:
  345.       return true;
  346.    case PIPE_CAP_INDEP_BLEND_ENABLE:
  347.    case PIPE_CAP_INDEP_BLEND_FUNC:
  348.       return true;
  349.    case PIPE_CAP_MAX_TEXTURE_ARRAY_LAYERS:
  350.       return (ilo_dev_gen(&is->dev) >= ILO_GEN(7)) ? 2048 : 512;
  351.    case PIPE_CAP_TGSI_FS_COORD_ORIGIN_UPPER_LEFT:
  352.    case PIPE_CAP_TGSI_FS_COORD_ORIGIN_LOWER_LEFT:
  353.    case PIPE_CAP_TGSI_FS_COORD_PIXEL_CENTER_HALF_INTEGER:
  354.    case PIPE_CAP_TGSI_FS_COORD_PIXEL_CENTER_INTEGER:
  355.    case PIPE_CAP_DEPTH_CLIP_DISABLE:
  356.       return true;
  357.    case PIPE_CAP_SHADER_STENCIL_EXPORT:
  358.       return false;
  359.    case PIPE_CAP_TGSI_INSTANCEID:
  360.    case PIPE_CAP_VERTEX_ELEMENT_INSTANCE_DIVISOR:
  361.       return true;
  362.    case PIPE_CAP_FRAGMENT_COLOR_CLAMPED:
  363.       return false;
  364.    case PIPE_CAP_MIXED_COLORBUFFER_FORMATS:
  365.       return true;
  366.    case PIPE_CAP_SEAMLESS_CUBE_MAP:
  367.    case PIPE_CAP_SEAMLESS_CUBE_MAP_PER_TEXTURE:
  368.       return true;
  369.    case PIPE_CAP_MIN_TEXTURE_GATHER_OFFSET:
  370.    case PIPE_CAP_MIN_TEXEL_OFFSET:
  371.       return -8;
  372.    case PIPE_CAP_MAX_TEXTURE_GATHER_OFFSET:
  373.    case PIPE_CAP_MAX_TEXEL_OFFSET:
  374.       return 7;
  375.    case PIPE_CAP_CONDITIONAL_RENDER:
  376.    case PIPE_CAP_TEXTURE_BARRIER:
  377.       return true;
  378.    case PIPE_CAP_MAX_STREAM_OUTPUT_SEPARATE_COMPONENTS:
  379.       return ILO_MAX_SO_BINDINGS / ILO_MAX_SO_BUFFERS;
  380.    case PIPE_CAP_MAX_STREAM_OUTPUT_INTERLEAVED_COMPONENTS:
  381.       return ILO_MAX_SO_BINDINGS;
  382.    case PIPE_CAP_STREAM_OUTPUT_PAUSE_RESUME:
  383.       if (ilo_dev_gen(&is->dev) >= ILO_GEN(7))
  384.          return is->dev.has_gen7_sol_reset;
  385.       else
  386.          return false; /* TODO */
  387.    case PIPE_CAP_TGSI_CAN_COMPACT_CONSTANTS:
  388.       return false;
  389.    case PIPE_CAP_VERTEX_COLOR_UNCLAMPED:
  390.       return true;
  391.    case PIPE_CAP_VERTEX_COLOR_CLAMPED:
  392.       return false;
  393.    case PIPE_CAP_GLSL_FEATURE_LEVEL:
  394.       return 140;
  395.    case PIPE_CAP_QUADS_FOLLOW_PROVOKING_VERTEX_CONVENTION:
  396.    case PIPE_CAP_USER_VERTEX_BUFFERS:
  397.       return false;
  398.    case PIPE_CAP_VERTEX_BUFFER_OFFSET_4BYTE_ALIGNED_ONLY:
  399.    case PIPE_CAP_VERTEX_BUFFER_STRIDE_4BYTE_ALIGNED_ONLY:
  400.    case PIPE_CAP_VERTEX_ELEMENT_SRC_OFFSET_4BYTE_ALIGNED_ONLY:
  401.       return false;
  402.    case PIPE_CAP_MAX_VERTEX_ATTRIB_STRIDE:
  403.       return 2048;
  404.    case PIPE_CAP_COMPUTE:
  405.       return false; /* TODO */
  406.    case PIPE_CAP_USER_INDEX_BUFFERS:
  407.    case PIPE_CAP_USER_CONSTANT_BUFFERS:
  408.       return true;
  409.    case PIPE_CAP_CONSTANT_BUFFER_OFFSET_ALIGNMENT:
  410.       /* imposed by OWord (Dual) Block Read */
  411.       return 16;
  412.    case PIPE_CAP_START_INSTANCE:
  413.       return true;
  414.    case PIPE_CAP_QUERY_TIMESTAMP:
  415.       return is->dev.has_timestamp;
  416.    case PIPE_CAP_TEXTURE_MULTISAMPLE:
  417.       return false; /* TODO */
  418.    case PIPE_CAP_MIN_MAP_BUFFER_ALIGNMENT:
  419.       return ILO_TRANSFER_MAP_BUFFER_ALIGNMENT;
  420.    case PIPE_CAP_CUBE_MAP_ARRAY:
  421.    case PIPE_CAP_TEXTURE_BUFFER_OBJECTS:
  422.       return true;
  423.    case PIPE_CAP_TEXTURE_BUFFER_OFFSET_ALIGNMENT:
  424.       return 1;
  425.    case PIPE_CAP_TGSI_TEXCOORD:
  426.       return false;
  427.    case PIPE_CAP_PREFER_BLIT_BASED_TEXTURE_TRANSFER:
  428.    case PIPE_CAP_QUERY_PIPELINE_STATISTICS:
  429.       return true;
  430.    case PIPE_CAP_TEXTURE_BORDER_COLOR_QUIRK:
  431.       return 0;
  432.    case PIPE_CAP_MAX_TEXTURE_BUFFER_SIZE:
  433.       /* a GEN6_SURFTYPE_BUFFER can have up to 2^27 elements */
  434.       return 1 << 27;
  435.    case PIPE_CAP_MAX_VIEWPORTS:
  436.       return ILO_MAX_VIEWPORTS;
  437.    case PIPE_CAP_ENDIANNESS:
  438.       return PIPE_ENDIAN_LITTLE;
  439.    case PIPE_CAP_MIXED_FRAMEBUFFER_SIZES:
  440.       return true;
  441.    case PIPE_CAP_TGSI_VS_LAYER_VIEWPORT:
  442.    case PIPE_CAP_MAX_GEOMETRY_OUTPUT_VERTICES:
  443.    case PIPE_CAP_MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS:
  444.    case PIPE_CAP_MAX_TEXTURE_GATHER_COMPONENTS:
  445.    case PIPE_CAP_TEXTURE_GATHER_SM5:
  446.       return 0;
  447.    case PIPE_CAP_BUFFER_MAP_PERSISTENT_COHERENT:
  448.       return true;
  449.    case PIPE_CAP_FAKE_SW_MSAA:
  450.    case PIPE_CAP_TEXTURE_QUERY_LOD:
  451.    case PIPE_CAP_SAMPLE_SHADING:
  452.    case PIPE_CAP_TEXTURE_GATHER_OFFSETS:
  453.    case PIPE_CAP_TGSI_VS_WINDOW_SPACE_POSITION:
  454.    case PIPE_CAP_MAX_VERTEX_STREAMS:
  455.    case PIPE_CAP_DRAW_INDIRECT:
  456.    case PIPE_CAP_TGSI_FS_FINE_DERIVATIVE:
  457.    case PIPE_CAP_CONDITIONAL_RENDER_INVERTED:
  458.    case PIPE_CAP_SAMPLER_VIEW_TARGET:
  459.    case PIPE_CAP_MULTISAMPLE_Z_RESOLVE:
  460.    case PIPE_CAP_RESOURCE_FROM_USER_MEMORY:
  461.    case PIPE_CAP_DEVICE_RESET_STATUS_QUERY:
  462.       return 0;
  463.  
  464.    case PIPE_CAP_VENDOR_ID:
  465.       return 0x8086;
  466.    case PIPE_CAP_DEVICE_ID:
  467.       return is->dev.devid;
  468.    case PIPE_CAP_ACCELERATED:
  469.       return true;
  470.    case PIPE_CAP_VIDEO_MEMORY: {
  471.       /* Once a batch uses more than 75% of the maximum mappable size, we
  472.        * assume that there's some fragmentation, and we start doing extra
  473.        * flushing, etc.  That's the big cliff apps will care about.
  474.        */
  475.       const uint64_t gpu_memory = is->dev.aperture_total * 3 / 4;
  476.       uint64_t system_memory;
  477.  
  478.       if (!os_get_total_physical_memory(&system_memory))
  479.          return 0;
  480.  
  481.       return (int) (MIN2(gpu_memory, system_memory) >> 20);
  482.    }
  483.    case PIPE_CAP_UMA:
  484.       return true;
  485.    case PIPE_CAP_CLIP_HALFZ:
  486.       return true;
  487.    case PIPE_CAP_VERTEXID_NOBASE:
  488.       return false;
  489.    case PIPE_CAP_POLYGON_OFFSET_CLAMP:
  490.       return true;
  491.  
  492.    default:
  493.       return 0;
  494.    }
  495. }
  496.  
  497. static const char *
  498. ilo_get_vendor(struct pipe_screen *screen)
  499. {
  500.    return "LunarG, Inc.";
  501. }
  502.  
  503. static const char *
  504. ilo_get_device_vendor(struct pipe_screen *screen)
  505. {
  506.    return "Intel";
  507. }
  508.  
  509. static const char *
  510. ilo_get_name(struct pipe_screen *screen)
  511. {
  512.    struct ilo_screen *is = ilo_screen(screen);
  513.    const char *chipset = NULL;
  514.  
  515.    if (gen_is_chv(is->dev.devid)) {
  516.       chipset = "Intel(R) Cherryview";
  517.    } else if (gen_is_bdw(is->dev.devid)) {
  518.       /* this is likely wrong */
  519.       if (gen_is_desktop(is->dev.devid))
  520.          chipset = "Intel(R) Broadwell Desktop";
  521.       else if (gen_is_mobile(is->dev.devid))
  522.          chipset = "Intel(R) Broadwell Mobile";
  523.       else if (gen_is_server(is->dev.devid))
  524.          chipset = "Intel(R) Broadwell Server";
  525.    } else if (gen_is_vlv(is->dev.devid)) {
  526.       chipset = "Intel(R) Bay Trail";
  527.    } else if (gen_is_hsw(is->dev.devid)) {
  528.       if (gen_is_desktop(is->dev.devid))
  529.          chipset = "Intel(R) Haswell Desktop";
  530.       else if (gen_is_mobile(is->dev.devid))
  531.          chipset = "Intel(R) Haswell Mobile";
  532.       else if (gen_is_server(is->dev.devid))
  533.          chipset = "Intel(R) Haswell Server";
  534.    } else if (gen_is_ivb(is->dev.devid)) {
  535.       if (gen_is_desktop(is->dev.devid))
  536.          chipset = "Intel(R) Ivybridge Desktop";
  537.       else if (gen_is_mobile(is->dev.devid))
  538.          chipset = "Intel(R) Ivybridge Mobile";
  539.       else if (gen_is_server(is->dev.devid))
  540.          chipset = "Intel(R) Ivybridge Server";
  541.    } else if (gen_is_snb(is->dev.devid)) {
  542.       if (gen_is_desktop(is->dev.devid))
  543.          chipset = "Intel(R) Sandybridge Desktop";
  544.       else if (gen_is_mobile(is->dev.devid))
  545.          chipset = "Intel(R) Sandybridge Mobile";
  546.       else if (gen_is_server(is->dev.devid))
  547.          chipset = "Intel(R) Sandybridge Server";
  548.    }
  549.  
  550.    if (!chipset)
  551.       chipset = "Unknown Intel Chipset";
  552.  
  553.    return chipset;
  554. }
  555.  
  556. static uint64_t
  557. ilo_get_timestamp(struct pipe_screen *screen)
  558. {
  559.    struct ilo_screen *is = ilo_screen(screen);
  560.    union {
  561.       uint64_t val;
  562.       uint32_t dw[2];
  563.    } timestamp;
  564.  
  565.    intel_winsys_read_reg(is->dev.winsys, GEN6_REG_TIMESTAMP, &timestamp.val);
  566.  
  567.    /*
  568.     * From the Ivy Bridge PRM, volume 1 part 3, page 107:
  569.     *
  570.     *     "Note: This timestamp register reflects the value of the PCU TSC.
  571.     *      The PCU TSC counts 10ns increments; this timestamp reflects bits
  572.     *      38:3 of the TSC (i.e. 80ns granularity, rolling over every 1.5
  573.     *      hours)."
  574.     *
  575.     * However, it seems dw[0] is garbage and dw[1] contains the lower 32 bits
  576.     * of the timestamp.  We will have to live with a timestamp that rolls over
  577.     * every ~343 seconds.
  578.     *
  579.     * See also brw_get_timestamp().
  580.     */
  581.    return (uint64_t) timestamp.dw[1] * 80;
  582. }
  583.  
  584. static boolean
  585. ilo_is_format_supported(struct pipe_screen *screen,
  586.                         enum pipe_format format,
  587.                         enum pipe_texture_target target,
  588.                         unsigned sample_count,
  589.                         unsigned bindings)
  590. {
  591.    struct ilo_screen *is = ilo_screen(screen);
  592.    const struct ilo_dev *dev = &is->dev;
  593.  
  594.    if (!util_format_is_supported(format, bindings))
  595.       return false;
  596.  
  597.    /* no MSAA support yet */
  598.    if (sample_count > 1)
  599.       return false;
  600.  
  601.    if ((bindings & PIPE_BIND_DEPTH_STENCIL) &&
  602.        !ilo_format_support_zs(dev, format))
  603.       return false;
  604.  
  605.    if ((bindings & PIPE_BIND_RENDER_TARGET) &&
  606.        !ilo_format_support_rt(dev, format))
  607.       return false;
  608.  
  609.    if ((bindings & PIPE_BIND_SAMPLER_VIEW) &&
  610.        !ilo_format_support_sampler(dev, format))
  611.       return false;
  612.  
  613.    if ((bindings & PIPE_BIND_VERTEX_BUFFER) &&
  614.        !ilo_format_support_vb(dev, format))
  615.       return false;
  616.  
  617.    return true;
  618. }
  619.  
  620. static boolean
  621. ilo_is_video_format_supported(struct pipe_screen *screen,
  622.                               enum pipe_format format,
  623.                               enum pipe_video_profile profile,
  624.                               enum pipe_video_entrypoint entrypoint)
  625. {
  626.    return vl_video_buffer_is_format_supported(screen, format, profile, entrypoint);
  627. }
  628.  
  629. static void
  630. ilo_screen_fence_reference(struct pipe_screen *screen,
  631.                            struct pipe_fence_handle **ptr,
  632.                            struct pipe_fence_handle *fence)
  633. {
  634.    struct pipe_fence_handle *old;
  635.  
  636.    if (likely(ptr)) {
  637.       old = *ptr;
  638.       *ptr = fence;
  639.    } else {
  640.       old = NULL;
  641.    }
  642.  
  643.    STATIC_ASSERT(&((struct pipe_fence_handle *) NULL)->reference == NULL);
  644.    if (pipe_reference(&old->reference, &fence->reference)) {
  645.       ilo_fence_cleanup(&old->fence);
  646.       FREE(old);
  647.    }
  648. }
  649.  
  650. static boolean
  651. ilo_screen_fence_finish(struct pipe_screen *screen,
  652.                         struct pipe_fence_handle *fence,
  653.                         uint64_t timeout)
  654. {
  655.    const int64_t wait_timeout = (timeout > INT64_MAX) ? -1 : timeout;
  656.    bool signaled;
  657.  
  658.    signaled = ilo_fence_wait(&fence->fence, wait_timeout);
  659.    /* XXX not thread safe */
  660.    if (signaled)
  661.       ilo_fence_set_seq_bo(&fence->fence, NULL);
  662.  
  663.    return signaled;
  664. }
  665.  
  666. static boolean
  667. ilo_screen_fence_signalled(struct pipe_screen *screen,
  668.                            struct pipe_fence_handle *fence)
  669. {
  670.    return ilo_screen_fence_finish(screen, fence, 0);
  671. }
  672.  
  673. /**
  674.  * Create a fence for \p bo.  When \p bo is not NULL, it must be submitted
  675.  * before waited on or checked.
  676.  */
  677. struct pipe_fence_handle *
  678. ilo_screen_fence_create(struct pipe_screen *screen, struct intel_bo *bo)
  679. {
  680.    struct ilo_screen *is = ilo_screen(screen);
  681.    struct pipe_fence_handle *fence;
  682.  
  683.    fence = CALLOC_STRUCT(pipe_fence_handle);
  684.    if (!fence)
  685.       return NULL;
  686.  
  687.    pipe_reference_init(&fence->reference, 1);
  688.  
  689.    ilo_fence_init(&fence->fence, &is->dev);
  690.    ilo_fence_set_seq_bo(&fence->fence, bo);
  691.  
  692.    return fence;
  693. }
  694.  
  695. static void
  696. ilo_screen_destroy(struct pipe_screen *screen)
  697. {
  698.    struct ilo_screen *is = ilo_screen(screen);
  699.  
  700.    ilo_dev_cleanup(&is->dev);
  701.  
  702.    FREE(is);
  703. }
  704.  
  705. struct pipe_screen *
  706. ilo_screen_create(struct intel_winsys *ws)
  707. {
  708.    struct ilo_screen *is;
  709.  
  710.    ilo_debug_init("ILO_DEBUG");
  711.  
  712.    is = CALLOC_STRUCT(ilo_screen);
  713.    if (!is)
  714.       return NULL;
  715.  
  716.    if (!ilo_dev_init(&is->dev, ws)) {
  717.       FREE(is);
  718.       return NULL;
  719.    }
  720.  
  721.    util_format_s3tc_init();
  722.  
  723.    is->base.destroy = ilo_screen_destroy;
  724.    is->base.get_name = ilo_get_name;
  725.    is->base.get_vendor = ilo_get_vendor;
  726.    is->base.get_device_vendor = ilo_get_device_vendor;
  727.    is->base.get_param = ilo_get_param;
  728.    is->base.get_paramf = ilo_get_paramf;
  729.    is->base.get_shader_param = ilo_get_shader_param;
  730.    is->base.get_video_param = ilo_get_video_param;
  731.    is->base.get_compute_param = ilo_get_compute_param;
  732.  
  733.    is->base.get_timestamp = ilo_get_timestamp;
  734.  
  735.    is->base.is_format_supported = ilo_is_format_supported;
  736.    is->base.is_video_format_supported = ilo_is_video_format_supported;
  737.  
  738.    is->base.flush_frontbuffer = NULL;
  739.  
  740.    is->base.fence_reference = ilo_screen_fence_reference;
  741.    is->base.fence_signalled = ilo_screen_fence_signalled;
  742.    is->base.fence_finish = ilo_screen_fence_finish;
  743.  
  744.    is->base.get_driver_query_info = NULL;
  745.  
  746.    ilo_init_context_functions(is);
  747.    ilo_init_resource_functions(is);
  748.  
  749.    return &is->base;
  750. }
  751.