Line data    Source code

       1             : /*
       2             :  * Copyright 2011 Christian König.
       3             :  * All Rights Reserved.
       4             :  *
       5             :  * Permission is hereby granted, free of charge, to any person obtaining a
       6             :  * copy of this software and associated documentation files (the
       7             :  * "Software"), to deal in the Software without restriction, including
       8             :  * without limitation the rights to use, copy, modify, merge, publish,
       9             :  * distribute, sub license, and/or sell copies of the Software, and to
      10             :  * permit persons to whom the Software is furnished to do so, subject to
      11             :  * the following conditions:
      12             :  *
      13             :  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
      14             :  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
      15             :  * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL
      16             :  * THE COPYRIGHT HOLDERS, AUTHORS AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM,
      17             :  * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
      18             :  * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
      19             :  * USE OR OTHER DEALINGS IN THE SOFTWARE.
      20             :  *
      21             :  * The above copyright notice and this permission notice (including the
      22             :  * next paragraph) shall be included in all copies or substantial portions
      23             :  * of the Software.
      24             :  *
      25             :  */
      26             : /*
      27             :  * Authors:
      28             :  *    Christian König <deathsimple@vodafone.de>
      29             :  */
      30             : #include <dev/pci/drm/drmP.h>
      31             : #include "radeon.h"
      32             : #include "radeon_trace.h"
      33             : 
      34           0 : int radeon_semaphore_create(struct radeon_device *rdev,
      35             :                             struct radeon_semaphore **semaphore)
      36             : {
      37             :         int r;
      38             : 
      39           0 :         *semaphore = kmalloc(sizeof(struct radeon_semaphore), GFP_KERNEL);
      40           0 :         if (*semaphore == NULL) {
      41           0 :                 return -ENOMEM;
      42             :         }
      43           0 :         r = radeon_sa_bo_new(rdev, &rdev->ring_tmp_bo,
      44           0 :                              &(*semaphore)->sa_bo, 8, 8);
      45           0 :         if (r) {
      46           0 :                 kfree(*semaphore);
      47           0 :                 *semaphore = NULL;
      48           0 :                 return r;
      49             :         }
      50           0 :         (*semaphore)->waiters = 0;
      51           0 :         (*semaphore)->gpu_addr = radeon_sa_bo_gpu_addr((*semaphore)->sa_bo);
      52             : 
      53           0 :         *((uint64_t *)radeon_sa_bo_cpu_addr((*semaphore)->sa_bo)) = 0;
      54             : 
      55           0 :         return 0;
      56           0 : }
      57             : 
      58           0 : bool radeon_semaphore_emit_signal(struct radeon_device *rdev, int ridx,
      59             :                                   struct radeon_semaphore *semaphore)
      60             : {
      61           0 :         struct radeon_ring *ring = &rdev->ring[ridx];
      62             : 
      63           0 :         trace_radeon_semaphore_signale(ridx, semaphore);
      64             : 
      65           0 :         if (radeon_semaphore_ring_emit(rdev, ridx, ring, semaphore, false)) {
      66           0 :                 --semaphore->waiters;
      67             : 
      68             :                 /* for debugging lockup only, used by sysfs debug files */
      69           0 :                 ring->last_semaphore_signal_addr = semaphore->gpu_addr;
      70           0 :                 return true;
      71             :         }
      72           0 :         return false;
      73           0 : }
      74             : 
      75           0 : bool radeon_semaphore_emit_wait(struct radeon_device *rdev, int ridx,
      76             :                                 struct radeon_semaphore *semaphore)
      77             : {
      78           0 :         struct radeon_ring *ring = &rdev->ring[ridx];
      79             : 
      80           0 :         trace_radeon_semaphore_wait(ridx, semaphore);
      81             : 
      82           0 :         if (radeon_semaphore_ring_emit(rdev, ridx, ring, semaphore, true)) {
      83           0 :                 ++semaphore->waiters;
      84             : 
      85             :                 /* for debugging lockup only, used by sysfs debug files */
      86           0 :                 ring->last_semaphore_wait_addr = semaphore->gpu_addr;
      87           0 :                 return true;
      88             :         }
      89           0 :         return false;
      90           0 : }
      91             : 
      92           0 : void radeon_semaphore_free(struct radeon_device *rdev,
      93             :                            struct radeon_semaphore **semaphore,
      94             :                            struct radeon_fence *fence)
      95             : {
      96           0 :         if (semaphore == NULL || *semaphore == NULL) {
      97             :                 return;
      98             :         }
      99           0 :         if ((*semaphore)->waiters > 0) {
     100           0 :                 dev_err(rdev->dev, "semaphore %p has more waiters than signalers,"
     101             :                         " hardware lockup imminent!\n", *semaphore);
     102           0 :         }
     103           0 :         radeon_sa_bo_free(rdev, &(*semaphore)->sa_bo, fence);
     104           0 :         kfree(*semaphore);
     105           0 :         *semaphore = NULL;
     106           0 : }