Subversion Repositories Kolibri OS

Rev

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

  1. /*
  2.  * Copyright © 2008-2010 Intel Corporation
  3.  *
  4.  * Permission is hereby granted, free of charge, to any person obtaining a
  5.  * copy of this software and associated documentation files (the "Software"),
  6.  * to deal in the Software without restriction, including without limitation
  7.  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  8.  * and/or sell copies of the Software, and to permit persons to whom the
  9.  * Software is furnished to do so, subject to the following conditions:
  10.  *
  11.  * The above copyright notice and this permission notice (including the next
  12.  * paragraph) shall be included in all copies or substantial portions of the
  13.  * Software.
  14.  *
  15.  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  16.  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  17.  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  18.  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  19.  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
  20.  * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
  21.  * IN THE SOFTWARE.
  22.  *
  23.  * Authors:
  24.  *    Eric Anholt <eric@anholt.net>
  25.  *    Zou Nan hai <nanhai.zou@intel.com>
  26.  *    Xiang Hai hao<haihao.xiang@intel.com>
  27.  *
  28.  */
  29. #define iowrite32(v, addr)      writel((v), (addr))
  30. #define ioread32(addr)          readl(addr)
  31.  
  32. #include "drmP.h"
  33. #include "drm.h"
  34. #include "i915_drv.h"
  35. #include "i915_drm.h"
  36. //#include "i915_trace.h"
  37. #include "intel_drv.h"
  38.  
  39. static inline int ring_space(struct intel_ring_buffer *ring)
  40. {
  41.         int space = (ring->head & HEAD_ADDR) - (ring->tail + 8);
  42.         if (space < 0)
  43.                 space += ring->size;
  44.         return space;
  45. }
  46.  
  47. static u32 i915_gem_get_seqno(struct drm_device *dev)
  48. {
  49.         drm_i915_private_t *dev_priv = dev->dev_private;
  50.         u32 seqno;
  51.  
  52.         seqno = dev_priv->next_seqno;
  53.  
  54.         /* reserve 0 for non-seqno */
  55.         if (++dev_priv->next_seqno == 0)
  56.                 dev_priv->next_seqno = 1;
  57.  
  58.         return seqno;
  59. }
  60.  
  61. static int
  62. render_ring_flush(struct intel_ring_buffer *ring,
  63.                   u32   invalidate_domains,
  64.                   u32   flush_domains)
  65. {
  66.         struct drm_device *dev = ring->dev;
  67.         u32 cmd;
  68.         int ret;
  69.  
  70.         /*
  71.          * read/write caches:
  72.          *
  73.          * I915_GEM_DOMAIN_RENDER is always invalidated, but is
  74.          * only flushed if MI_NO_WRITE_FLUSH is unset.  On 965, it is
  75.          * also flushed at 2d versus 3d pipeline switches.
  76.          *
  77.          * read-only caches:
  78.          *
  79.          * I915_GEM_DOMAIN_SAMPLER is flushed on pre-965 if
  80.          * MI_READ_FLUSH is set, and is always flushed on 965.
  81.          *
  82.          * I915_GEM_DOMAIN_COMMAND may not exist?
  83.          *
  84.          * I915_GEM_DOMAIN_INSTRUCTION, which exists on 965, is
  85.          * invalidated when MI_EXE_FLUSH is set.
  86.          *
  87.          * I915_GEM_DOMAIN_VERTEX, which exists on 965, is
  88.          * invalidated with every MI_FLUSH.
  89.          *
  90.          * TLBs:
  91.          *
  92.          * On 965, TLBs associated with I915_GEM_DOMAIN_COMMAND
  93.          * and I915_GEM_DOMAIN_CPU in are invalidated at PTE write and
  94.          * I915_GEM_DOMAIN_RENDER and I915_GEM_DOMAIN_SAMPLER
  95.          * are flushed at any MI_FLUSH.
  96.          */
  97.  
  98.         cmd = MI_FLUSH | MI_NO_WRITE_FLUSH;
  99.         if ((invalidate_domains|flush_domains) &
  100.             I915_GEM_DOMAIN_RENDER)
  101.                 cmd &= ~MI_NO_WRITE_FLUSH;
  102.         if (INTEL_INFO(dev)->gen < 4) {
  103.                 /*
  104.                  * On the 965, the sampler cache always gets flushed
  105.                  * and this bit is reserved.
  106.                  */
  107.                 if (invalidate_domains & I915_GEM_DOMAIN_SAMPLER)
  108.                         cmd |= MI_READ_FLUSH;
  109.         }
  110.         if (invalidate_domains & I915_GEM_DOMAIN_INSTRUCTION)
  111.                 cmd |= MI_EXE_FLUSH;
  112.  
  113.         if (invalidate_domains & I915_GEM_DOMAIN_COMMAND &&
  114.             (IS_G4X(dev) || IS_GEN5(dev)))
  115.                 cmd |= MI_INVALIDATE_ISP;
  116.  
  117.         ret = intel_ring_begin(ring, 2);
  118.         if (ret)
  119.                 return ret;
  120.  
  121.         intel_ring_emit(ring, cmd);
  122.         intel_ring_emit(ring, MI_NOOP);
  123.         intel_ring_advance(ring);
  124.  
  125.         return 0;
  126. }
  127.  
  128. static void ring_write_tail(struct intel_ring_buffer *ring,
  129.                             u32 value)
  130. {
  131.         drm_i915_private_t *dev_priv = ring->dev->dev_private;
  132.         I915_WRITE_TAIL(ring, value);
  133. }
  134.  
  135. u32 intel_ring_get_active_head(struct intel_ring_buffer *ring)
  136. {
  137.         drm_i915_private_t *dev_priv = ring->dev->dev_private;
  138.         u32 acthd_reg = INTEL_INFO(ring->dev)->gen >= 4 ?
  139.                         RING_ACTHD(ring->mmio_base) : ACTHD;
  140.  
  141.         return I915_READ(acthd_reg);
  142. }
  143.  
  144.  
  145. static int init_ring_common(struct intel_ring_buffer *ring)
  146. {
  147.         drm_i915_private_t *dev_priv = ring->dev->dev_private;
  148.         struct drm_i915_gem_object *obj = ring->obj;
  149.         u32 head;
  150.  
  151.     ENTER();
  152.  
  153.         /* Stop the ring if it's running. */
  154.         I915_WRITE_CTL(ring, 0);
  155.         I915_WRITE_HEAD(ring, 0);
  156.         ring->write_tail(ring, 0);
  157.  
  158.         /* Initialize the ring. */
  159.         I915_WRITE_START(ring, obj->gtt_offset);
  160.         head = I915_READ_HEAD(ring) & HEAD_ADDR;
  161.  
  162.         /* G45 ring initialization fails to reset head to zero */
  163.         if (head != 0) {
  164.                 DRM_DEBUG_KMS("%s head not reset to zero "
  165.                               "ctl %08x head %08x tail %08x start %08x\n",
  166.                               ring->name,
  167.                               I915_READ_CTL(ring),
  168.                               I915_READ_HEAD(ring),
  169.                               I915_READ_TAIL(ring),
  170.                               I915_READ_START(ring));
  171.  
  172.                 I915_WRITE_HEAD(ring, 0);
  173.  
  174.                 if (I915_READ_HEAD(ring) & HEAD_ADDR) {
  175.                         DRM_ERROR("failed to set %s head to zero "
  176.                                   "ctl %08x head %08x tail %08x start %08x\n",
  177.                                   ring->name,
  178.                                   I915_READ_CTL(ring),
  179.                                   I915_READ_HEAD(ring),
  180.                                   I915_READ_TAIL(ring),
  181.                                   I915_READ_START(ring));
  182.                 }
  183.         }
  184.  
  185.         I915_WRITE_CTL(ring,
  186.                         ((ring->size - PAGE_SIZE) & RING_NR_PAGES)
  187.                         | RING_REPORT_64K | RING_VALID);
  188.  
  189.         /* If the head is still not zero, the ring is dead */
  190.         if ((I915_READ_CTL(ring) & RING_VALID) == 0 ||
  191.             I915_READ_START(ring) != obj->gtt_offset ||
  192.             (I915_READ_HEAD(ring) & HEAD_ADDR) != 0) {
  193.                 DRM_ERROR("%s initialization failed "
  194.                                 "ctl %08x head %08x tail %08x start %08x\n",
  195.                                 ring->name,
  196.                                 I915_READ_CTL(ring),
  197.                                 I915_READ_HEAD(ring),
  198.                                 I915_READ_TAIL(ring),
  199.                                 I915_READ_START(ring));
  200.                 return -EIO;
  201.         }
  202.  
  203.     ring->head = I915_READ_HEAD(ring);
  204.     ring->tail = I915_READ_TAIL(ring) & TAIL_ADDR;
  205.     ring->space = ring_space(ring);
  206.  
  207.     LEAVE();
  208.  
  209.         return 0;
  210. }
  211.  
  212. #if 0
  213.  
  214. /*
  215.  * 965+ support PIPE_CONTROL commands, which provide finer grained control
  216.  * over cache flushing.
  217.  */
  218. struct pipe_control {
  219.         struct drm_i915_gem_object *obj;
  220.         volatile u32 *cpu_page;
  221.         u32 gtt_offset;
  222. };
  223.  
  224. static int
  225. init_pipe_control(struct intel_ring_buffer *ring)
  226. {
  227.         struct pipe_control *pc;
  228.         struct drm_i915_gem_object *obj;
  229.         int ret;
  230.  
  231.         if (ring->private)
  232.                 return 0;
  233.  
  234.         pc = kmalloc(sizeof(*pc), GFP_KERNEL);
  235.         if (!pc)
  236.                 return -ENOMEM;
  237.  
  238.         obj = i915_gem_alloc_object(ring->dev, 4096);
  239.         if (obj == NULL) {
  240.                 DRM_ERROR("Failed to allocate seqno page\n");
  241.                 ret = -ENOMEM;
  242.                 goto err;
  243.         }
  244.  
  245.         i915_gem_object_set_cache_level(obj, I915_CACHE_LLC);
  246.  
  247.         ret = i915_gem_object_pin(obj, 4096, true);
  248.         if (ret)
  249.                 goto err_unref;
  250.  
  251.         pc->gtt_offset = obj->gtt_offset;
  252.         pc->cpu_page =  kmap(obj->pages[0]);
  253.         if (pc->cpu_page == NULL)
  254.                 goto err_unpin;
  255.  
  256.         pc->obj = obj;
  257.         ring->private = pc;
  258.         return 0;
  259.  
  260. err_unpin:
  261.         i915_gem_object_unpin(obj);
  262. err_unref:
  263.         drm_gem_object_unreference(&obj->base);
  264. err:
  265.         kfree(pc);
  266.         return ret;
  267. }
  268.  
  269. static void
  270. cleanup_pipe_control(struct intel_ring_buffer *ring)
  271. {
  272.         struct pipe_control *pc = ring->private;
  273.         struct drm_i915_gem_object *obj;
  274.  
  275.         if (!ring->private)
  276.                 return;
  277.  
  278.         obj = pc->obj;
  279.         kunmap(obj->pages[0]);
  280.         i915_gem_object_unpin(obj);
  281.         drm_gem_object_unreference(&obj->base);
  282.  
  283.         kfree(pc);
  284.         ring->private = NULL;
  285. }
  286.  
  287. #endif
  288.  
  289. static int init_render_ring(struct intel_ring_buffer *ring)
  290. {
  291.         struct drm_device *dev = ring->dev;
  292.         struct drm_i915_private *dev_priv = dev->dev_private;
  293.  
  294.     ENTER();
  295.  
  296.         int ret = init_ring_common(ring);
  297.  
  298.  
  299.         if (INTEL_INFO(dev)->gen > 3) {
  300.                 int mode = VS_TIMER_DISPATCH << 16 | VS_TIMER_DISPATCH;
  301.                 if (IS_GEN6(dev) || IS_GEN7(dev))
  302.                         mode |= MI_FLUSH_ENABLE << 16 | MI_FLUSH_ENABLE;
  303.                 I915_WRITE(MI_MODE, mode);
  304.                 if (IS_GEN7(dev))
  305.                         I915_WRITE(GFX_MODE_GEN7,
  306.                                    GFX_MODE_DISABLE(GFX_TLB_INVALIDATE_ALWAYS) |
  307.                                    GFX_MODE_ENABLE(GFX_REPLAY_MODE));
  308.         }
  309.  
  310.         if (INTEL_INFO(dev)->gen >= 6) {
  311.         } else if (IS_GEN5(dev)) {
  312. //       ret = init_pipe_control(ring);
  313.                 if (ret)
  314.                         return ret;
  315.         }
  316.  
  317.     LEAVE();
  318.  
  319.         return ret;
  320. }
  321.  
  322. #if 0
  323.  
  324. static void render_ring_cleanup(struct intel_ring_buffer *ring)
  325. {
  326.         if (!ring->private)
  327.                 return;
  328.  
  329.         cleanup_pipe_control(ring);
  330. }
  331.  
  332. static void
  333. update_semaphore(struct intel_ring_buffer *ring, int i, u32 seqno)
  334. {
  335.         struct drm_device *dev = ring->dev;
  336.         struct drm_i915_private *dev_priv = dev->dev_private;
  337.         int id;
  338.  
  339.         /*
  340.          * cs -> 1 = vcs, 0 = bcs
  341.          * vcs -> 1 = bcs, 0 = cs,
  342.          * bcs -> 1 = cs, 0 = vcs.
  343.          */
  344.         id = ring - dev_priv->ring;
  345.         id += 2 - i;
  346.         id %= 3;
  347.  
  348.         intel_ring_emit(ring,
  349.                         MI_SEMAPHORE_MBOX |
  350.                         MI_SEMAPHORE_REGISTER |
  351.                         MI_SEMAPHORE_UPDATE);
  352.         intel_ring_emit(ring, seqno);
  353.         intel_ring_emit(ring,
  354.                         RING_SYNC_0(dev_priv->ring[id].mmio_base) + 4*i);
  355. }
  356.  
  357. static int
  358. gen6_add_request(struct intel_ring_buffer *ring,
  359.                  u32 *result)
  360. {
  361.         u32 seqno;
  362.         int ret;
  363.  
  364.         ret = intel_ring_begin(ring, 10);
  365.         if (ret)
  366.                 return ret;
  367.  
  368.         seqno = i915_gem_get_seqno(ring->dev);
  369.         update_semaphore(ring, 0, seqno);
  370.         update_semaphore(ring, 1, seqno);
  371.  
  372.         intel_ring_emit(ring, MI_STORE_DWORD_INDEX);
  373.         intel_ring_emit(ring, I915_GEM_HWS_INDEX << MI_STORE_DWORD_INDEX_SHIFT);
  374.         intel_ring_emit(ring, seqno);
  375.         intel_ring_emit(ring, MI_USER_INTERRUPT);
  376.         intel_ring_advance(ring);
  377.  
  378.         *result = seqno;
  379.         return 0;
  380. }
  381.  
  382. int
  383. intel_ring_sync(struct intel_ring_buffer *ring,
  384.                 struct intel_ring_buffer *to,
  385.                 u32 seqno)
  386. {
  387.         int ret;
  388.  
  389.         ret = intel_ring_begin(ring, 4);
  390.         if (ret)
  391.                 return ret;
  392.  
  393.         intel_ring_emit(ring,
  394.                         MI_SEMAPHORE_MBOX |
  395.                         MI_SEMAPHORE_REGISTER |
  396.                         intel_ring_sync_index(ring, to) << 17 |
  397.                         MI_SEMAPHORE_COMPARE);
  398.         intel_ring_emit(ring, seqno);
  399.         intel_ring_emit(ring, 0);
  400.         intel_ring_emit(ring, MI_NOOP);
  401.         intel_ring_advance(ring);
  402.  
  403.         return 0;
  404. }
  405.  
  406. #define PIPE_CONTROL_FLUSH(ring__, addr__)                                      \
  407. do {                                                                    \
  408.         intel_ring_emit(ring__, GFX_OP_PIPE_CONTROL | PIPE_CONTROL_QW_WRITE |           \
  409.                  PIPE_CONTROL_DEPTH_STALL | 2);                         \
  410.         intel_ring_emit(ring__, (addr__) | PIPE_CONTROL_GLOBAL_GTT);                    \
  411.         intel_ring_emit(ring__, 0);                                                     \
  412.         intel_ring_emit(ring__, 0);                                                     \
  413. } while (0)
  414.  
  415. static int
  416. pc_render_add_request(struct intel_ring_buffer *ring,
  417.                       u32 *result)
  418. {
  419.         struct drm_device *dev = ring->dev;
  420.         u32 seqno = i915_gem_get_seqno(dev);
  421.         struct pipe_control *pc = ring->private;
  422.         u32 scratch_addr = pc->gtt_offset + 128;
  423.         int ret;
  424.  
  425.         /* For Ironlake, MI_USER_INTERRUPT was deprecated and apparently
  426.          * incoherent with writes to memory, i.e. completely fubar,
  427.          * so we need to use PIPE_NOTIFY instead.
  428.          *
  429.          * However, we also need to workaround the qword write
  430.          * incoherence by flushing the 6 PIPE_NOTIFY buffers out to
  431.          * memory before requesting an interrupt.
  432.          */
  433.         ret = intel_ring_begin(ring, 32);
  434.         if (ret)
  435.                 return ret;
  436.  
  437.         intel_ring_emit(ring, GFX_OP_PIPE_CONTROL | PIPE_CONTROL_QW_WRITE |
  438.                         PIPE_CONTROL_WC_FLUSH | PIPE_CONTROL_TC_FLUSH);
  439.         intel_ring_emit(ring, pc->gtt_offset | PIPE_CONTROL_GLOBAL_GTT);
  440.         intel_ring_emit(ring, seqno);
  441.         intel_ring_emit(ring, 0);
  442.         PIPE_CONTROL_FLUSH(ring, scratch_addr);
  443.         scratch_addr += 128; /* write to separate cachelines */
  444.         PIPE_CONTROL_FLUSH(ring, scratch_addr);
  445.         scratch_addr += 128;
  446.         PIPE_CONTROL_FLUSH(ring, scratch_addr);
  447.         scratch_addr += 128;
  448.         PIPE_CONTROL_FLUSH(ring, scratch_addr);
  449.         scratch_addr += 128;
  450.         PIPE_CONTROL_FLUSH(ring, scratch_addr);
  451.         scratch_addr += 128;
  452.         PIPE_CONTROL_FLUSH(ring, scratch_addr);
  453.         intel_ring_emit(ring, GFX_OP_PIPE_CONTROL | PIPE_CONTROL_QW_WRITE |
  454.                         PIPE_CONTROL_WC_FLUSH | PIPE_CONTROL_TC_FLUSH |
  455.                         PIPE_CONTROL_NOTIFY);
  456.         intel_ring_emit(ring, pc->gtt_offset | PIPE_CONTROL_GLOBAL_GTT);
  457.         intel_ring_emit(ring, seqno);
  458.         intel_ring_emit(ring, 0);
  459.         intel_ring_advance(ring);
  460.  
  461.         *result = seqno;
  462.         return 0;
  463. }
  464.  
  465. static int
  466. render_ring_add_request(struct intel_ring_buffer *ring,
  467.                         u32 *result)
  468. {
  469.         struct drm_device *dev = ring->dev;
  470.         u32 seqno = i915_gem_get_seqno(dev);
  471.         int ret;
  472.  
  473.         ret = intel_ring_begin(ring, 4);
  474.         if (ret)
  475.                 return ret;
  476.  
  477.         intel_ring_emit(ring, MI_STORE_DWORD_INDEX);
  478.         intel_ring_emit(ring, I915_GEM_HWS_INDEX << MI_STORE_DWORD_INDEX_SHIFT);
  479.         intel_ring_emit(ring, seqno);
  480.         intel_ring_emit(ring, MI_USER_INTERRUPT);
  481.         intel_ring_advance(ring);
  482.  
  483.         *result = seqno;
  484.         return 0;
  485. }
  486.  
  487. static u32
  488. ring_get_seqno(struct intel_ring_buffer *ring)
  489. {
  490.         return intel_read_status_page(ring, I915_GEM_HWS_INDEX);
  491. }
  492.  
  493. static u32
  494. pc_render_get_seqno(struct intel_ring_buffer *ring)
  495. {
  496.         struct pipe_control *pc = ring->private;
  497.         return pc->cpu_page[0];
  498. }
  499.  
  500. static void
  501. ironlake_enable_irq(drm_i915_private_t *dev_priv, u32 mask)
  502. {
  503.         dev_priv->gt_irq_mask &= ~mask;
  504.         I915_WRITE(GTIMR, dev_priv->gt_irq_mask);
  505.         POSTING_READ(GTIMR);
  506. }
  507.  
  508. static void
  509. ironlake_disable_irq(drm_i915_private_t *dev_priv, u32 mask)
  510. {
  511.         dev_priv->gt_irq_mask |= mask;
  512.         I915_WRITE(GTIMR, dev_priv->gt_irq_mask);
  513.         POSTING_READ(GTIMR);
  514. }
  515.  
  516. static void
  517. i915_enable_irq(drm_i915_private_t *dev_priv, u32 mask)
  518. {
  519.         dev_priv->irq_mask &= ~mask;
  520.         I915_WRITE(IMR, dev_priv->irq_mask);
  521.         POSTING_READ(IMR);
  522. }
  523.  
  524. static void
  525. i915_disable_irq(drm_i915_private_t *dev_priv, u32 mask)
  526. {
  527.         dev_priv->irq_mask |= mask;
  528.         I915_WRITE(IMR, dev_priv->irq_mask);
  529.         POSTING_READ(IMR);
  530. }
  531.  
  532. static bool
  533. render_ring_get_irq(struct intel_ring_buffer *ring)
  534. {
  535.         struct drm_device *dev = ring->dev;
  536.         drm_i915_private_t *dev_priv = dev->dev_private;
  537.  
  538.         if (!dev->irq_enabled)
  539.                 return false;
  540.  
  541.         spin_lock(&ring->irq_lock);
  542.         if (ring->irq_refcount++ == 0) {
  543.                 if (HAS_PCH_SPLIT(dev))
  544.                         ironlake_enable_irq(dev_priv,
  545.                                             GT_PIPE_NOTIFY | GT_USER_INTERRUPT);
  546.                 else
  547.                         i915_enable_irq(dev_priv, I915_USER_INTERRUPT);
  548.         }
  549.         spin_unlock(&ring->irq_lock);
  550.  
  551.         return true;
  552. }
  553.  
  554. static void
  555. render_ring_put_irq(struct intel_ring_buffer *ring)
  556. {
  557.         struct drm_device *dev = ring->dev;
  558.         drm_i915_private_t *dev_priv = dev->dev_private;
  559.  
  560.         spin_lock(&ring->irq_lock);
  561.         if (--ring->irq_refcount == 0) {
  562.                 if (HAS_PCH_SPLIT(dev))
  563.                         ironlake_disable_irq(dev_priv,
  564.                                              GT_USER_INTERRUPT |
  565.                                              GT_PIPE_NOTIFY);
  566.                 else
  567.                         i915_disable_irq(dev_priv, I915_USER_INTERRUPT);
  568.         }
  569.         spin_unlock(&ring->irq_lock);
  570. }
  571.  
  572. void intel_ring_setup_status_page(struct intel_ring_buffer *ring)
  573. {
  574.         struct drm_device *dev = ring->dev;
  575.         drm_i915_private_t *dev_priv = ring->dev->dev_private;
  576.         u32 mmio = 0;
  577.  
  578.         /* The ring status page addresses are no longer next to the rest of
  579.          * the ring registers as of gen7.
  580.          */
  581.         if (IS_GEN7(dev)) {
  582.                 switch (ring->id) {
  583.                 case RING_RENDER:
  584.                         mmio = RENDER_HWS_PGA_GEN7;
  585.                         break;
  586.                 case RING_BLT:
  587.                         mmio = BLT_HWS_PGA_GEN7;
  588.                         break;
  589.                 case RING_BSD:
  590.                         mmio = BSD_HWS_PGA_GEN7;
  591.                         break;
  592.                 }
  593.         } else if (IS_GEN6(ring->dev)) {
  594.                 mmio = RING_HWS_PGA_GEN6(ring->mmio_base);
  595.         } else {
  596.                 mmio = RING_HWS_PGA(ring->mmio_base);
  597.         }
  598.  
  599.         I915_WRITE(mmio, (u32)ring->status_page.gfx_addr);
  600.         POSTING_READ(mmio);
  601. }
  602. #endif
  603.  
  604. static int
  605. bsd_ring_flush(struct intel_ring_buffer *ring,
  606.                u32     invalidate_domains,
  607.                u32     flush_domains)
  608. {
  609.         int ret;
  610.  
  611.         ret = intel_ring_begin(ring, 2);
  612.         if (ret)
  613.                 return ret;
  614.  
  615.         intel_ring_emit(ring, MI_FLUSH);
  616.         intel_ring_emit(ring, MI_NOOP);
  617.         intel_ring_advance(ring);
  618.         return 0;
  619. }
  620.  
  621. #if 0
  622.  
  623. static int
  624. ring_add_request(struct intel_ring_buffer *ring,
  625.                  u32 *result)
  626. {
  627.         u32 seqno;
  628.         int ret;
  629.  
  630.         ret = intel_ring_begin(ring, 4);
  631.         if (ret)
  632.                 return ret;
  633.  
  634.         seqno = i915_gem_get_seqno(ring->dev);
  635.  
  636.         intel_ring_emit(ring, MI_STORE_DWORD_INDEX);
  637.         intel_ring_emit(ring, I915_GEM_HWS_INDEX << MI_STORE_DWORD_INDEX_SHIFT);
  638.         intel_ring_emit(ring, seqno);
  639.         intel_ring_emit(ring, MI_USER_INTERRUPT);
  640.         intel_ring_advance(ring);
  641.  
  642.         *result = seqno;
  643.         return 0;
  644. }
  645.  
  646. static bool
  647. gen6_ring_get_irq(struct intel_ring_buffer *ring, u32 gflag, u32 rflag)
  648. {
  649.         struct drm_device *dev = ring->dev;
  650.         drm_i915_private_t *dev_priv = dev->dev_private;
  651.  
  652.         if (!dev->irq_enabled)
  653.                return false;
  654.  
  655.         spin_lock(&ring->irq_lock);
  656.         if (ring->irq_refcount++ == 0) {
  657.                 ring->irq_mask &= ~rflag;
  658.                 I915_WRITE_IMR(ring, ring->irq_mask);
  659.                 ironlake_enable_irq(dev_priv, gflag);
  660.         }
  661.         spin_unlock(&ring->irq_lock);
  662.  
  663.         return true;
  664. }
  665.  
  666. static void
  667. gen6_ring_put_irq(struct intel_ring_buffer *ring, u32 gflag, u32 rflag)
  668. {
  669.         struct drm_device *dev = ring->dev;
  670.         drm_i915_private_t *dev_priv = dev->dev_private;
  671.  
  672.         spin_lock(&ring->irq_lock);
  673.         if (--ring->irq_refcount == 0) {
  674.                 ring->irq_mask |= rflag;
  675.                 I915_WRITE_IMR(ring, ring->irq_mask);
  676.                 ironlake_disable_irq(dev_priv, gflag);
  677.         }
  678.         spin_unlock(&ring->irq_lock);
  679. }
  680.  
  681. static bool
  682. bsd_ring_get_irq(struct intel_ring_buffer *ring)
  683. {
  684.         struct drm_device *dev = ring->dev;
  685.         drm_i915_private_t *dev_priv = dev->dev_private;
  686.  
  687.         if (!dev->irq_enabled)
  688.                 return false;
  689.  
  690.         spin_lock(&ring->irq_lock);
  691.         if (ring->irq_refcount++ == 0) {
  692.                 if (IS_G4X(dev))
  693.                         i915_enable_irq(dev_priv, I915_BSD_USER_INTERRUPT);
  694.                 else
  695.                         ironlake_enable_irq(dev_priv, GT_BSD_USER_INTERRUPT);
  696.         }
  697.         spin_unlock(&ring->irq_lock);
  698.  
  699.         return true;
  700. }
  701. static void
  702. bsd_ring_put_irq(struct intel_ring_buffer *ring)
  703. {
  704.         struct drm_device *dev = ring->dev;
  705.         drm_i915_private_t *dev_priv = dev->dev_private;
  706.  
  707.         spin_lock(&ring->irq_lock);
  708.         if (--ring->irq_refcount == 0) {
  709.                 if (IS_G4X(dev))
  710.                         i915_disable_irq(dev_priv, I915_BSD_USER_INTERRUPT);
  711.                 else
  712.                         ironlake_disable_irq(dev_priv, GT_BSD_USER_INTERRUPT);
  713.         }
  714.         spin_unlock(&ring->irq_lock);
  715. }
  716.  
  717. static int
  718. ring_dispatch_execbuffer(struct intel_ring_buffer *ring, u32 offset, u32 length)
  719. {
  720.         int ret;
  721.  
  722.         ret = intel_ring_begin(ring, 2);
  723.         if (ret)
  724.                 return ret;
  725.  
  726.         intel_ring_emit(ring,
  727.                         MI_BATCH_BUFFER_START | (2 << 6) |
  728.                         MI_BATCH_NON_SECURE_I965);
  729.         intel_ring_emit(ring, offset);
  730.         intel_ring_advance(ring);
  731.  
  732.         return 0;
  733. }
  734.  
  735. static int
  736. render_ring_dispatch_execbuffer(struct intel_ring_buffer *ring,
  737.                                 u32 offset, u32 len)
  738. {
  739.         struct drm_device *dev = ring->dev;
  740.         int ret;
  741.  
  742.         if (IS_I830(dev) || IS_845G(dev)) {
  743.                 ret = intel_ring_begin(ring, 4);
  744.                 if (ret)
  745.                         return ret;
  746.  
  747.                 intel_ring_emit(ring, MI_BATCH_BUFFER);
  748.                 intel_ring_emit(ring, offset | MI_BATCH_NON_SECURE);
  749.                 intel_ring_emit(ring, offset + len - 8);
  750.                 intel_ring_emit(ring, 0);
  751.         } else {
  752.                 ret = intel_ring_begin(ring, 2);
  753.                 if (ret)
  754.                         return ret;
  755.  
  756.                 if (INTEL_INFO(dev)->gen >= 4) {
  757.                         intel_ring_emit(ring,
  758.                                         MI_BATCH_BUFFER_START | (2 << 6) |
  759.                                         MI_BATCH_NON_SECURE_I965);
  760.                         intel_ring_emit(ring, offset);
  761.                 } else {
  762.                         intel_ring_emit(ring,
  763.                                         MI_BATCH_BUFFER_START | (2 << 6));
  764.                         intel_ring_emit(ring, offset | MI_BATCH_NON_SECURE);
  765.                 }
  766.         }
  767.         intel_ring_advance(ring);
  768.  
  769.         return 0;
  770. }
  771.  
  772. static void cleanup_status_page(struct intel_ring_buffer *ring)
  773. {
  774.         drm_i915_private_t *dev_priv = ring->dev->dev_private;
  775.         struct drm_i915_gem_object *obj;
  776.  
  777.         obj = ring->status_page.obj;
  778.         if (obj == NULL)
  779.                 return;
  780.  
  781.         kunmap(obj->pages[0]);
  782.         i915_gem_object_unpin(obj);
  783.         drm_gem_object_unreference(&obj->base);
  784.         ring->status_page.obj = NULL;
  785.  
  786.         memset(&dev_priv->hws_map, 0, sizeof(dev_priv->hws_map));
  787. }
  788.  
  789. static int init_status_page(struct intel_ring_buffer *ring)
  790. {
  791.         struct drm_device *dev = ring->dev;
  792.         drm_i915_private_t *dev_priv = dev->dev_private;
  793.         struct drm_i915_gem_object *obj;
  794.         int ret;
  795.  
  796.         obj = i915_gem_alloc_object(dev, 4096);
  797.         if (obj == NULL) {
  798.                 DRM_ERROR("Failed to allocate status page\n");
  799.                 ret = -ENOMEM;
  800.                 goto err;
  801.         }
  802.  
  803.         i915_gem_object_set_cache_level(obj, I915_CACHE_LLC);
  804.  
  805.         ret = i915_gem_object_pin(obj, 4096, true);
  806.         if (ret != 0) {
  807.                 goto err_unref;
  808.         }
  809.  
  810.         ring->status_page.gfx_addr = obj->gtt_offset;
  811.         ring->status_page.page_addr = kmap(obj->pages[0]);
  812.         if (ring->status_page.page_addr == NULL) {
  813.                 memset(&dev_priv->hws_map, 0, sizeof(dev_priv->hws_map));
  814.                 goto err_unpin;
  815.         }
  816.         ring->status_page.obj = obj;
  817.         memset(ring->status_page.page_addr, 0, PAGE_SIZE);
  818.  
  819.         intel_ring_setup_status_page(ring);
  820.         DRM_DEBUG_DRIVER("%s hws offset: 0x%08x\n",
  821.                         ring->name, ring->status_page.gfx_addr);
  822.  
  823.         return 0;
  824.  
  825. err_unpin:
  826.         i915_gem_object_unpin(obj);
  827. err_unref:
  828.         drm_gem_object_unreference(&obj->base);
  829. err:
  830.         return ret;
  831. }
  832. #endif
  833.  
  834. int intel_init_ring_buffer(struct drm_device *dev,
  835.                            struct intel_ring_buffer *ring)
  836. {
  837.     struct drm_i915_gem_object *obj=NULL;
  838.         int ret;
  839.     ENTER();
  840.         ring->dev = dev;
  841.         INIT_LIST_HEAD(&ring->active_list);
  842.         INIT_LIST_HEAD(&ring->request_list);
  843.         INIT_LIST_HEAD(&ring->gpu_write_list);
  844.  
  845. //   init_waitqueue_head(&ring->irq_queue);
  846. //   spin_lock_init(&ring->irq_lock);
  847.     ring->irq_mask = ~0;
  848.  
  849.         if (I915_NEED_GFX_HWS(dev)) {
  850. //       ret = init_status_page(ring);
  851. //       if (ret)
  852. //           return ret;
  853.         }
  854.  
  855.     obj = i915_gem_alloc_object(dev, ring->size);
  856.         if (obj == NULL) {
  857.                 DRM_ERROR("Failed to allocate ringbuffer\n");
  858.                 ret = -ENOMEM;
  859.                 goto err_hws;
  860.         }
  861.  
  862.         ring->obj = obj;
  863.  
  864.     ret = i915_gem_object_pin(obj, PAGE_SIZE, true);
  865.         if (ret)
  866.                 goto err_unref;
  867.  
  868.         ring->map.size = ring->size;
  869.     ring->map.offset = get_bus_addr() + obj->gtt_offset;
  870.         ring->map.type = 0;
  871.         ring->map.flags = 0;
  872.         ring->map.mtrr = 0;
  873.  
  874. //   drm_core_ioremap_wc(&ring->map, dev);
  875.  
  876.     ring->map.handle = ioremap(ring->map.offset, ring->map.size);
  877.  
  878.         if (ring->map.handle == NULL) {
  879.                 DRM_ERROR("Failed to map ringbuffer.\n");
  880.                 ret = -EINVAL;
  881.                 goto err_unpin;
  882.         }
  883.  
  884.         ring->virtual_start = ring->map.handle;
  885.         ret = ring->init(ring);
  886.         if (ret)
  887.                 goto err_unmap;
  888.  
  889.         /* Workaround an erratum on the i830 which causes a hang if
  890.          * the TAIL pointer points to within the last 2 cachelines
  891.          * of the buffer.
  892.          */
  893.         ring->effective_size = ring->size;
  894.         if (IS_I830(ring->dev))
  895.                 ring->effective_size -= 128;
  896.     LEAVE();
  897.         return 0;
  898.  
  899. err_unmap:
  900. //   drm_core_ioremapfree(&ring->map, dev);
  901.     FreeKernelSpace(ring->virtual_start);
  902. err_unpin:
  903. //   i915_gem_object_unpin(obj);
  904. err_unref:
  905. //   drm_gem_object_unreference(&obj->base);
  906.         ring->obj = NULL;
  907. err_hws:
  908. //   cleanup_status_page(ring);
  909.         return ret;
  910. }
  911.  
  912.  
  913. void intel_cleanup_ring_buffer(struct intel_ring_buffer *ring)
  914. {
  915.         struct drm_i915_private *dev_priv;
  916.         int ret;
  917.  
  918.         if (ring->obj == NULL)
  919.                 return;
  920.  
  921.         /* Disable the ring buffer. The ring must be idle at this point */
  922.         dev_priv = ring->dev->dev_private;
  923.         ret = intel_wait_ring_idle(ring);
  924.         if (ret)
  925.                 DRM_ERROR("failed to quiesce %s whilst cleaning up: %d\n",
  926.                           ring->name, ret);
  927.  
  928.         I915_WRITE_CTL(ring, 0);
  929.  
  930. //   drm_core_ioremapfree(&ring->map, ring->dev);
  931.  
  932. //   i915_gem_object_unpin(ring->obj);
  933. //   drm_gem_object_unreference(&ring->obj->base);
  934.         ring->obj = NULL;
  935.  
  936.         if (ring->cleanup)
  937.                 ring->cleanup(ring);
  938.  
  939. //   cleanup_status_page(ring);
  940. }
  941.  
  942.  
  943. static int intel_wrap_ring_buffer(struct intel_ring_buffer *ring)
  944. {
  945.         unsigned int *virt;
  946.         int rem = ring->size - ring->tail;
  947.  
  948.         if (ring->space < rem) {
  949.                 int ret = intel_wait_ring_buffer(ring, rem);
  950.                 if (ret)
  951.                         return ret;
  952.         }
  953.  
  954.         virt = (unsigned int *)(ring->virtual_start + ring->tail);
  955.         rem /= 8;
  956.         while (rem--) {
  957.                 *virt++ = MI_NOOP;
  958.                 *virt++ = MI_NOOP;
  959.         }
  960.  
  961.         ring->tail = 0;
  962.         ring->space = ring_space(ring);
  963.  
  964.         return 0;
  965. }
  966.  
  967. int intel_wait_ring_buffer(struct intel_ring_buffer *ring, int n)
  968. {
  969.         struct drm_device *dev = ring->dev;
  970.         struct drm_i915_private *dev_priv = dev->dev_private;
  971.         unsigned long end;
  972.         u32 head;
  973.  
  974.         /* If the reported head position has wrapped or hasn't advanced,
  975.          * fallback to the slow and accurate path.
  976.          */
  977.         head = intel_read_status_page(ring, 4);
  978.         if (head > ring->head) {
  979.                 ring->head = head;
  980.                 ring->space = ring_space(ring);
  981.                 if (ring->space >= n)
  982.                         return 0;
  983.         }
  984.  
  985. //   trace_i915_ring_wait_begin(ring);
  986.         end = jiffies + 3 * HZ;
  987.         do {
  988.                 ring->head = I915_READ_HEAD(ring);
  989.                 ring->space = ring_space(ring);
  990.                 if (ring->space >= n) {
  991. //           trace_i915_ring_wait_end(ring);
  992.                         return 0;
  993.                 }
  994.  
  995.                 if (dev->primary->master) {
  996.                         struct drm_i915_master_private *master_priv = dev->primary->master->driver_priv;
  997.                         if (master_priv->sarea_priv)
  998.                                 master_priv->sarea_priv->perf_boxes |= I915_BOX_WAIT;
  999.                 }
  1000.  
  1001.                 msleep(1);
  1002.                 if (atomic_read(&dev_priv->mm.wedged))
  1003.                         return -EAGAIN;
  1004.         } while (!time_after(jiffies, end));
  1005. //   trace_i915_ring_wait_end(ring);
  1006.         return -EBUSY;
  1007. }
  1008.  
  1009. int intel_ring_begin(struct intel_ring_buffer *ring,
  1010.                      int num_dwords)
  1011. {
  1012.         struct drm_i915_private *dev_priv = ring->dev->dev_private;
  1013.         int n = 4*num_dwords;
  1014.         int ret;
  1015.  
  1016.         if (unlikely(atomic_read(&dev_priv->mm.wedged)))
  1017.                 return -EIO;
  1018.  
  1019.         if (unlikely(ring->tail + n > ring->effective_size)) {
  1020.                 ret = intel_wrap_ring_buffer(ring);
  1021.                 if (unlikely(ret))
  1022.                         return ret;
  1023.         }
  1024.  
  1025.         if (unlikely(ring->space < n)) {
  1026.                 ret = intel_wait_ring_buffer(ring, n);
  1027.                 if (unlikely(ret))
  1028.                         return ret;
  1029.         }
  1030.  
  1031.         ring->space -= n;
  1032.         return 0;
  1033. }
  1034.  
  1035. void intel_ring_advance(struct intel_ring_buffer *ring)
  1036. {
  1037.         ring->tail &= ring->size - 1;
  1038.         ring->write_tail(ring, ring->tail);
  1039. }
  1040.  
  1041.  
  1042. static const struct intel_ring_buffer render_ring = {
  1043.         .name                   = "render ring",
  1044.         .id                     = RING_RENDER,
  1045.         .mmio_base              = RENDER_RING_BASE,
  1046.         .size                   = 32 * PAGE_SIZE,
  1047.         .init                   = init_render_ring,
  1048.     .write_tail     = ring_write_tail,
  1049.     .flush          = render_ring_flush,
  1050. //   .add_request        = render_ring_add_request,
  1051. //   .get_seqno      = ring_get_seqno,
  1052. //   .irq_get        = render_ring_get_irq,
  1053. //   .irq_put        = render_ring_put_irq,
  1054. //   .dispatch_execbuffer    = render_ring_dispatch_execbuffer,
  1055. //       .cleanup            = render_ring_cleanup,
  1056. };
  1057.  
  1058. /* ring buffer for bit-stream decoder */
  1059.  
  1060. static const struct intel_ring_buffer bsd_ring = {
  1061.         .name                   = "bsd ring",
  1062.         .id                     = RING_BSD,
  1063.         .mmio_base              = BSD_RING_BASE,
  1064.         .size                   = 32 * PAGE_SIZE,
  1065.         .init                   = init_ring_common,
  1066.         .write_tail             = ring_write_tail,
  1067.     .flush          = bsd_ring_flush,
  1068. //   .add_request        = ring_add_request,
  1069. //   .get_seqno      = ring_get_seqno,
  1070. //   .irq_get        = bsd_ring_get_irq,
  1071. //   .irq_put        = bsd_ring_put_irq,
  1072. //   .dispatch_execbuffer    = ring_dispatch_execbuffer,
  1073. };
  1074.  
  1075.  
  1076. static void gen6_bsd_ring_write_tail(struct intel_ring_buffer *ring,
  1077.                                      u32 value)
  1078. {
  1079.        drm_i915_private_t *dev_priv = ring->dev->dev_private;
  1080.  
  1081.        /* Every tail move must follow the sequence below */
  1082.        I915_WRITE(GEN6_BSD_SLEEP_PSMI_CONTROL,
  1083.                GEN6_BSD_SLEEP_PSMI_CONTROL_RC_ILDL_MESSAGE_MODIFY_MASK |
  1084.                GEN6_BSD_SLEEP_PSMI_CONTROL_RC_ILDL_MESSAGE_DISABLE);
  1085.        I915_WRITE(GEN6_BSD_RNCID, 0x0);
  1086.  
  1087.        if (wait_for((I915_READ(GEN6_BSD_SLEEP_PSMI_CONTROL) &
  1088.                                GEN6_BSD_SLEEP_PSMI_CONTROL_IDLE_INDICATOR) == 0,
  1089.                        50))
  1090.                DRM_ERROR("timed out waiting for IDLE Indicator\n");
  1091.  
  1092.        I915_WRITE_TAIL(ring, value);
  1093.        I915_WRITE(GEN6_BSD_SLEEP_PSMI_CONTROL,
  1094.                GEN6_BSD_SLEEP_PSMI_CONTROL_RC_ILDL_MESSAGE_MODIFY_MASK |
  1095.                GEN6_BSD_SLEEP_PSMI_CONTROL_RC_ILDL_MESSAGE_ENABLE);
  1096. }
  1097.  
  1098.  
  1099. static int gen6_ring_flush(struct intel_ring_buffer *ring,
  1100.                            u32 invalidate, u32 flush)
  1101. {
  1102.         uint32_t cmd;
  1103.         int ret;
  1104.  
  1105.         ret = intel_ring_begin(ring, 4);
  1106.         if (ret)
  1107.                 return ret;
  1108.  
  1109.         cmd = MI_FLUSH_DW;
  1110.         if (invalidate & I915_GEM_GPU_DOMAINS)
  1111.                 cmd |= MI_INVALIDATE_TLB | MI_INVALIDATE_BSD;
  1112.         intel_ring_emit(ring, cmd);
  1113.         intel_ring_emit(ring, 0);
  1114.         intel_ring_emit(ring, 0);
  1115.         intel_ring_emit(ring, MI_NOOP);
  1116.         intel_ring_advance(ring);
  1117.         return 0;
  1118. }
  1119.  
  1120. #if 0
  1121. static int
  1122. gen6_ring_dispatch_execbuffer(struct intel_ring_buffer *ring,
  1123.                               u32 offset, u32 len)
  1124. {
  1125.        int ret;
  1126.  
  1127.        ret = intel_ring_begin(ring, 2);
  1128.        if (ret)
  1129.                return ret;
  1130.  
  1131.        intel_ring_emit(ring, MI_BATCH_BUFFER_START | MI_BATCH_NON_SECURE_I965);
  1132.        /* bit0-7 is the length on GEN6+ */
  1133.        intel_ring_emit(ring, offset);
  1134.        intel_ring_advance(ring);
  1135.  
  1136.        return 0;
  1137. }
  1138.  
  1139. static bool
  1140. gen6_render_ring_get_irq(struct intel_ring_buffer *ring)
  1141. {
  1142.         return gen6_ring_get_irq(ring,
  1143.                                  GT_USER_INTERRUPT,
  1144.                                  GEN6_RENDER_USER_INTERRUPT);
  1145. }
  1146.  
  1147. static void
  1148. gen6_render_ring_put_irq(struct intel_ring_buffer *ring)
  1149. {
  1150.         return gen6_ring_put_irq(ring,
  1151.                                  GT_USER_INTERRUPT,
  1152.                                  GEN6_RENDER_USER_INTERRUPT);
  1153. }
  1154.  
  1155. static bool
  1156. gen6_bsd_ring_get_irq(struct intel_ring_buffer *ring)
  1157. {
  1158.         return gen6_ring_get_irq(ring,
  1159.                                  GT_GEN6_BSD_USER_INTERRUPT,
  1160.                                  GEN6_BSD_USER_INTERRUPT);
  1161. }
  1162.  
  1163. static void
  1164. gen6_bsd_ring_put_irq(struct intel_ring_buffer *ring)
  1165. {
  1166.         return gen6_ring_put_irq(ring,
  1167.                                  GT_GEN6_BSD_USER_INTERRUPT,
  1168.                                  GEN6_BSD_USER_INTERRUPT);
  1169. }
  1170.  
  1171. #endif
  1172.  
  1173. /* ring buffer for Video Codec for Gen6+ */
  1174. static const struct intel_ring_buffer gen6_bsd_ring = {
  1175.         .name                   = "gen6 bsd ring",
  1176.         .id                     = RING_BSD,
  1177.         .mmio_base              = GEN6_BSD_RING_BASE,
  1178.         .size                   = 32 * PAGE_SIZE,
  1179.         .init                   = init_ring_common,
  1180.         .write_tail             = gen6_bsd_ring_write_tail,
  1181.     .flush          = gen6_ring_flush,
  1182. //   .add_request        = gen6_add_request,
  1183. //   .get_seqno      = ring_get_seqno,
  1184. //   .irq_get        = gen6_bsd_ring_get_irq,
  1185. //   .irq_put        = gen6_bsd_ring_put_irq,
  1186. //   .dispatch_execbuffer    = gen6_ring_dispatch_execbuffer,
  1187. };
  1188.  
  1189. #if 0
  1190. /* Blitter support (SandyBridge+) */
  1191.  
  1192. static bool
  1193. blt_ring_get_irq(struct intel_ring_buffer *ring)
  1194. {
  1195.         return gen6_ring_get_irq(ring,
  1196.                                  GT_BLT_USER_INTERRUPT,
  1197.                                  GEN6_BLITTER_USER_INTERRUPT);
  1198. }
  1199.  
  1200. static void
  1201. blt_ring_put_irq(struct intel_ring_buffer *ring)
  1202. {
  1203.         gen6_ring_put_irq(ring,
  1204.                           GT_BLT_USER_INTERRUPT,
  1205.                           GEN6_BLITTER_USER_INTERRUPT);
  1206. }
  1207. #endif
  1208.  
  1209.  
  1210. /* Workaround for some stepping of SNB,
  1211.  * each time when BLT engine ring tail moved,
  1212.  * the first command in the ring to be parsed
  1213.  * should be MI_BATCH_BUFFER_START
  1214.  */
  1215. #define NEED_BLT_WORKAROUND(dev) \
  1216.         (IS_GEN6(dev) && (dev->pdev->revision < 8))
  1217.  
  1218. static inline struct drm_i915_gem_object *
  1219. to_blt_workaround(struct intel_ring_buffer *ring)
  1220. {
  1221.         return ring->private;
  1222. }
  1223.  
  1224.  
  1225. static int blt_ring_init(struct intel_ring_buffer *ring)
  1226. {
  1227.         if (NEED_BLT_WORKAROUND(ring->dev)) {
  1228.                 struct drm_i915_gem_object *obj;
  1229.                 u32 *ptr;
  1230.                 int ret;
  1231.  
  1232.                 obj = i915_gem_alloc_object(ring->dev, 4096);
  1233.                 if (obj == NULL)
  1234.                         return -ENOMEM;
  1235.  
  1236.                 ret = i915_gem_object_pin(obj, 4096, true);
  1237.                 if (ret) {
  1238. //           drm_gem_object_unreference(&obj->base);
  1239.                         return ret;
  1240.                 }
  1241.  
  1242.         ptr = ioremap(obj->pages[0], 4096);
  1243.                 *ptr++ = MI_BATCH_BUFFER_END;
  1244.                 *ptr++ = MI_NOOP;
  1245.         iounmap(obj->pages[0]);
  1246.  
  1247.                 ret = i915_gem_object_set_to_gtt_domain(obj, false);
  1248.                 if (ret) {
  1249. //           i915_gem_object_unpin(obj);
  1250. //           drm_gem_object_unreference(&obj->base);
  1251.                         return ret;
  1252.                 }
  1253.  
  1254.                 ring->private = obj;
  1255.         }
  1256.  
  1257.         return init_ring_common(ring);
  1258. }
  1259.  
  1260. static int blt_ring_begin(struct intel_ring_buffer *ring,
  1261.                           int num_dwords)
  1262. {
  1263.         if (ring->private) {
  1264.                 int ret = intel_ring_begin(ring, num_dwords+2);
  1265.                 if (ret)
  1266.                         return ret;
  1267.  
  1268.                 intel_ring_emit(ring, MI_BATCH_BUFFER_START);
  1269.                 intel_ring_emit(ring, to_blt_workaround(ring)->gtt_offset);
  1270.  
  1271.                 return 0;
  1272.         } else
  1273.                 return intel_ring_begin(ring, 4);
  1274. }
  1275.  
  1276. static int blt_ring_flush(struct intel_ring_buffer *ring,
  1277.                           u32 invalidate, u32 flush)
  1278. {
  1279.         uint32_t cmd;
  1280.         int ret;
  1281.  
  1282.         ret = blt_ring_begin(ring, 4);
  1283.         if (ret)
  1284.                 return ret;
  1285.  
  1286.         cmd = MI_FLUSH_DW;
  1287.         if (invalidate & I915_GEM_DOMAIN_RENDER)
  1288.                 cmd |= MI_INVALIDATE_TLB;
  1289.         intel_ring_emit(ring, cmd);
  1290.         intel_ring_emit(ring, 0);
  1291.         intel_ring_emit(ring, 0);
  1292.         intel_ring_emit(ring, MI_NOOP);
  1293.         intel_ring_advance(ring);
  1294.         return 0;
  1295. }
  1296.  
  1297. static void blt_ring_cleanup(struct intel_ring_buffer *ring)
  1298. {
  1299.         if (!ring->private)
  1300.                 return;
  1301.  
  1302.         i915_gem_object_unpin(ring->private);
  1303.         drm_gem_object_unreference(ring->private);
  1304.         ring->private = NULL;
  1305. }
  1306.  
  1307.  
  1308. static const struct intel_ring_buffer gen6_blt_ring = {
  1309.        .name                    = "blt ring",
  1310.        .id                      = RING_BLT,
  1311.        .mmio_base               = BLT_RING_BASE,
  1312.        .size                    = 32 * PAGE_SIZE,
  1313.        .init                    = blt_ring_init,
  1314.        .write_tail              = ring_write_tail,
  1315.        .flush          = blt_ring_flush,
  1316. //       .add_request        = gen6_add_request,
  1317. //       .get_seqno      = ring_get_seqno,
  1318. //       .irq_get            = blt_ring_get_irq,
  1319. //       .irq_put            = blt_ring_put_irq,
  1320. //       .dispatch_execbuffer    = gen6_ring_dispatch_execbuffer,
  1321. //       .cleanup            = blt_ring_cleanup,
  1322. };
  1323.  
  1324.  
  1325.  
  1326. int intel_init_render_ring_buffer(struct drm_device *dev)
  1327. {
  1328.         drm_i915_private_t *dev_priv = dev->dev_private;
  1329.         struct intel_ring_buffer *ring = &dev_priv->ring[RCS];
  1330.     ENTER();
  1331.         *ring = render_ring;
  1332.         if (INTEL_INFO(dev)->gen >= 6) {
  1333. //       ring->add_request = gen6_add_request;
  1334. //       ring->irq_get = gen6_render_ring_get_irq;
  1335. //       ring->irq_put = gen6_render_ring_put_irq;
  1336.         } else if (IS_GEN5(dev)) {
  1337. //       ring->add_request = pc_render_add_request;
  1338. //       ring->get_seqno = pc_render_get_seqno;
  1339.         }
  1340.  
  1341.         if (!I915_NEED_GFX_HWS(dev)) {
  1342.                 ring->status_page.page_addr = dev_priv->status_page_dmah->vaddr;
  1343.                 memset(ring->status_page.page_addr, 0, PAGE_SIZE);
  1344.         }
  1345.     LEAVE();
  1346.         return intel_init_ring_buffer(dev, ring);
  1347. }
  1348.  
  1349.  
  1350. int intel_init_bsd_ring_buffer(struct drm_device *dev)
  1351. {
  1352.         drm_i915_private_t *dev_priv = dev->dev_private;
  1353.         struct intel_ring_buffer *ring = &dev_priv->ring[VCS];
  1354.  
  1355.         if (IS_GEN6(dev) || IS_GEN7(dev))
  1356.                 *ring = gen6_bsd_ring;
  1357.         else
  1358.                 *ring = bsd_ring;
  1359.  
  1360.         return intel_init_ring_buffer(dev, ring);
  1361. }
  1362.  
  1363. int intel_init_blt_ring_buffer(struct drm_device *dev)
  1364. {
  1365.         drm_i915_private_t *dev_priv = dev->dev_private;
  1366.         struct intel_ring_buffer *ring = &dev_priv->ring[BCS];
  1367.  
  1368.         *ring = gen6_blt_ring;
  1369.  
  1370.         return intel_init_ring_buffer(dev, ring);
  1371. }
  1372.  
  1373.  
  1374.  
  1375.  
  1376.