int adreno_ringbuffer_load_pfp_ucode(struct kgsl_device *device)
{
struct adreno_device *adreno_dev = ADRENO_DEVICE(device);
int i;
if (adreno_dev->pfp_fw == NULL) {
int ret = adreno_ringbuffer_read_pfp_ucode(device);
if (ret)
return ret;
}
KGSL_DRV_INFO(device, "loading pfp ucode version: %d\n",
adreno_dev->pfp_fw_version);
adreno_regwrite(device, adreno_dev->gpudev->reg_cp_pfp_ucode_addr, 0);
for (i = 1; i < adreno_dev->pfp_fw_size; i++)
adreno_regwrite(device,
adreno_dev->gpudev->reg_cp_pfp_ucode_data,
adreno_dev->pfp_fw[i]);
return 0;
}
static int adreno_ringbuffer_load_pm4_ucode(struct kgsl_device *device)
{
struct adreno_device *adreno_dev = ADRENO_DEVICE(device);
int i, ret = 0;
if (adreno_dev->pm4_fw == NULL) {
int len;
void *ptr;
ret = _load_firmware(device, adreno_dev->pm4_fwfile,
&ptr, &len);
if (ret)
goto err;
/* PM4 size is 3 dword aligned plus 1 dword of version */
if (len % ((sizeof(uint32_t) * 3)) != sizeof(uint32_t)) {
KGSL_DRV_ERR(device, "Bad firmware size: %d\n", len);
ret = -EINVAL;
kfree(ptr);
goto err;
}
adreno_dev->pm4_fw_size = len / sizeof(uint32_t);
adreno_dev->pm4_fw = ptr;
}
KGSL_DRV_INFO(device, "loading pm4 ucode version: %d\n",
adreno_dev->pm4_fw[0]);
adreno_regwrite(device, REG_CP_DEBUG, 0x02000000);
adreno_regwrite(device, REG_CP_ME_RAM_WADDR, 0);
for (i = 1; i < adreno_dev->pm4_fw_size; i++)
adreno_regwrite(device, REG_CP_ME_RAM_DATA,
adreno_dev->pm4_fw[i]);
err:
return ret;
}
static int adreno_ringbuffer_load_pfp_ucode(struct kgsl_device *device)
{
struct adreno_device *adreno_dev = ADRENO_DEVICE(device);
int i, ret = 0;
if (adreno_dev->pfp_fw == NULL) {
int len;
void *ptr;
ret = _load_firmware(device, adreno_dev->pfp_fwfile,
&ptr, &len);
if (ret)
goto err;
/* PFP size shold be dword aligned */
if (len % sizeof(uint32_t) != 0) {
KGSL_DRV_ERR(device, "Bad firmware size: %d\n", len);
ret = -EINVAL;
kfree(ptr);
goto err;
}
adreno_dev->pfp_fw_size = len / sizeof(uint32_t);
adreno_dev->pfp_fw = ptr;
}
KGSL_DRV_INFO(device, "loading pfp ucode version: %d\n",
adreno_dev->pfp_fw[0]);
adreno_regwrite(device, adreno_dev->gpudev->reg_cp_pfp_ucode_addr, 0);
for (i = 1; i < adreno_dev->pfp_fw_size; i++)
adreno_regwrite(device,
adreno_dev->gpudev->reg_cp_pfp_ucode_data,
adreno_dev->pfp_fw[i]);
err:
return ret;
}
int kgsl_g12_cmdwindow_write(struct kgsl_device *device,
enum kgsl_cmdwindow_type target, unsigned int addr,
unsigned int data)
{
unsigned int cmdwinaddr;
unsigned int cmdstream;
KGSL_DRV_INFO("enter (device=%p,addr=%08x,data=0x%x)\n", device, addr,
data);
if (target < KGSL_CMDWINDOW_MIN ||
target > KGSL_CMDWINDOW_MAX) {
KGSL_DRV_ERR("dev %p invalid target\n", device);
return -EINVAL;
}
if (!(device->flags & KGSL_FLAGS_INITIALIZED)) {
KGSL_DRV_ERR("Trying to write uninitialized device.\n");
return -EINVAL;
}
if (target == KGSL_CMDWINDOW_MMU)
cmdstream = ADDR_VGC_MMUCOMMANDSTREAM;
else
cmdstream = ADDR_VGC_COMMANDSTREAM;
cmdwinaddr = ((target << KGSL_G12_CMDWINDOW_TARGET_SHIFT) &
KGSL_G12_CMDWINDOW_TARGET_MASK);
cmdwinaddr |= ((addr << KGSL_G12_CMDWINDOW_ADDR_SHIFT) &
KGSL_G12_CMDWINDOW_ADDR_MASK);
kgsl_g12_regwrite(device, cmdstream >> 2, cmdwinaddr);
kgsl_g12_regwrite(device, cmdstream >> 2, data);
return 0;
}
int adreno_ringbuffer_load_pm4_ucode(struct kgsl_device *device)
{
struct adreno_device *adreno_dev = ADRENO_DEVICE(device);
int i;
if (adreno_dev->pm4_fw == NULL) {
int ret = adreno_ringbuffer_read_pm4_ucode(device);
if (ret)
return ret;
}
KGSL_DRV_INFO(device, "loading pm4 ucode version: %d\n",
adreno_dev->pm4_fw_version);
if (adreno_is_a3xx(adreno_dev))
adreno_regwrite(device, REG_CP_DEBUG, CP_DEBUG_DEFAULT);
else
adreno_regwrite(device, REG_CP_DEBUG, 0x02000000);
adreno_regwrite(device, REG_CP_ME_RAM_WADDR, 0);
for (i = 1; i < adreno_dev->pm4_fw_size; i++)
adreno_regwrite(device, REG_CP_ME_RAM_DATA,
adreno_dev->pm4_fw[i]);
return 0;
}
int kgsl_g12_first_open_locked(void)
{
int result = KGSL_SUCCESS;
KGSL_DRV_INFO("kgsl_g12_first_open()\n");
if (kgsl_driver.g12_device.hwaccess_blocked == KGSL_FALSE) {
kgsl_pwrctrl(KGSL_PWRFLAGS_G12_CLK_ON);
result = kgsl_g12_init(&kgsl_driver.g12_device,
&kgsl_driver.g12_config);
if (result != 0)
goto done;
result = kgsl_g12_start(&kgsl_driver.g12_device, 0);
if (result != 0)
goto done;
kgsl_pwrctrl(KGSL_PWRFLAGS_G12_IRQ_ON);
}
done:
return result;
}
static int kgsl_ringbuffer_load_pfp_ucode(struct kgsl_device *device)
{
int status = 0;
int i;
const struct firmware *fw = NULL;
unsigned int *fw_ptr = NULL;
size_t fw_word_size = 0;
struct kgsl_yamato_device *yamato_device = KGSL_YAMATO_DEVICE(device);
if (yamato_device->pfp_fw == NULL) {
if (device->chip_id == KGSL_CHIPID_LEIA_REV470) {
status = request_firmware(&fw, LEIA_PFP_470_FW,
device->dev);
if (status != 0) {
KGSL_DRV_ERR("request_firmware for %s \
failed with error %d\n",
LEIA_PFP_470_FW, status);
return status;
}
} else {
status = request_firmware(&fw, YAMATO_PFP_FW,
device->dev);
if (status != 0) {
KGSL_DRV_ERR("request_firmware for %s \
failed with error %d\n",
YAMATO_PFP_FW, status);
return status;
}
}
/*this firmware must come in 1 word chunks. */
if ((fw->size % sizeof(uint32_t)) != 0) {
KGSL_DRV_ERR("bad firmware size %d.\n", fw->size);
status = -EINVAL;
goto error_release_fw;
}
fw_ptr = (unsigned int *)fw->data;
fw_word_size = fw->size/sizeof(uint32_t);
yamato_device->pfp_fw_size = fw_word_size;
/* keep a copy of fw to be reloaded later */
yamato_device->pfp_fw = (unsigned int *)
kmalloc(fw->size, GFP_KERNEL);
if (yamato_device->pfp_fw == NULL) {
KGSL_DRV_ERR("ERROR: couldn't kmalloc fw size= %d.\n",
fw->size);
status = -EINVAL;
goto error_release_fw;
}
memcpy(yamato_device->pfp_fw, fw->data, fw->size);
} else {
fw_ptr = yamato_device->pfp_fw;
fw_word_size = yamato_device->pfp_fw_size;
}
KGSL_DRV_INFO("loading pfp ucode version: %d\n", fw_ptr[0]);
kgsl_yamato_regwrite(device, REG_CP_PFP_UCODE_ADDR, 0);
for (i = 1; i < fw_word_size; i++)
kgsl_yamato_regwrite(device, REG_CP_PFP_UCODE_DATA, fw_ptr[i]);
error_release_fw:
if (fw)
release_firmware(fw);
return status;
}
int kgsl_pwrctrl_clk(struct kgsl_device *device, unsigned int pwrflag)
{
struct kgsl_pwrctrl *pwr = &device->pwrctrl;
int ret = 0;
switch (pwrflag) {
case KGSL_PWRFLAGS_CLK_OFF:
if (pwr->power_flags & KGSL_PWRFLAGS_CLK_ON) {
KGSL_DRV_INFO("clocks off, device %d sleep 10uSec\n", device->id);
if (pwr->grp_pclk)
clk_disable(pwr->grp_pclk);
clk_disable(pwr->grp_clk);
if (pwr->imem_clk != NULL)
clk_disable(pwr->imem_clk);
if (pwr->imem_pclk != NULL)
clk_disable(pwr->imem_pclk);
if (pwr->clk_freq[KGSL_MIN_FREQ]) {
ret = clk_set_rate(pwr->grp_src_clk,
pwr->clk_freq[KGSL_MIN_FREQ]);
if (ret < 0)
KGSL_DRV_ERR("grp_src Err %d\n", ret);
}
usleep(10);
pwr->power_flags &=
~(KGSL_PWRFLAGS_CLK_ON);
pwr->power_flags |= KGSL_PWRFLAGS_CLK_OFF;
}
return KGSL_SUCCESS;
case KGSL_PWRFLAGS_CLK_ON:
if (pwr->power_flags & KGSL_PWRFLAGS_CLK_OFF) {
KGSL_DRV_INFO("clocks on, device %d sleep 100uSec\n", device->id);
if (pwr->clk_freq[KGSL_MAX_FREQ]) {
ret = clk_set_rate(pwr->grp_src_clk,
pwr->clk_freq[KGSL_MAX_FREQ]);
if (ret < 0)
KGSL_DRV_ERR("grp_src Err %d\n", ret);
}
if (pwr->grp_pclk) {
ret = clk_enable(pwr->grp_pclk);
if (ret < 0)
KGSL_DRV_ERR("grp_pclk Err %d\n", ret);
}
ret = clk_enable(pwr->grp_clk);
if (ret < 0)
KGSL_DRV_ERR("grp_clk returns %d\n", ret);
if (pwr->imem_clk != NULL) {
ret = clk_enable(pwr->imem_clk);
if (ret < 0)
KGSL_DRV_ERR("imem_clk Err %d\n", ret);
}
if (pwr->imem_pclk != NULL) {
ret = clk_enable(pwr->imem_pclk);
if (ret < 0)
KGSL_DRV_ERR("imem_pclk Err %d\n", ret);
}
usleep(100);
pwr->power_flags &=
~(KGSL_PWRFLAGS_CLK_OFF);
pwr->power_flags |= KGSL_PWRFLAGS_CLK_ON;
}
return KGSL_SUCCESS;
default:
return KGSL_FAILURE;
}
}
