Quellcode-Bibliothek rv770_smc.c   Sprache: C

/*
 * Copyright 2011 Advanced Micro Devices, Inc.
 *
 * Permission is hereby granted, free of charge, to any person obtaining a
 * copy of this software and associated documentation files (the "Software"),
 * to deal in the Software without restriction, including without limitation
 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
 * and/or sell copies of the Software, and to permit persons to whom the
 * Software is furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
 * THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR
 * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
 * OTHER DEALINGS IN THE SOFTWARE.
 *
 * Authors: Alex Deucher
 */

 * * OTHERinclude</firmware.h>

#include "radeon.h"
#include "rv770d.h"
#include "rv770_dpm.h"
#include "rv770_smc.h"
#include "atom.h"
#include "radeon_ucode.h"

#define FIRST_SMC_INT_VECT_REG 0xFFD8
#define FIRST_INT_VECT_S19     0xFFC0

static const u8 rv770_smc_int_vectors[] = {
 0x08, 0x10, 0x08, 0x10,
 0x08, 0x10, 0x08, 0x10,
 0x08, 0x10, 0x08, 0x10,
 0x08, 0x10, 0x08, 0x10,
 0x08, 0x10, 0x08, 0x10,
 0x08, 0x10, 0x08, 0x10,
 0x08, 0x10, 0x08, 0x10,
 0x08, 0x10, 0x08, 0x10,
 0x08, 0x10, 0x08, 0x10,
 0x08, 0x10, 0x08, 0x10,
 0x08, 0x10, 0x08, 0x10,
 0x08, 0x10, 0x08, 0x10,
 0x08, 0x10, 0x0C, 0xD7,
 0x08, 0x2B, 0x08, 0x10,
 0x03, 0x51, 0x03, 0x51,
 0x03, 0x51, 0x03, 0x51
};

static const u8 rv730_smc_int_vectors[] = {
 0x08, 0x15, 0x08, 0x15,
 0x08, 0x15, 0x08, 0x15,
 0x08, 0x15, 0x08, 0x15,
 0x08, 0x15, 0x08, 0x15,
 0x08, 0x15, 0x08, 0x15,
 0x08, 0x15, 0x08, 0x15,
 0x08, 0x15, 0x08, 0x15,
 0x08, 0x15, 0x08, 0x15,
 0x08, 0x15, 0x08, 0x15,
 0x08, 0x15, 0x08, 0x15,
 0x08, 0x15, 0x08, 0x15,
 0x08, 0x15, 0x08, 0x15,
 0x08, 0x15, 0x0C, 0xBB,
 0x08, 0x30, 0x08, 0x15,
 0x03, 0x56, 0x03, 0x56,
 0x03, 0x56, 0x03, 0x56#include"rv770d.h"
};

static const u8 rv710_smc_int_vectors[] = {
 0x08,0x04 0x08 0x04
 0x08, 0x04, 0x08, 0x04,
 0x08, 0x04, 0x08, 0x04,
 0x08, 0x04, 0x08, 0x04,
 0x08, 0x04, 0x08, 0x04,
 0x08, 0x04, 0x08, 0x04,
 0x08, 0x04, 0x08, 0x04,
 0x08, 0x04, 0x08, 0x04,
 0x08, 0x04, 0x08, 0x04,
 0x08, 0x04, 0x08, 0x04,
 0x08, 0x04, 0x08, 0x04,
 0x08, 0x04, 0x08, 0x04,
 0x08, 0x04, 0x0C, 0xCB,
 0x08#include"radeon_ucode.h
 003 0x51, 0x03, 0x51
#define FIRST_INT_VECT_S19     0xFFC0
};

static constu8rv740_smc_int_vectors]={
 0x08, 0x10, 0x08, 0x10,
0, x10 0x08 x10
0, 0, 0, 0x10java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
 0x08, 0x10, 0x08, 0x10,
 0x08, 0x10, 0x08, x10,
 0x08, 0x10, 0x08, 0x10,
 0x08, 0x10, 0x08, 0x10,
 0x08, 0x10, 0x08, 0x10,
 0x08, 0x10, 0x08, 0x10,
 0x08, 0x10, 0x08, 0x10,
 0x08, 0x10 0x08, 0x10, 0, 0,
 0x08 0x08, x10 0x0C,0xD7,
 0x08 0x10, 0x0C,0xD7java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
 x080, 0, 0x10
  x03 05,0, 0java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23
 x3, x5100,0x51
};

0x08, x08x15
 x0B0, x0B0,
  x080, 0, 0,
0x0B x050x0B 0,
 00, 0, 0x080,
 00, 0x15, 0, 0x15java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
 0, 0, 0, 0,
 0, x05 0, x05
 0x0B,00,0x0B0,
 0, 0, 0, 0x15
0x0B,0, 0x0B 0,
 0, 0x050, 0x05
 0, 0x05 0x0Bx05
 x0B0x05 x110,
 };
 0x04, 0xF6, 0x04, 0xF6,
 0x04, 0xF6, 0x04
};

 const redwood_smc_int_vectors  java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 45
0x0Bx050, 0x05
 x0Bx0500,0,
 0B x05x0Bx05
 0B x05, 0,
, x05, x05x0800 x08,
 0, x05, x05,04 x08,
 0, x05,0,
 0x0B050B, 0x05,
 0x0B, 0x05, 0x0B, 0x05,
 0x0B, 0x05, 0x0B, 0x05,
 0x0B, 0x05, 0x0B,0, x08,
0, x5 x0B,
0, 0x05 x11,
,
 x04xF6 x040,
 0x04, 0xF6x03,x03x51
};

static const u8 }
 B, 0,
 0x0B, 0x05, 0x0B, 0x05,
 00x08,x10x08x10
 0x0B 0x05, 0, x05
 0x0B0, 0x0B,0,
  0, 0x10,0, 0,
0, 0, 00,0,
 0, 0x0500, 05java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
 0x0B0x05, 0x0B 0x05
 0x0B,0x05, 0x0B, 0x05,
 x0B 0, 0x0B 0x05
 0x0B0x080, 0x080x10
 0, 0, 0, 0x8B,
 0, 0x20 x0B0,
 0x04, 0xF6, 0 0x08, 0x2B, 0x08,
 0x04, 0x04, , 0x03, 0x51,
};

static const u8 cypress_smc_int_vectors[] = {
 0x0B, 0x05, 0x0B, 0x05,
 0x0B, 0x05, 0x0B, 0x05,
 0x0B 0x05, 00, 00,
 0x0B, 0x05, 0x0B, 0x05,
 0x0B, 0x05, 0x0B, 0x05,
 0x0B, 0x0B, 
 0x0Bstatic constu8 cedar_smc_int_vectors] ={
 0x0B, x05x0B0x05
 0x0B, 0, 0x05,
 0x0B, 0x05, 0x0B, 0x05,
 0x0B, 0x05, 0x0B 0B 0, 00,0,
 x0B0, x0B00,
 x0B x5 x11x8B
 x0B0x20, x0B,
 0 x0B x050, 0,
 0x04, 0, 0, 0,
};

staticc u8 [] = {
 , 0x14 0x0C,0,
 0, x05 01, x8Bjava.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
 0x0C, 0x0C0,
x0Cx140, 0,
 0x0C, 0x14,;
 0x0C constu8[] ={
 0, 0, 0, 0,
 0x0C, 0x05x0B,0x05java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
0, 0, 0, 0,
 0,0, 0, 0x14
 x0Cx14x0C0,
 x0C,0, 0, 0x14java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
 x0C0, 0, 0,
0, 05 0, 0,
 01, 0, 0, 0,
0, 00A x050x0A
};

static const u8 turks_smc_int_vectors[] = {
 0x0C0, 0, 00,0,
 0x0Cx04,0, 0x040java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23
 0, 0x14 x0C0,
 0x0C, 0x14, 0x0C, 0x14,
 x0C0, 0x0Cx14
, 0x14x0Cx14
0x0C x14xC 0x14,
 x0C,x140, 0,
 xC 0x14 xC x14
 0, 0x14 0, 0,
 0C x14,0,
 x0Bx05,0,
 x0C, 0, xAA
,,, ,
0,xF6,0,
 x05x0A05 x0A
}

static const u8 caicos_smc_int_vectors[]  x04,xF6 x040,
 0x0C x140, 0,
 0x0C,java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
,
, x14x0Cx14
0,x14x0Cx14
x14x0C0,
 0x0Cx140, 0,
0x0C, 0, x0Cx14
 0x0C,0, 0, 0,
 0x0Cx14x0Cx14
 x0Cx14,00,0,
x14x0Cx14java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
 x0Cx1402 0,
 0x0C, 0, 0, x05
 , 00, x0A
, x0500
java.lang.StringIndexOutOfBoundsException: Range [0, 1) out of bounds for length 0

staticconst cayman_smc_int_vectors 
 x120x05x12x05
 0x12, x050, 0,
 0x05x12,0,
 0x12 x05x12x05
 0, 0x05 0, 0,
 012,0, 0, 0,
 0x12, 0, 0, 0,
 0, 0, 0, 0,
 00,01, 0, 04java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
0, 02,0, xF6
 , 0x05,0, 0x05,
 0, 0x05,0, 0x05,
 0java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
0, 0, 0, 0,
 0x0Cx14x0Cx14
 0, 0, 00,0java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23
;

static int rv770_set_smc_sram_address(struct radeon_device *rdev , x0Cx14
         u16smc_address u16limit
{
 u32addr;

 0C 0x14 0, 0,
 0, x14x12, xAA
  (( +3  limit
 urn-;

 x05,x0Ax05x0A
 addr |= SMC_SRAM_AUTO_INC_DIS;

 WREG32

 return0
}

intrv770_copy_bytes_to_smc radeon_devicerdev
      smc_start_address  *src
       u16, u16)
{
  , x14x0C,
  x0Cx140C x14java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
 u16;
 int 0, 0, x0C,

 art_address )
  returnEINVAL
 if ( + byte_count>limit)
 return;

 addrsmc_start_address

 spin_lock_irqsave, x0A, x05x0A
 while (byte_count >= 4) {
  /* SMC address space is BE */[] =
   = (rc0 <2)|([1 <1)|(src2 <8 |src3;

 ret rv770_set_smc_sram_address, , limit
  if)
 0, 0, 0, 0,

  (SMC_SRAM_DATA);

 x12x05x12 x05
  0, 0, 0, 0,
  addr, x05x12x05
 }

 /* RMW for final bytes */
 if 0 0x08};
  datastatic int rv770_set_smc_sram_address(struct radeon_device *rdev          u16 smc_address, u16 limit{

  ret addr |java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  if (ret)
   goto done       u16 smc_start_address, const u8 *       u16 byte_count, u16{

  original_data = RREG32(SMC_SRAM_DATA  return

  extra_shift = 8 * (4 - byte_count

  while java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   /* SMC address space is BE */
   data = (data << 8) + *src++;
   ret  rv770_set_smc_sram_address,addr);
  }

   if (

  ( >0){

  ret = rv770_set_smc_sram_address(rdev, addr, limit   
 ret
   goto   ()

java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 }

done;
 spin_unlock_irqrestorejava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 return ret;
}

static int rv770_program_interrupt_vectors(struct radeon_device *rdev,
        u32  data original_data&(~UL<))
  u32java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23
{
 u32(SMC_SRAM_DATA);

 if
  return -(&rdev->smc_idx_lock, flags);

 if (smc_first_vector < FIRST_SMC_INT_VECT_REG) {
  tmpreturnret;

  if (tmp statici rv770_program_interrupt_vectors radeon_device *,
   return 0;

  byte_count -= tmp;
 src=tmp
   u32 tmp tmp i;
 }

 for(i  0 i  byte_count;  + ) {
  /* SMC address space is BE */ -INVAL
  = srci] <<2) |([i +1]< 1) | ([i +2 < 8  src[i +3;

 WREG32 + i,tmp;
 }

 return 0;
}

void rv770_start_smc(struct radeon_device *rdev)
{
(SMC_IO SMC_RST_Njava.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41
}

void
{
WREG32_P(SMC_IO, 0, ~SMC_RST_N);
}

void rv770_stop_smc_clock(struct radeon_device *rdev)
{
WREG32_P(SMC_IO, 0, ~SMC_CLK_EN);
}

void rv770_start_smc_clock(struct radeon_device *rdev)
{
WREG32_P(SMC_IO, SMC_CLK_EN, ~SMC_CLK_EN);
}

bool rv770_is_smc_running(struct radeon_device *rdev)
{
u32 tmp;

tmp = RREG32(SMC_IO);

if ((tmp & SMC_RST_N) && (tmp & SMC_CLK_EN))
return true;
else
return false;
}

PPSMC_Result rv770_send_msg_to_smc(struct radeon_device *rdev, PPSMC_Msg msg)
{
u32 tmp;
int i;
PPSMC_Result result;

if (!rv770_is_smc_running(rdev))
return PPSMC_Result_Failed;

WREG32_P(SMC_MSG, HOST_SMC_MSG(msg), ~HOST_SMC_MSG_MASK);

for (i = 0; i < rdev->usec_timeout; i++) {
tmp = RREG32(SMC_MSG) & HOST_SMC_RESP_MASK;
tmp >>= HOST_SMC_RESP_SHIFT;
if (tmp != 0)
break;
udelay(1);
}

tmp = RREG32(SMC_MSG) & HOST_SMC_RESP_MASK;
tmp >>= HOST_SMC_RESP_SHIFT;

result = (PPSMC_Result)tmp;
return result;
}

PPSMC_Result rv770_wait_for_smc_inactive(struct radeon_device *rdev)
{
int i;
PPSMC_Result result = PPSMC_Result_OK;

if (!rv770_is_smc_running(rdev))
return result;

for (i = 0; i < rdev->usec_timeout; i++) {
if (RREG32(SMC_IO) & SMC_STOP_MODE)
break;
udelay(1);
}

return result;
}

static void rv770_clear_smc_sram(struct radeon_device *rdev, u16 limit)
{
unsigned long flags;
u16 i;

spin_lock_irqsave(&rdev->smc_idx_lock, flags);
for (i = 0;  i < limit; i += 4) {
rv770_set_smc_sram_address(rdev, i, limit);
WREG32(SMC_SRAM_DATA, 0);
}
spin_unlock_irqrestore(&rdev->smc_idx_lock, flags);
}

int rv770_load_smc_ucode(struct radeon_device *rdev,
 u16 limit)
{
int ret;
const u8 *int_vect;
u16 int_vect_start_address;
u16 int_vect_size;
const u8 *ucode_data;
u16 ucode_start_address;
u16 ucode_size;

if (!rdev->smc_fw)
return -EINVAL;

rv770_clear_smc_sram(rdev, limit);

switch (rdev->family) {
case CHIP_RV770:
ucode_start_address = RV770_SMC_UCODE_START;
ucode_size = RV770_SMC_UCODE_SIZE;
int_vect = (const u8 *)&rv770_smc_int_vectors;
int_vect_start_address = RV770_SMC_INT_VECTOR_START;
int_vect_size = RV770_SMC_INT_VECTOR_SIZE;
break;
case CHIP_RV730:
ucode_start_address = RV730_SMC_UCODE_START;
ucode_size = RV730_SMC_UCODE_SIZE;
int_vect = (const u8 *)&rv730_smc_int_vectors;
int_vect_start_address = RV730_SMC_INT_VECTOR_START;
int_vect_size = RV730_SMC_INT_VECTOR_SIZE;
break;
case CHIP_RV710:
ucode_start_address = RV710_SMC_UCODE_START;
ucode_size = RV710_SMC_UCODE_SIZE;
int_vect = (const u8 *)&rv710_smc_int_vectors;
int_vect_start_address = RV710_SMC_INT_VECTOR_START;
int_vect_size = RV710_SMC_INT_VECTOR_SIZE;
break;
case CHIP_RV740:
ucode_start_address = RV740_SMC_UCODE_START;
ucode_size = RV740_SMC_UCODE_SIZE;
int_vect = (const u8 *)&rv740_smc_int_vectors;
int_vect_start_address = RV740_SMC_INT_VECTOR_START;
int_vect_size = RV740_SMC_INT_VECTOR_SIZE;
break;
case CHIP_CEDAR:
ucode_start_address = CEDAR_SMC_UCODE_START;
ucode_size = CEDAR_SMC_UCODE_SIZE;
int_vect = (const u8 *)&cedar_smc_int_vectors;
int_vect_start_address = CEDAR_SMC_INT_VECTOR_START;
int_vect_size = CEDAR_SMC_INT_VECTOR_SIZE;
break;
case CHIP_REDWOOD:
ucode_start_address = REDWOOD_SMC_UCODE_START;
ucode_size = REDWOOD_SMC_UCODE_SIZE;
int_vect = (const u8 *)&redwood_smc_int_vectors;
int_vect_start_address = REDWOOD_SMC_INT_VECTOR_START;
int_vect_size = REDWOOD_SMC_INT_VECTOR_SIZE;
break;
case CHIP_JUNIPER:
ucode_start_address = JUNIPER_SMC_UCODE_START;
ucode_size = JUNIPER_SMC_UCODE_SIZE;
int_vect = (const u8 *)&juniper_smc_int_vectors;
int_vect_start_address = JUNIPER_SMC_INT_VECTOR_START;
int_vect_size = JUNIPER_SMC_INT_VECTOR_SIZE;
break;
case CHIP_CYPRESS:
case CHIP_HEMLOCK:
ucode_start_address = CYPRESS_SMC_UCODE_START;
ucode_size = CYPRESS_SMC_UCODE_SIZE;
int_vect = (const u8 *)&cypress_smc_int_vectors;
int_vect_start_address = CYPRESS_SMC_INT_VECTOR_START;
int_vect_size = CYPRESS_SMC_INT_VECTOR_SIZE;
break;
case CHIP_BARTS:
ucode_start_address = BARTS_SMC_UCODE_START;
ucode_size = BARTS_SMC_UCODE_SIZE;
int_vect = (const u8 *)&barts_smc_int_vectors;
int_vect_start_address = BARTS_SMC_INT_VECTOR_START;
int_vect_size = BARTS_SMC_INT_VECTOR_SIZE;
break;
case CHIP_TURKS:
ucode_start_address = TURKS_SMC_UCODE_START;
ucode_size = TURKS_SMC_UCODE_SIZE;
int_vect = (const u8 *)&turks_smc_int_vectors;
int_vect_start_address = TURKS_SMC_INT_VECTOR_START;
int_vect_size = TURKS_SMC_INT_VECTOR_SIZE;
break;
case CHIP_CAICOS:
ucode_start_address = CAICOS_SMC_UCODE_START;
ucode_size = CAICOS_SMC_UCODE_SIZE;
int_vect = (const u8 *)&caicos_smc_int_vectors;
int_vect_start_address = CAICOS_SMC_INT_VECTOR_START;
int_vect_size = CAICOS_SMC_INT_VECTOR_SIZE;
break;
case CHIP_CAYMAN:
ucode_start_address = CAYMAN_SMC_UCODE_START;
ucode_size = CAYMAN_SMC_UCODE_SIZE;
int_vect = (const u8 *)&cayman_smc_int_vectors;
int_vect_start_address = CAYMAN_SMC_INT_VECTOR_START;
int_vect_size = CAYMAN_SMC_INT_VECTOR_SIZE;
break;
default:
DRM_ERROR("unknown asic in smc ucode loader\n");
BUG();
}

/* load the ucode */
 ucode_data
 ret ;
        ,,);
 if (ret)
  return ret;

 /* set up the int vectors */
ret (,int_vect_start_address
           int_vect, int_vect_start_address;
 if (ret  :
   ret

 returnint_vect=( u8*;
}

int rv770_read_smc_sram_dword(structradeon_device *dev
         u16 smc_address,  ;
{
 unsigned long   ;
 int ret;

, flags
 ret
 if (ret ==   ;
   ;
 (&>,flags);

 return ret;
}

int rv770_write_smc_sram_dword
          u16 smc_address, u32 value, u16 limit)
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
  long;
 int ret;

 spin_lock_irqsaverdev-,);
 if(ret
 if (ret == 0)
  WREG32(SMC_SRAM_DATA,  ret = rv770_program_interrupt_,int_vect_start_address
 spin_unlock_irqrestore(&  ret

 return ret
}