"VEGA12",
        "VEGA20",
        "RAVEN",
-       "PICASSO",
        "LAST",
 };
 
        case CHIP_RAVEN:
                if (adev->rev_id >= 8)
                        chip_name = "raven2";
+               else if (adev->pdev->device == 0x15d8)
+                       chip_name = "picasso";
                else
                        chip_name = "raven";
                break;
-       case CHIP_PICASSO:
-               chip_name = "picasso";
-               break;
        }
 
        snprintf(fw_name, sizeof(fw_name), "amdgpu/%s_gpu_info.bin", chip_name);
        case CHIP_VEGA12:
        case CHIP_VEGA20:
        case CHIP_RAVEN:
-       case CHIP_PICASSO:
-               if ((adev->asic_type == CHIP_RAVEN) || (adev->asic_type == CHIP_PICASSO))
+               if (adev->asic_type == CHIP_RAVEN)
                        adev->family = AMDGPU_FAMILY_RV;
                else
                        adev->family = AMDGPU_FAMILY_AI;
        case CHIP_VEGA20:
 #if defined(CONFIG_DRM_AMD_DC_DCN1_0)
        case CHIP_RAVEN:
-       case CHIP_PICASSO:
 #endif
                return amdgpu_dc != 0;
 #endif
 
        {0x1002, 0x66AF, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_VEGA20},
        /* Raven */
        {0x1002, 0x15dd, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RAVEN|AMD_IS_APU},
-       /* Picasso */
-       {0x1002, 0x15d8, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_PICASSO|AMD_IS_APU},
+       {0x1002, 0x15d8, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RAVEN|AMD_IS_APU},
 
        {0, 0, 0}
 };
 
                psp_v3_1_set_psp_funcs(psp);
                break;
        case CHIP_RAVEN:
-       case CHIP_PICASSO:
                psp_v10_0_set_psp_funcs(psp);
                break;
        case CHIP_VEGA20:
 
                        return AMDGPU_FW_LOAD_SMU;
        case CHIP_VEGA10:
        case CHIP_RAVEN:
-       case CHIP_PICASSO:
        case CHIP_VEGA12:
        case CHIP_VEGA20:
                if (!load_type)
 
 
        switch (adev->asic_type) {
        case CHIP_RAVEN:
-        if (adev->rev_id >= 8)
+               if (adev->rev_id >= 8)
                        fw_name = FIRMWARE_RAVEN2;
+               else if (adev->pdev->device == 0x15d8)
+                       fw_name = FIRMWARE_PICASSO;
                else
                        fw_name = FIRMWARE_RAVEN;
                break;
-       case CHIP_PICASSO:
-               fw_name = FIRMWARE_PICASSO;
-               break;
        default:
                return -EINVAL;
        }
 
                vm->use_cpu_for_update = !!(adev->vm_manager.vm_update_mode &
                                                AMDGPU_VM_USE_CPU_FOR_COMPUTE);
 
-               if (adev->asic_type == CHIP_RAVEN || adev->asic_type == CHIP_PICASSO)
+               if (adev->asic_type == CHIP_RAVEN)
                        vm->pte_support_ats = true;
        } else {
                vm->use_cpu_for_update = !!(adev->vm_manager.vm_update_mode &
  */
 int amdgpu_vm_make_compute(struct amdgpu_device *adev, struct amdgpu_vm *vm, unsigned int pasid)
 {
-       bool pte_support_ats = (adev->asic_type == CHIP_RAVEN || adev->asic_type == CHIP_PICASSO);
+       bool pte_support_ats = (adev->asic_type == CHIP_RAVEN);
        int r;
 
        r = amdgpu_bo_reserve(vm->root.base.bo, true);
 
 #define VEGA10_GB_ADDR_CONFIG_GOLDEN 0x2a114042
 #define VEGA12_GB_ADDR_CONFIG_GOLDEN 0x24104041
 #define RAVEN_GB_ADDR_CONFIG_GOLDEN 0x24000042
-#define PICASSO_GB_ADDR_CONFIG_GOLDEN 0x24000042
 #define RAVEN2_GB_ADDR_CONFIG_GOLDEN 0x26013041
 
 static void gfx_v9_0_set_ring_funcs(struct amdgpu_device *adev);
                                                        golden_settings_gc_9_1_rv1,
                                                        ARRAY_SIZE(golden_settings_gc_9_1_rv1));
                break;
-       case CHIP_PICASSO:
-               soc15_program_register_sequence(adev,
-                                                golden_settings_gc_9_1,
-                                                ARRAY_SIZE(golden_settings_gc_9_1));
-               soc15_program_register_sequence(adev,
-                                                golden_settings_gc_9_1_rv1,
-                                                ARRAY_SIZE(golden_settings_gc_9_1_rv1));
-               break;
        default:
                break;
        }
        case CHIP_RAVEN:
                if (adev->rev_id >= 8)
                        chip_name = "raven2";
+               else if (adev->pdev->device == 0x15d8)
+                       chip_name = "picasso";
                else
                        chip_name = "raven";
                break;
-       case CHIP_PICASSO:
-               chip_name = "picasso";
-               break;
        default:
                BUG();
        }
                amdgpu_bo_unreserve(adev->gfx.rlc.clear_state_obj);
        }
 
-       if (adev->asic_type == CHIP_RAVEN || adev->asic_type == CHIP_PICASSO) {
+       if (adev->asic_type == CHIP_RAVEN) {
                /* TODO: double check the cp_table_size for RV */
                adev->gfx.rlc.cp_table_size = ALIGN(96 * 5 * 4, 2048) + (64 * 1024); /* JT + GDS */
                r = amdgpu_bo_create_reserved(adev, adev->gfx.rlc.cp_table_size,
                else
                        gb_addr_config = RAVEN_GB_ADDR_CONFIG_GOLDEN;
                break;
-       case CHIP_PICASSO:
-               adev->gfx.config.max_hw_contexts = 8;
-               adev->gfx.config.sc_prim_fifo_size_frontend = 0x20;
-               adev->gfx.config.sc_prim_fifo_size_backend = 0x100;
-               adev->gfx.config.sc_hiz_tile_fifo_size = 0x30;
-               adev->gfx.config.sc_earlyz_tile_fifo_size = 0x4C0;
-               gb_addr_config = PICASSO_GB_ADDR_CONFIG_GOLDEN;
-               break;
        default:
                BUG();
                break;
        case CHIP_VEGA12:
        case CHIP_VEGA20:
        case CHIP_RAVEN:
-       case CHIP_PICASSO:
                adev->gfx.mec.num_mec = 2;
                break;
        default:
        amdgpu_bo_free_kernel(&adev->gfx.rlc.clear_state_obj,
                                &adev->gfx.rlc.clear_state_gpu_addr,
                                (void **)&adev->gfx.rlc.cs_ptr);
-       if ((adev->asic_type == CHIP_RAVEN) || (adev->asic_type == CHIP_PICASSO)) {
+       if (adev->asic_type == CHIP_RAVEN) {
                amdgpu_bo_free_kernel(&adev->gfx.rlc.cp_table_obj,
                                &adev->gfx.rlc.cp_table_gpu_addr,
                                (void **)&adev->gfx.rlc.cp_table_ptr);
                        return r;
        }
 
-       if (adev->asic_type == CHIP_RAVEN || adev->asic_type == CHIP_PICASSO) {
+       if (adev->asic_type == CHIP_RAVEN) {
                if (amdgpu_lbpw != 0)
                        gfx_v9_0_enable_lbpw(adev, true);
                else
 
        switch (adev->asic_type) {
        case CHIP_RAVEN:
-       case CHIP_PICASSO:
                if (!enable) {
                        amdgpu_gfx_off_ctrl(adev, false);
                        cancel_delayed_work_sync(&adev->gfx.gfx_off_delay_work);
        case CHIP_VEGA12:
        case CHIP_VEGA20:
        case CHIP_RAVEN:
-       case CHIP_PICASSO:
                gfx_v9_0_update_gfx_clock_gating(adev,
                                                 state == AMD_CG_STATE_GATE ? true : false);
                break;
        case CHIP_VEGA12:
        case CHIP_VEGA20:
        case CHIP_RAVEN:
-       case CHIP_PICASSO:
                adev->gfx.rlc.funcs = &gfx_v9_0_rlc_funcs;
                break;
        default:
 
                        adev->gmc.gart_size = 512ULL << 20;
                        break;
                case CHIP_RAVEN:   /* DCE SG support */
-               case CHIP_PICASSO:   /* DCE SG support */
                        adev->gmc.gart_size = 1024ULL << 20;
                        break;
                }
        adev->gmc.vram_type = amdgpu_atomfirmware_get_vram_type(adev);
        switch (adev->asic_type) {
        case CHIP_RAVEN:
-       case CHIP_PICASSO:
                if (adev->rev_id == 0x0 || adev->rev_id == 0x1) {
                        amdgpu_vm_adjust_size(adev, 256 * 1024, 9, 3, 48);
                } else {
        case CHIP_VEGA12:
                break;
        case CHIP_RAVEN:
-       case CHIP_PICASSO:
                soc15_program_register_sequence(adev,
                                                golden_settings_athub_1_0_0,
                                                ARRAY_SIZE(golden_settings_athub_1_0_0));
 
        switch (adev->asic_type) {
        case CHIP_RAVEN:
-       case CHIP_PICASSO:
                mmhub_v1_0_update_power_gating(adev, true);
                break;
        default:
 
 
        def  = data  = RREG32_SOC15(MMHUB, 0, mmATC_L2_MISC_CG);
 
-       if (adev->asic_type != CHIP_RAVEN && adev->asic_type != CHIP_PICASSO) {
+       if (adev->asic_type != CHIP_RAVEN) {
                def1 = data1 = RREG32_SOC15(MMHUB, 0, mmDAGB0_CNTL_MISC2);
                def2 = data2 = RREG32_SOC15(MMHUB, 0, mmDAGB1_CNTL_MISC2);
        } else
                           DAGB0_CNTL_MISC2__DISABLE_TLBWR_CG_MASK |
                           DAGB0_CNTL_MISC2__DISABLE_TLBRD_CG_MASK);
 
-               if (adev->asic_type != CHIP_RAVEN && adev->asic_type != CHIP_PICASSO)
+               if (adev->asic_type != CHIP_RAVEN)
                        data2 &= ~(DAGB1_CNTL_MISC2__DISABLE_WRREQ_CG_MASK |
                                   DAGB1_CNTL_MISC2__DISABLE_WRRET_CG_MASK |
                                   DAGB1_CNTL_MISC2__DISABLE_RDREQ_CG_MASK |
                          DAGB0_CNTL_MISC2__DISABLE_TLBWR_CG_MASK |
                          DAGB0_CNTL_MISC2__DISABLE_TLBRD_CG_MASK);
 
-               if (adev->asic_type != CHIP_RAVEN && adev->asic_type != CHIP_PICASSO)
+               if (adev->asic_type != CHIP_RAVEN)
                        data2 |= (DAGB1_CNTL_MISC2__DISABLE_WRREQ_CG_MASK |
                                  DAGB1_CNTL_MISC2__DISABLE_WRRET_CG_MASK |
                                  DAGB1_CNTL_MISC2__DISABLE_RDREQ_CG_MASK |
                WREG32_SOC15(MMHUB, 0, mmATC_L2_MISC_CG, data);
 
        if (def1 != data1) {
-               if (adev->asic_type != CHIP_RAVEN && adev->asic_type != CHIP_PICASSO)
+               if (adev->asic_type != CHIP_RAVEN)
                        WREG32_SOC15(MMHUB, 0, mmDAGB0_CNTL_MISC2, data1);
                else
                        WREG32_SOC15(MMHUB, 0, mmDAGB0_CNTL_MISC2_RV, data1);
        }
 
-       if (adev->asic_type != CHIP_RAVEN && adev->asic_type != CHIP_PICASSO && def2 != data2)
+       if (adev->asic_type != CHIP_RAVEN && def2 != data2)
                WREG32_SOC15(MMHUB, 0, mmDAGB1_CNTL_MISC2, data2);
 }
 
        case CHIP_VEGA12:
        case CHIP_VEGA20:
        case CHIP_RAVEN:
-       case CHIP_PICASSO:
                mmhub_v1_0_update_medium_grain_clock_gating(adev,
                                state == AMD_CG_STATE_GATE ? true : false);
                athub_update_medium_grain_clock_gating(adev,
 
        case CHIP_RAVEN:
                if (adev->rev_id >= 0x8)
                        chip_name = "raven2";
+               else if (adev->pdev->device == 0x15d8)
+                       chip_name = "picasso";
                else
                        chip_name = "raven";
                break;
-       case CHIP_PICASSO:
-               chip_name = "picasso";
-               break;
        default: BUG();
        }
 
 
                                                ARRAY_SIZE(golden_settings_sdma1_4_2));
                break;
        case CHIP_RAVEN:
-       case CHIP_PICASSO:
                soc15_program_register_sequence(adev,
                                                golden_settings_sdma_4_1,
                                                ARRAY_SIZE(golden_settings_sdma_4_1));
        case CHIP_RAVEN:
                if (adev->rev_id >= 8)
                        chip_name = "raven2";
+               else if (adev->pdev->device == 0x15d8)
+                       chip_name = "picasso";
                else
                        chip_name = "raven";
                break;
-       case CHIP_PICASSO:
-               chip_name = "picasso";
-               break;
        default:
                BUG();
        }
 
        switch (adev->asic_type) {
        case CHIP_RAVEN:
-       case CHIP_PICASSO:
                sdma_v4_1_init_power_gating(adev);
                sdma_v4_1_update_power_gating(adev, true);
                break;
 {
        struct amdgpu_device *adev = (struct amdgpu_device *)handle;
 
-       if (adev->asic_type == CHIP_RAVEN || adev->asic_type == CHIP_PICASSO)
+       if (adev->asic_type == CHIP_RAVEN)
                adev->sdma.num_instances = 1;
        else
                adev->sdma.num_instances = 2;
        case CHIP_VEGA12:
        case CHIP_VEGA20:
        case CHIP_RAVEN:
-       case CHIP_PICASSO:
                sdma_v4_0_update_medium_grain_clock_gating(adev,
                                state == AMD_CG_STATE_GATE ? true : false);
                sdma_v4_0_update_medium_grain_light_sleep(adev,
 
        switch (adev->asic_type) {
        case CHIP_RAVEN:
-       case CHIP_PICASSO:
                sdma_v4_1_update_power_gating(adev,
                                state == AMD_PG_STATE_GATE ? true : false);
                break;
 
        case CHIP_VEGA10:
        case CHIP_VEGA12:
        case CHIP_RAVEN:
-       case CHIP_PICASSO:
                vega10_reg_base_init(adev);
                break;
        case CHIP_VEGA20:
                amdgpu_device_ip_block_add(adev, &vce_v4_0_ip_block);
                break;
        case CHIP_RAVEN:
-       case CHIP_PICASSO:
                amdgpu_device_ip_block_add(adev, &vega10_common_ip_block);
                amdgpu_device_ip_block_add(adev, &gmc_v9_0_ip_block);
                amdgpu_device_ip_block_add(adev, &vega10_ih_ip_block);
                break;
        case CHIP_RAVEN:
                if (adev->rev_id >= 0x8)
+                       adev->external_rev_id = adev->rev_id + 0x81;
+               else if (adev->pdev->device == 0x15d8)
+                       adev->external_rev_id = adev->rev_id + 0x41;
+               else
+                       adev->external_rev_id = 0x1;
+
+               if (adev->rev_id >= 0x8) {
                        adev->cg_flags = AMD_CG_SUPPORT_GFX_MGCG |
                                AMD_CG_SUPPORT_GFX_MGLS |
                                AMD_CG_SUPPORT_GFX_CP_LS |
                                AMD_CG_SUPPORT_SDMA_MGCG |
                                AMD_CG_SUPPORT_SDMA_LS |
                                AMD_CG_SUPPORT_VCN_MGCG;
-               else
+
+                       adev->pg_flags = AMD_PG_SUPPORT_SDMA | AMD_PG_SUPPORT_VCN;
+               } else if (adev->pdev->device == 0x15d8) {
+                       adev->cg_flags = AMD_CG_SUPPORT_GFX_MGLS |
+                               AMD_CG_SUPPORT_GFX_CP_LS |
+                               AMD_CG_SUPPORT_GFX_3D_CGCG |
+                               AMD_CG_SUPPORT_GFX_3D_CGLS |
+                               AMD_CG_SUPPORT_GFX_CGCG |
+                               AMD_CG_SUPPORT_GFX_CGLS |
+                               AMD_CG_SUPPORT_BIF_LS |
+                               AMD_CG_SUPPORT_HDP_LS |
+                               AMD_CG_SUPPORT_ROM_MGCG |
+                               AMD_CG_SUPPORT_MC_MGCG |
+                               AMD_CG_SUPPORT_MC_LS |
+                               AMD_CG_SUPPORT_SDMA_MGCG |
+                               AMD_CG_SUPPORT_SDMA_LS;
+
+                       adev->pg_flags = AMD_PG_SUPPORT_SDMA |
+                               AMD_PG_SUPPORT_MMHUB |
+                               AMD_PG_SUPPORT_VCN;
+               } else {
                        adev->cg_flags = AMD_CG_SUPPORT_GFX_MGCG |
                                AMD_CG_SUPPORT_GFX_MGLS |
                                AMD_CG_SUPPORT_GFX_RLC_LS |
                                AMD_CG_SUPPORT_SDMA_LS |
                                AMD_CG_SUPPORT_VCN_MGCG;
 
-               adev->pg_flags = AMD_PG_SUPPORT_SDMA | AMD_PG_SUPPORT_VCN;
-
-               if (adev->powerplay.pp_feature & PP_GFXOFF_MASK)
-                       adev->pg_flags |= AMD_PG_SUPPORT_GFX_PG |
-                               AMD_PG_SUPPORT_CP |
-                               AMD_PG_SUPPORT_RLC_SMU_HS;
-
-               if (adev->rev_id >= 0x8)
-                       adev->external_rev_id = adev->rev_id + 0x81;
-               else
-                       adev->external_rev_id = 0x1;
-               break;
-       case CHIP_PICASSO:
-               adev->cg_flags = AMD_CG_SUPPORT_GFX_MGLS |
-                       AMD_CG_SUPPORT_GFX_CP_LS |
-                       AMD_CG_SUPPORT_GFX_3D_CGCG |
-                       AMD_CG_SUPPORT_GFX_3D_CGLS |
-                       AMD_CG_SUPPORT_GFX_CGCG |
-                       AMD_CG_SUPPORT_GFX_CGLS |
-                       AMD_CG_SUPPORT_BIF_LS |
-                       AMD_CG_SUPPORT_HDP_LS |
-                       AMD_CG_SUPPORT_ROM_MGCG |
-                       AMD_CG_SUPPORT_MC_MGCG |
-                       AMD_CG_SUPPORT_MC_LS |
-                       AMD_CG_SUPPORT_SDMA_MGCG |
-                       AMD_CG_SUPPORT_SDMA_LS;
-
-               adev->pg_flags = AMD_PG_SUPPORT_SDMA |
-                                               AMD_PG_SUPPORT_MMHUB |
-                                               AMD_PG_SUPPORT_VCN;
+                       adev->pg_flags = AMD_PG_SUPPORT_SDMA | AMD_PG_SUPPORT_VCN;
+               }
 
                if (adev->powerplay.pp_feature & PP_GFXOFF_MASK)
                        adev->pg_flags |= AMD_PG_SUPPORT_GFX_PG |
                                AMD_PG_SUPPORT_CP |
                                AMD_PG_SUPPORT_RLC_SMU_HS;
-
-               adev->external_rev_id = adev->rev_id + 0x41;
                break;
        default:
                /* FIXME: not supported yet */
                                state == AMD_CG_STATE_GATE ? true : false);
                break;
        case CHIP_RAVEN:
-       case CHIP_PICASSO:
                adev->nbio_funcs->update_medium_grain_clock_gating(adev,
                                state == AMD_CG_STATE_GATE ? true : false);
                adev->nbio_funcs->update_medium_grain_light_sleep(adev,
 
        if (adev->asic_type == CHIP_VEGA10 ||
            adev->asic_type == CHIP_VEGA12 ||
            adev->asic_type == CHIP_VEGA20 ||
-           adev->asic_type == CHIP_RAVEN  ||
-           adev->asic_type == CHIP_PICASSO)
+           adev->asic_type == CHIP_RAVEN)
                client_id = SOC15_IH_CLIENTID_DCE;
 
        int_params.requested_polarity = INTERRUPT_POLARITY_DEFAULT;
                break;
 #if defined(CONFIG_DRM_AMD_DC_DCN1_0)
        case CHIP_RAVEN:
-       case CHIP_PICASSO:
                if (dcn10_register_irq_handlers(dm->adev)) {
                        DRM_ERROR("DM: Failed to initialize IRQ\n");
                        goto fail;
                break;
 #if defined(CONFIG_DRM_AMD_DC_DCN1_0)
        case CHIP_RAVEN:
-       case CHIP_PICASSO:
                adev->mode_info.num_crtc = 4;
                adev->mode_info.num_hpd = 4;
                adev->mode_info.num_dig = 4;
        if (adev->asic_type == CHIP_VEGA10 ||
            adev->asic_type == CHIP_VEGA12 ||
            adev->asic_type == CHIP_VEGA20 ||
-           adev->asic_type == CHIP_RAVEN  ||
-           adev->asic_type == CHIP_PICASSO) {
+           adev->asic_type == CHIP_RAVEN) {
                /* Fill GFX9 params */
                plane_state->tiling_info.gfx9.num_pipes =
                        adev->gfx.config.gb_addr_config_fields.num_pipes;
 
        case AMDGPU_FAMILY_RV:
                switch (hwmgr->chip_id) {
                case CHIP_RAVEN:
-               case CHIP_PICASSO:
                        hwmgr->od_enabled = false;
                        hwmgr->smumgr_funcs = &smu10_smu_funcs;
                        smu10_init_function_pointers(hwmgr);
 
        uint16_t size;
 
        if (!table_addr) {
-               if (hwmgr->chip_id == CHIP_RAVEN || hwmgr->chip_id == CHIP_PICASSO) {
+               if (hwmgr->chip_id == CHIP_RAVEN) {
                        table_addr = &soft_dummy_pp_table[0];
                        hwmgr->soft_pp_table = &soft_dummy_pp_table[0];
                        hwmgr->soft_pp_table_size = sizeof(soft_dummy_pp_table);
        hwmgr->platform_descriptor.maxOverdriveVDDC = 0;
        hwmgr->platform_descriptor.overdriveVDDCStep = 0;
 
-       if (hwmgr->chip_id == CHIP_RAVEN || hwmgr->chip_id == CHIP_PICASSO)
+       if (hwmgr->chip_id == CHIP_RAVEN)
                return 0;
 
        /* We assume here that fw_info is unchanged if this call fails.*/
        int result;
        const ATOM_PPLIB_POWERPLAYTABLE *powerplay_table;
 
-       if (hwmgr->chip_id == CHIP_RAVEN || hwmgr->chip_id == CHIP_PICASSO)
+       if (hwmgr->chip_id == CHIP_RAVEN)
                return 0;
 
        hwmgr->need_pp_table_upload = true;
 
 static int pp_tables_uninitialize(struct pp_hwmgr *hwmgr)
 {
-       if (hwmgr->chip_id == CHIP_RAVEN || hwmgr->chip_id == CHIP_PICASSO)
+       if (hwmgr->chip_id == CHIP_RAVEN)
                return 0;
 
        kfree(hwmgr->dyn_state.vddc_dependency_on_sclk);
 
        CHIP_VEGA12,
        CHIP_VEGA20,
        CHIP_RAVEN,
-       CHIP_PICASSO,
        CHIP_LAST,
 };