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; } }